local_participant.h

/*
 * Copyright 2025 LiveKit
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an “AS IS” BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
#pragma once
 
#include <atomic>
#include <condition_variable>
#include <cstdint>
#include <functional>
#include <memory>
#include <mutex>
#include <optional>
#include <string>
#include <unordered_map>
#include <vector>
 
#include "livekit/data_track_error.h"
#include "livekit/data_track_options.h"
#include "livekit/data_track_schema.h"
#include "livekit/ffi_handle.h"
#include "livekit/local_audio_track.h"
#include "livekit/local_data_track.h"
#include "livekit/local_video_track.h"
#include "livekit/participant.h"
#include "livekit/result.h"
#include "livekit/room_event_types.h"
#include "livekit/rpc_error.h"
#include "livekit/visibility.h"
 
namespace livekit {
 
struct ParticipantTrackPermission;
 
class FfiClient;
class Track;
class LocalTrackPublication;
 
struct RpcInvocationData {
  std::string request_id;
  std::string caller_identity;
  std::string payload;
  double response_timeout_sec; // seconds
};
 
class LIVEKIT_API LocalParticipant : public Participant {
public:
  using PublicationMap = std::unordered_map<std::string, std::shared_ptr<LocalTrackPublication>>;
  using TrackMap = std::unordered_map<std::string, std::weak_ptr<Track>>;
 
  using RpcHandler = std::function<std::optional<std::string>(const RpcInvocationData&)>;
 
  LocalParticipant(FfiHandle handle, std::string sid, std::string name, std::string identity, std::string metadata,
                   std::unordered_map<std::string, std::string> attributes, ParticipantKind kind,
                   DisconnectReason reason);
 
  PublicationMap trackPublications() const;
 
  void publishData(const std::vector<std::uint8_t>& payload, bool reliable = true,
                   const std::vector<std::string>& destination_identities = {}, const std::string& topic = {});
 
  void publishDtmf(int code, const std::string& digit);
 
  void setMetadata(const std::string& metadata);
 
  void setName(const std::string& name);
 
  void setAttributes(const std::unordered_map<std::string, std::string>& attributes);
 
  void setTrackSubscriptionPermissions(bool allow_all_participants,
                                       const std::vector<ParticipantTrackPermission>& participant_permissions = {});
 
  void publishTrack(const std::shared_ptr<Track>& track, const TrackPublishOptions& options);
 
  std::shared_ptr<LocalVideoTrack> publishVideoTrack(const std::string& name,
                                                     const std::shared_ptr<VideoSource>& source,
                                                     TrackSource track_source);
 
  std::shared_ptr<LocalAudioTrack> publishAudioTrack(const std::string& name,
                                                     const std::shared_ptr<AudioSource>& source,
                                                     TrackSource track_source);
 
  void unpublishTrack(const std::string& track_sid);
 
  Result<std::shared_ptr<LocalDataTrack>, PublishDataTrackError> publishDataTrack(const std::string& name);
 
  Result<std::shared_ptr<LocalDataTrack>, PublishDataTrackError> publishDataTrack(
      const DataTrackPublishOptions& options);
 
  void unpublishDataTrack(const std::shared_ptr<LocalDataTrack>& track);
 
  bool defineSchema(const DataTrackSchemaId& id, const std::string& definition);
 
  std::optional<std::string> getSchema(const DataTrackSchemaId& id, const std::string& participant_identity);
 
  std::string performRpc(const std::string& destination_identity, const std::string& method, const std::string& payload,
                         const std::optional<double>& response_timeout = std::nullopt);
 
  void registerRpcMethod(const std::string& method_name, RpcHandler handler);
 
  void unregisterRpcMethod(const std::string& method_name);
 
protected:
  void shutdown();
  void handleRpcMethodInvocation(std::uint64_t invocation_id, const std::string& method, const std::string& request_id,
                                 const std::string& caller_identity, const std::string& payload,
                                 double response_timeout);
  std::shared_ptr<TrackPublication> findTrackPublication(const std::string& sid) const override;
  friend class Room;
 
private:
  mutable TrackMap published_tracks_by_sid_;
 
  std::unordered_map<std::string, RpcHandler> rpc_handlers_;
 
  // Shared state for RPC invocation tracking. Using shared_ptr so the state
  // can outlive the LocalParticipant if there are in-flight invocations when
  // the participant is destroyed.
  struct RpcInvocationState {
    std::mutex mutex;
    std::condition_variable cv;
    int active_invocations = 0;
    bool shutting_down = false;
  };
  std::shared_ptr<RpcInvocationState> rpc_state_ = std::make_shared<RpcInvocationState>();
};
 
} // namespace livekit