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 "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/room_event_types.h"
#include "livekit/rpc_error.h"
 
#include <atomic>
#include <condition_variable>
#include <cstdint>
#include <functional>
#include <memory>
#include <mutex>
#include <string>
#include <unordered_map>
#include <vector>
 
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 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);
 
  // -------------------------------------------------------------------------
  // Metadata APIs (set metadata / name / attributes)
  // -------------------------------------------------------------------------
 
  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);
 
  void unpublishDataTrack(const std::shared_ptr<LocalDataTrack> &track);
 
  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();
  // Called by Room when an rpc_method_invocation event is received from the
  // SFU. This is internal plumbing and not intended to be called directly by
  // SDK users.
  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);
  // Called by Room events like kTrackMuted.
  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