const auto &pinfo = owned.info();

std::unordered_map<std::string, std::string> attrs;

attrs.reserve(pinfo.attributes_size());

for (const auto &kv : pinfo.attributes()) {

attrs.emplace(kv.first, kv.second);

}

auto kind = livekit::fromProto(pinfo.kind());

auto reason = livekit::toDisconnectReason(pinfo.disconnect_reason());

livekit::FfiHandle handle(static_cast<uintptr_t>(owned.handle().id()));

return std::make_shared<livekit::RemoteParticipant>(

std::move(handle), pinfo.sid(), pinfo.name(), pinfo.identity(),

pinfo.metadata(), std::move(attrs), kind, reason);

const RoomOptions &options) {

{

std::lock_guard<std::mutex> g(lock_);

if (connection_state_ != ConnectionState::Disconnected) {

throw std::runtime_error("already connected");

}

connection_state_ = ConnectionState::Reconnecting;

}

auto fut = FfiClient::instance().connectAsync(url, token, options);

try {

auto connectCb =

fut.get(); // fut will throw if it fails to connect to the room

const auto &owned_room = connectCb.result().room();

auto new_room_handle =

std::make_shared<FfiHandle>(owned_room.handle().id());

auto new_room_info = fromProto(owned_room.info());

// Setup local particpant

std::unique_ptr<LocalParticipant> new_local_participant;

{

const auto &owned_local = connectCb.result().local_participant();

const auto &pinfo = owned_local.info();

// Build attributes map

std::unordered_map<std::string, std::string> attrs;

for (const auto &kv : pinfo.attributes()) {

attrs.emplace(kv.first, kv.second);

}

auto kind = fromProto(pinfo.kind());

auto reason = toDisconnectReason(pinfo.disconnect_reason());

// Participant base stores a weak_ptr<FfiHandle>, so share the room handle

FfiHandle participant_handle(

static_cast<uintptr_t>(owned_local.handle().id()));

new_local_participant = std::make_unique<LocalParticipant>(

std::move(participant_handle), pinfo.sid(), pinfo.name(),

pinfo.identity(), pinfo.metadata(), std::move(attrs), kind, reason);

}

// Setup remote participants

std::unordered_map<std::string, std::shared_ptr<RemoteParticipant>>

new_remote_participants;

{

const auto &participants = connectCb.result().participants();

std::lock_guard<std::mutex> g(lock_);

for (const auto &pt : participants) {

const auto &owned = pt.participant();

auto rp = createRemoteParticipant(owned);

// Add the initial remote participant tracks

for (const auto &owned_publication_info : pt.publications()) {

auto publication =

std::make_shared<RemoteTrackPublication>(owned_publication_info);

rp->mutableTrackPublications().emplace(publication->sid(),

std::move(publication));

}

new_remote_participants.emplace(rp->identity(), std::move(rp));

}

}

// Setup e2eeManager

std::unique_ptr<E2EEManager> new_e2ee_manager;

if (options.encryption) {

LK_LOG_INFO("creating E2eeManager");

e2ee_manager_ = std::unique_ptr<E2EEManager>(

new E2EEManager(room_handle_->get(), options.encryption.value()));

}

// Publish all state atomically under lock

{

std::lock_guard<std::mutex> g(lock_);

room_handle_ = std::move(new_room_handle);

room_info_ = std::move(new_room_info);

local_participant_ = std::move(new_local_participant);

remote_participants_ = std::move(new_remote_participants);

e2ee_manager_ = std::move(new_e2ee_manager);

connection_state_ = ConnectionState::Connected;

}

// Install listener (Room is fully initialized)

auto listenerId = FfiClient::instance().AddListener(

std::bind(&Room::OnEvent, this, std::placeholders::_1));

{

std::lock_guard<std::mutex> g(lock_);

listener_id_ = listenerId;

}

return true;

} catch (const std::exception &e) {

// On error, set the connection_state_ to Disconnected

connection_state_ = ConnectionState::Disconnected;

LK_LOG_ERROR("Room::Connect failed: {}", e.what());

return false;

}

std::lock_guard<std::mutex> guard(lock_);

std::vector<std::shared_ptr<RemoteParticipant>> out;

out.reserve(remote_participants_.size());

for (const auto &kv : remote_participants_) {

out.push_back(kv.second);

}

return out;

TextStreamHandler handler) {

std::lock_guard<std::mutex> g(lock_);

auto [it, inserted] =

text_stream_handlers_.emplace(topic, std::move(handler));

if (!inserted) {

throw std::runtime_error("text stream handler for topic '" + topic +

"' already set");

}

ByteStreamHandler handler) {

std::lock_guard<std::mutex> g(lock_);

auto [it, inserted] =

byte_stream_handlers_.emplace(topic, std::move(handler));

if (!inserted) {

throw std::runtime_error("byte stream handler for topic '" + topic +

"' already set");

}

// Take a snapshot of the delegate under lock, but do NOT call it under the

// lock.

RoomDelegate *delegate_snapshot = nullptr;

{

std::lock_guard<std::mutex> guard(lock_);

delegate_snapshot = delegate_;

}

// First, handle RPC method invocations (not part of RoomEvent).

if (event.message_case() == FfiEvent::kRpcMethodInvocation) {

const auto &rpc = event.rpc_method_invocation();

LocalParticipant *lp = nullptr;

{

std::lock_guard<std::mutex> guard(lock_);

if (!local_participant_) {

return;

}

auto local_handle = local_participant_->ffiHandleId();

if (local_handle == INVALID_HANDLE ||

rpc.local_participant_handle() !=

static_cast<std::uint64_t>(local_handle)) {

// RPC is not targeted at this room's local participant; ignore.

return;

}

lp = local_participant_.get();

}

// Call outside the lock to avoid deadlocks / re-entrancy issues.

lp->handleRpcMethodInvocation(

rpc.invocation_id(), rpc.method(), rpc.request_id(),

rpc.caller_identity(), rpc.payload(),

static_cast<double>(rpc.response_timeout_ms()) / 1000.0);

return;

}

switch (event.message_case()) {

case FfiEvent::kRoomEvent: {

const proto::RoomEvent &re = event.room_event();

// Check if this event is for our room handle

{

std::lock_guard<std::mutex> guard(lock_);

if (!room_handle_ ||

re.room_handle() != static_cast<std::uint64_t>(room_handle_->get())) {

return;

}

}

switch (re.message_case()) {

case proto::RoomEvent::kParticipantConnected: {

std::shared_ptr<RemoteParticipant> new_participant;

{

std::lock_guard<std::mutex> guard(lock_);

const auto &owned = re.participant_connected().info();

// createRemoteParticipant takes proto::OwnedParticipant

new_participant = createRemoteParticipant(owned);

remote_participants_.emplace(new_participant->identity(),

new_participant);

}

ParticipantConnectedEvent ev;

ev.participant = new_participant.get();

if (delegate_snapshot) {

delegate_snapshot->onParticipantConnected(*this, ev);

}

break;

}

case proto::RoomEvent::kParticipantDisconnected: {

std::shared_ptr<RemoteParticipant> removed;

DisconnectReason reason = DisconnectReason::Unknown;

{

std::lock_guard<std::mutex> guard(lock_);

const auto &pd = re.participant_disconnected();

const std::string &identity = pd.participant_identity();

reason = toDisconnectReason(pd.disconnect_reason());

auto it = remote_participants_.find(identity);

if (it != remote_participants_.end()) {

removed = it->second;

remote_participants_.erase(it);

} else {

// We saw a disconnect event for a participant we don't track

// internally. This can happen on races or if we never created a

// RemoteParticipant

LK_LOG_WARN("participant_disconnected for unknown identity: {}",

identity);

}

}

if (removed) {

ParticipantDisconnectedEvent ev;

ev.participant = removed.get();

ev.reason = reason;

if (delegate_snapshot) {

delegate_snapshot->onParticipantDisconnected(*this, ev);

}

}

break;

}

case proto::RoomEvent::kLocalTrackPublished: {

LocalTrackPublishedEvent ev;

{

std::lock_guard<std::mutex> guard(lock_);

if (!local_participant_) {

LK_LOG_ERROR("kLocalTrackPublished: local_participant_ is nullptr");

break;

}

const auto &ltp = re.local_track_published();

const std::string &sid = ltp.track_sid();

auto &pubs = local_participant_->trackPublications();

auto it = pubs.find(sid);

if (it == pubs.end()) {

LK_LOG_WARN("local_track_published for unknown sid: {}", sid);

break;

}

ev.publication = it->second;

ev.track = ev.publication ? ev.publication->track() : nullptr;

}

if (delegate_snapshot) {

delegate_snapshot->onLocalTrackPublished(*this, ev);

}

break;

}

case proto::RoomEvent::kLocalTrackUnpublished: {

LocalTrackUnpublishedEvent ev;

{

std::lock_guard<std::mutex> guard(lock_);

if (!local_participant_) {

LK_LOG_ERROR("kLocalTrackUnpublished: local_participant_ is nullptr");

break;

}

const auto &ltu = re.local_track_unpublished();

const std::string &pub_sid = ltu.publication_sid();

auto &pubs = local_participant_->trackPublications();

auto it = pubs.find(pub_sid);

if (it == pubs.end()) {

LK_LOG_WARN("local_track_unpublished for unknown publication sid: {}",

pub_sid);

break;

}

ev.publication = it->second;

}

if (delegate_snapshot) {

delegate_snapshot->onLocalTrackUnpublished(*this, ev);

}

break;

}

case proto::RoomEvent::kLocalTrackSubscribed: {

LocalTrackSubscribedEvent ev;

{

std::lock_guard<std::mutex> guard(lock_);

if (!local_participant_) {

break;

}

const auto &lts = re.local_track_subscribed();

const std::string &sid = lts.track_sid();

auto &pubs = local_participant_->trackPublications();

auto it = pubs.find(sid);

if (it == pubs.end()) {

LK_LOG_WARN("local_track_subscribed for unknown sid: {}", sid);

break;

}

auto publication = it->second;

ev.track = publication ? publication->track() : nullptr;

}

if (delegate_snapshot) {

delegate_snapshot->onLocalTrackSubscribed(*this, ev);

}

break;

}

case proto::RoomEvent::kTrackPublished: {

TrackPublishedEvent ev;

{

std::lock_guard<std::mutex> guard(lock_);

const auto &tp = re.track_published();

const std::string &identity = tp.participant_identity();

auto it = remote_participants_.find(identity);

if (it != remote_participants_.end()) {

RemoteParticipant *rparticipant = it->second.get();

const auto &owned_publication = tp.publication();

auto rpublication =

std::make_shared<RemoteTrackPublication>(owned_publication);

// Store it on the participant, keyed by SID

rparticipant->mutableTrackPublications().emplace(

rpublication->sid(), std::move(rpublication));

ev.participant = rparticipant;

ev.publication = rpublication;

} else {

// Optional: log if we get a track for an unknown participant

LK_LOG_WARN("track_published for unknown participant: {}", identity);

// Don't emit the

break;

}

}

if (delegate_snapshot) {

delegate_snapshot->onTrackPublished(*this, ev);

}

break;

}

case proto::RoomEvent::kTrackUnpublished: {

TrackUnpublishedEvent ev;

{

std::lock_guard<std::mutex> guard(lock_);

const auto &tu = re.track_unpublished();

const std::string &identity = tu.participant_identity();

const std::string &pub_sid = tu.publication_sid();

auto pit = remote_participants_.find(identity);

if (pit == remote_participants_.end()) {

LK_LOG_WARN("track_unpublished for unknown participant: {}",

identity);

break;

}

RemoteParticipant *rparticipant = pit->second.get();

auto &pubs = rparticipant->mutableTrackPublications();

auto it = pubs.find(pub_sid);

if (it == pubs.end()) {

LK_LOG_WARN("track_unpublished for unknown publication sid {} "

"(participant {})",

pub_sid, identity);

break;

}

ev.participant = rparticipant;

ev.publication = it->second;

pubs.erase(it);

}

if (delegate_snapshot) {

delegate_snapshot->onTrackUnpublished(*this, ev);

}

break;

}

case proto::RoomEvent::kTrackSubscribed: {

const auto &ts = re.track_subscribed();

const std::string &identity = ts.participant_identity();

const auto &owned_track = ts.track();

const auto &track_info = owned_track.info();

std::shared_ptr<RemoteTrackPublication> rpublication;

RemoteParticipant *rparticipant = nullptr;

std::shared_ptr<Track> remote_track;

{

std::lock_guard<std::mutex> guard(lock_);

// Find participant

auto pit = remote_participants_.find(identity);

if (pit == remote_participants_.end()) {

LK_LOG_WARN("track_subscribed for unknown participant: {}", identity);

break;

}

rparticipant = pit->second.get();

// Find existing publication by track SID (from track_published)

auto &pubs = rparticipant->mutableTrackPublications();

auto pubIt = pubs.find(track_info.sid());

if (pubIt == pubs.end()) {

LK_LOG_WARN("track_subscribed for unknown publication sid {} "

"(participant {})",

track_info.sid(), identity);

break;

}

rpublication = pubIt->second;

// Create RemoteVideoTrack / RemoteAudioTrack

if (track_info.kind() == proto::TrackKind::KIND_VIDEO) {

remote_track = std::make_shared<RemoteVideoTrack>(owned_track);

} else if (track_info.kind() == proto::TrackKind::KIND_AUDIO) {

remote_track = std::make_shared<RemoteAudioTrack>(owned_track);

} else {

LK_LOG_WARN("track_subscribed with unsupported kind: {}",

static_cast<int>(track_info.kind()));

break;

}

// Attach to publication, mark subscribed

rpublication->setTrack(remote_track);

rpublication->setSubscribed(true);

}

// Emit remote track_subscribed-style callback

TrackSubscribedEvent ev;

ev.track = remote_track;

ev.publication = rpublication;

ev.participant = rparticipant;

if (delegate_snapshot) {

delegate_snapshot->onTrackSubscribed(*this, ev);

}

break;

}

case proto::RoomEvent::kTrackUnsubscribed: {

TrackUnsubscribedEvent ev;

{

std::lock_guard<std::mutex> guard(lock_);

const auto &tu = re.track_unsubscribed();

const std::string &identity = tu.participant_identity();

const std::string &track_sid = tu.track_sid();

auto pit = remote_participants_.find(identity);

if (pit == remote_participants_.end()) {

LK_LOG_WARN("track_unsubscribed for unknown participant: {}",

identity);

break;

}

RemoteParticipant *rparticipant = pit->second.get();

auto &pubs = rparticipant->mutableTrackPublications();

auto pubIt = pubs.find(track_sid);

if (pubIt == pubs.end()) {

LK_LOG_WARN("track_unsubscribed for unknown publication sid {} "

"(participant {})",

track_sid, identity);

break;

}

auto publication = pubIt->second;

auto track = publication->track();

publication->setTrack(nullptr);

publication->setSubscribed(false);

ev.participant = rparticipant;

ev.publication = publication;

ev.track = track;

}

if (delegate_snapshot) {

delegate_snapshot->onTrackUnsubscribed(*this, ev);

}

break;

}

case proto::RoomEvent::kTrackSubscriptionFailed: {

TrackSubscriptionFailedEvent ev;

{

std::lock_guard<std::mutex> guard(lock_);

const auto &tsf = re.track_subscription_failed();

const std::string &identity = tsf.participant_identity();

auto pit = remote_participants_.find(identity);

if (pit == remote_participants_.end()) {

LK_LOG_WARN("track_subscription_failed for unknown participant: {}",

identity);

break;

}

ev.participant = pit->second.get();

ev.track_sid = tsf.track_sid();

ev.error = tsf.error();

}

if (delegate_snapshot) {

delegate_snapshot->onTrackSubscriptionFailed(*this, ev);

}

break;

}

case proto::RoomEvent::kTrackMuted: {

TrackMutedEvent ev;

bool success = false;

{

std::lock_guard<std::mutex> guard(lock_);

const auto &tm = re.track_muted();

const std::string &identity = tm.participant_identity();

const std::string &sid = tm.track_sid();

Participant *participant = nullptr;

if (local_participant_ && local_participant_->identity() == identity) {

participant = local_participant_.get();

} else {

auto pit = remote_participants_.find(identity);

if (pit != remote_participants_.end()) {

participant = pit->second.get();

}

}

if (!participant) {

LK_LOG_WARN("track_muted for unknown participant: {}", identity);

break;

}

auto pub = participant->findTrackPublication(sid);

if (!pub) {

LK_LOG_WARN("track_muted for unknown track sid: {}", sid);

} else {

pub->setMuted(true);

if (auto t = pub->track()) {

t->setMuted(true);

}

ev.participant = participant;

ev.publication = pub;

success = true;

}

}

if (success && delegate_snapshot) {

delegate_snapshot->onTrackMuted(*this, ev);

}

break;

}

case proto::RoomEvent::kTrackUnmuted: {

TrackUnmutedEvent ev;

bool success = false;

{

std::lock_guard<std::mutex> guard(lock_);

const auto &tu = re.track_unmuted();

const std::string &identity = tu.participant_identity();

const std::string &sid = tu.track_sid();

Participant *participant = nullptr;

if (local_participant_ && local_participant_->identity() == identity) {

participant = local_participant_.get();

} else {

auto pit = remote_participants_.find(identity);

if (pit != remote_participants_.end()) {

participant = pit->second.get();

}

}

if (!participant) {

LK_LOG_WARN("track_unmuted for unknown participant: {}", identity);

break;

}

auto pub = participant->findTrackPublication(sid);

if (!pub) {

LK_LOG_WARN("track_unmuted for unknown track sid: {}", sid);

} else {

pub->setMuted(false);

if (auto t = pub->track()) {

t->setMuted(false);

}

ev.participant = participant;

ev.publication = pub;

success = true;

}

ev.participant = participant;

ev.publication = pub;

}

if (success && delegate_snapshot) {

delegate_snapshot->onTrackUnmuted(*this, ev);

}

break;

}

case proto::RoomEvent::kActiveSpeakersChanged: {

ActiveSpeakersChangedEvent ev;

{

std::lock_guard<std::mutex> guard(lock_);

const auto &asc = re.active_speakers_changed();

for (const auto &identity : asc.participant_identities()) {

Participant *participant = nullptr;

if (local_participant_ &&

local_participant_->identity() == identity) {

participant = local_participant_.get();

} else {

auto pit = remote_participants_.find(identity);

if (pit != remote_participants_.end()) {

participant = pit->second.get();

}

}

if (participant) {

ev.speakers.push_back(participant);

}

}

}

if (delegate_snapshot) {

delegate_snapshot->onActiveSpeakersChanged(*this, ev);

}

break;

}

case proto::RoomEvent::kRoomMetadataChanged: {

RoomMetadataChangedEvent ev;

{

std::lock_guard<std::mutex> guard(lock_);

const auto old_metadata = room_info_.metadata;

room_info_.metadata = re.room_metadata_changed().metadata();

ev.old_metadata = old_metadata;

ev.new_metadata = room_info_.metadata;

}

if (delegate_snapshot) {

delegate_snapshot->onRoomMetadataChanged(*this, ev);

}

break;

}

case proto::RoomEvent::kRoomSidChanged: {

RoomSidChangedEvent ev;

{

std::lock_guard<std::mutex> guard(lock_);

room_info_.sid = re.room_sid_changed().sid();

ev.sid = room_info_.sid.value_or(std::string{});

}

if (delegate_snapshot) {

delegate_snapshot->onRoomSidChanged(*this, ev);

}

break;

}

case proto::RoomEvent::kParticipantMetadataChanged: {

ParticipantMetadataChangedEvent ev;

{

std::lock_guard<std::mutex> guard(lock_);

const auto &pm = re.participant_metadata_changed();

const std::string &identity = pm.participant_identity();

Participant *participant = nullptr;

if (local_participant_ && local_participant_->identity() == identity) {

participant = local_participant_.get();

} else {

auto it = remote_participants_.find(identity);

if (it != remote_participants_.end()) {

participant = it->second.get();

}

}

if (!participant) {

LK_LOG_WARN(

"participant_metadata_changed for unknown participant: {}",

identity);

break;

}

std::string old_metadata = participant->metadata();

participant->set_metadata(pm.metadata());

ev.participant = participant;

ev.old_metadata = old_metadata;

ev.new_metadata = participant->metadata();

}

if (delegate_snapshot) {

delegate_snapshot->onParticipantMetadataChanged(*this, ev);

}

break;

}

case proto::RoomEvent::kParticipantNameChanged: {

ParticipantNameChangedEvent ev;

{

std::lock_guard<std::mutex> guard(lock_);

const auto &pn = re.participant_name_changed();

const std::string &identity = pn.participant_identity();

Participant *participant = nullptr;

if (local_participant_ && local_participant_->identity() == identity) {

participant = local_participant_.get();

} else {

auto it = remote_participants_.find(identity);

if (it != remote_participants_.end()) {

participant = it->second.get();

}

}

if (!participant) {

LK_LOG_WARN("participant_name_changed for unknown participant: {}",

identity);

break;

}

std::string old_name = participant->name();

participant->set_name(pn.name());

ev.participant = participant;

ev.old_name = old_name;

ev.new_name = participant->name();

}

if (delegate_snapshot) {

delegate_snapshot->onParticipantNameChanged(*this, ev);

}

break;

}

case proto::RoomEvent::kParticipantAttributesChanged: {

ParticipantAttributesChangedEvent ev;

{

std::lock_guard<std::mutex> guard(lock_);

const auto &pa = re.participant_attributes_changed();

const std::string &identity = pa.participant_identity();

Participant *participant = nullptr;

if (local_participant_ && local_participant_->identity() == identity) {

participant = local_participant_.get();

} else {

auto it = remote_participants_.find(identity);

if (it != remote_participants_.end()) {

participant = it->second.get();

}

}

if (!participant) {

LK_LOG_WARN(

"participant_attributes_changed for unknown participant: {}",

identity);

break;

}

// Build full attributes map

std::unordered_map<std::string, std::string> attrs;

for (const auto &entry : pa.attributes()) {

attrs.emplace(entry.key(), entry.value());

}

participant->set_attributes(attrs);

// Build changed_attributes map

for (const auto &entry : pa.changed_attributes()) {

ev.changed_attributes.emplace_back(entry.key(), entry.value());

}

ev.participant = participant;

}

if (delegate_snapshot) {

delegate_snapshot->onParticipantAttributesChanged(*this, ev);

}

break;

}

case proto::RoomEvent::kParticipantEncryptionStatusChanged: {

ParticipantEncryptionStatusChangedEvent ev;

{

std::lock_guard<std::mutex> guard(lock_);

const auto &pe = re.participant_encryption_status_changed();

const std::string &identity = pe.participant_identity();

Participant *participant = nullptr;

if (local_participant_ && local_participant_->identity() == identity) {

participant = local_participant_.get();

} else {

auto it = remote_participants_.find(identity);

if (it != remote_participants_.end()) {

participant = it->second.get();

}

}

if (!participant) {

LK_LOG_WARN("participant_encryption_status_changed for unknown "

"participant: {}",

identity);

break;

}

ev.participant = participant;

ev.is_encrypted = pe.is_encrypted();

}

if (delegate_snapshot) {

delegate_snapshot->onParticipantEncryptionStatusChanged(*this, ev);

}

break;

}

case proto::RoomEvent::kConnectionQualityChanged: {

ConnectionQualityChangedEvent ev;

{

std::lock_guard<std::mutex> guard(lock_);

const auto &cq = re.connection_quality_changed();

const std::string &identity = cq.participant_identity();

Participant *participant = nullptr;

if (local_participant_ && local_participant_->identity() == identity) {

participant = local_participant_.get();

} else {

auto it = remote_participants_.find(identity);

if (it != remote_participants_.end()) {

participant = it->second.get();

}

}

if (!participant) {

LK_LOG_WARN("connection_quality_changed for unknown participant: {}",

identity);

break;

}

ev.participant = participant;

ev.quality = static_cast<ConnectionQuality>(cq.quality());

}

if (delegate_snapshot) {

delegate_snapshot->onConnectionQualityChanged(*this, ev);

}

break;

}

// ------------------------------------------------------------------------

// Data packets: user vs SIP DTMF

// ------------------------------------------------------------------------

case proto::RoomEvent::kDataPacketReceived: {

const auto &dp = re.data_packet_received();

RemoteParticipant *rp = nullptr;

{

std::lock_guard<std::mutex> guard(lock_);

auto it = remote_participants_.find(dp.participant_identity());

if (it != remote_participants_.end()) {

rp = it->second.get();

}

}

const auto which_val = dp.value_case();

if (which_val == proto::DataPacketReceived::kUser && delegate_snapshot) {

UserDataPacketEvent ev = userDataPacketFromProto(dp, rp);

delegate_snapshot->onUserPacketReceived(*this, ev);

} else if (which_val == proto::DataPacketReceived::kSipDtmf &&

delegate_snapshot) {

SipDtmfReceivedEvent ev = sipDtmfFromProto(dp, rp);

delegate_snapshot->onSipDtmfReceived(*this, ev);

}

break;

}

// ------------------------------------------------------------------------

// E2EE state

// ------------------------------------------------------------------------

case proto::RoomEvent::kE2EeStateChanged: {

E2eeStateChangedEvent ev;

{

LK_LOG_DEBUG("e2ee_state_changed for participant");

std::lock_guard<std::mutex> guard(lock_);

const auto &es = re.e2ee_state_changed();

const std::string &identity = es.participant_identity();

Participant *participant = nullptr;

if (local_participant_ && local_participant_->identity() == identity) {

participant = local_participant_.get();

} else {

auto it = remote_participants_.find(identity);

if (it != remote_participants_.end()) {

participant = it->second.get();

}

}

if (!participant) {

LK_LOG_WARN("e2ee_state_changed for unknown participant: {}",

identity);

break;

}

ev.participant = participant;

ev.state = static_cast<EncryptionState>(es.state());

}

if (delegate_snapshot) {

delegate_snapshot->onE2eeStateChanged(*this, ev);

}

break;

}

// ------------------------------------------------------------------------

// Connection state / lifecycle

// ------------------------------------------------------------------------

case proto::RoomEvent::kConnectionStateChanged: {

ConnectionStateChangedEvent ev;

{

std::lock_guard<std::mutex> guard(lock_);

const auto &cs = re.connection_state_changed();

// TODO, maybe we should update our |connection_state_|

// correspoindingly, but the this kConnectionStateChanged event is never

// triggered in my local test.

LK_LOG_DEBUG("cs.state() is {} connection_state_ is {}",

static_cast<int>(cs.state()),

static_cast<int>(connection_state_));

ev.state = static_cast<ConnectionState>(cs.state());

}

if (delegate_snapshot) {

delegate_snapshot->onConnectionStateChanged(*this, ev);

}

break;

}

case proto::RoomEvent::kDisconnected: {

DisconnectedEvent ev;

ev.reason = toDisconnectReason(re.disconnected().reason());

if (delegate_snapshot) {

delegate_snapshot->onDisconnected(*this, ev);

}

break;

}

case proto::RoomEvent::kReconnecting: {

ReconnectingEvent ev;

if (delegate_snapshot) {

delegate_snapshot->onReconnecting(*this, ev);

}

break;

}

case proto::RoomEvent::kReconnected: {

ReconnectedEvent ev;

if (delegate_snapshot) {

delegate_snapshot->onReconnected(*this, ev);

}

break;