publish client-sdk-native (#12)

* Create README.md

* add example

* crates & examples

* fix syntax

* add LICENSE

* thirdparty LICENSE

* rearrange repo

* fix build

* egui versions

* prepare publish

* fix demo compilation

* add test ci

* Update rust.yml

* forgot runs-on

* install protoc before building

* avoid rate limit

* include submodules

* updates to readme

* cache rust builds

Co-authored-by: David Zhao <[email protected]>
Co-authored-by: David Zhao <[email protected]>

livekit/src/room/id.rs

@@ -0,0 +1,56 @@
+use std::fmt;
+
+macro_rules! id_str {
+    ($($name:ident;)*) => {
+        $(
+            impl $name {
+                pub fn new(str: String) -> Self {
+                    Self(str)
+                }
+
+                pub fn as_str(&self) -> &str {
+                    &self.0
+                }
+            }
+
+            impl From<String> for $name {
+                fn from(str: String) -> $name {
+                    $name(str)
+                }
+            }
+
+            impl From<$name> for String {
+                fn from(id: $name) -> String {
+                    id.0
+                }
+            }
+
+            impl PartialEq<$name> for String {
+                fn eq(&self, u: &$name) -> bool {
+                    *self == *u.0
+                }
+            }
+
+            impl fmt::Display for $name {
+                fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+                    f.write_str(&self.0)
+                }
+            }
+        )*
+    }
+}
+
+#[derive(Clone, Default, Debug, Eq, Hash, PartialEq, PartialOrd, Ord)]
+pub struct ParticipantSid(String);
+
+#[derive(Clone, Default, Debug, Eq, Hash, PartialEq, PartialOrd, Ord)]
+pub struct ParticipantIdentity(String);
+
+#[derive(Clone, Default, Debug, Eq, Hash, PartialEq, PartialOrd, Ord)]
+pub struct TrackSid(String);
+
+id_str! {
+    ParticipantSid;
+    ParticipantIdentity;
+    TrackSid;
+}

livekit/src/room/mod.rs

@@ -0,0 +1,115 @@
+use self::participant::ConnectionQuality;
+use self::room_session::{ConnectionState, RoomSession, SessionHandle};
+use crate::proto::data_packet;
+use crate::room::id::TrackSid;
+use crate::room::participant::remote_participant::RemoteParticipant;
+use crate::room::participant::Participant;
+use crate::room::publication::RemoteTrackPublication;
+use crate::room::publication::TrackPublication;
+use crate::room::track::remote_track::RemoteTrackHandle;
+use crate::rtc_engine::EngineError;
+use std::fmt::Debug;
+use std::sync::Arc;
+use thiserror::Error;
+use tokio::sync::mpsc;
+
+pub use crate::rtc_engine::SimulateScenario;
+
+pub mod id;
+pub mod participant;
+pub mod publication;
+pub mod room_session;
+pub mod track;
+
+pub type RoomEvents = mpsc::UnboundedReceiver<RoomEvent>;
+pub type RoomEmitter = mpsc::UnboundedSender<RoomEvent>;
+pub type RoomResult<T> = Result<T, RoomError>;
+
+#[derive(Error, Debug)]
+pub enum RoomError {
+    #[error("engine : {0}")]
+    Engine(#[from] EngineError),
+    #[error("room failure: {0}")]
+    Internal(String),
+}
+
+#[derive(Error, Debug, Clone)]
+pub enum TrackError {
+    #[error("could not find published track with sid: {0}")]
+    TrackNotFound(String),
+}
+
+#[derive(Clone, Debug)]
+pub enum RoomEvent {
+    ParticipantConnected(Arc<RemoteParticipant>),
+    ParticipantDisconnected(Arc<RemoteParticipant>),
+    TrackSubscribed {
+        track: RemoteTrackHandle,
+        publication: RemoteTrackPublication,
+        participant: Arc<RemoteParticipant>,
+    },
+    TrackPublished {
+        publication: RemoteTrackPublication,
+        participant: Arc<RemoteParticipant>,
+    },
+    TrackUnpublished {
+        publication: RemoteTrackPublication,
+        participant: Arc<RemoteParticipant>,
+    },
+    TrackUnsubscribed {
+        track: RemoteTrackHandle,
+        publication: RemoteTrackPublication,
+        participant: Arc<RemoteParticipant>,
+    },
+    TrackSubscriptionFailed {
+        error: TrackError,
+        sid: TrackSid,
+        participant: Arc<RemoteParticipant>,
+    },
+    TrackMuted {
+        publication: TrackPublication,
+        participant: Participant,
+    },
+    TrackUnmuted {
+        publication: TrackPublication,
+        participant: Participant,
+    },
+    ActiveSpeakersChanged {
+        speakers: Vec<Participant>,
+    },
+    ConnectionQualityChanged {
+        quality: ConnectionQuality,
+        participant: Participant,
+    },
+    DataReceived {
+        payload: Arc<Vec<u8>>,
+        kind: data_packet::Kind,
+        participant: Arc<RemoteParticipant>,
+    },
+    ConnectionStateChanged(ConnectionState),
+    Connected,
+    Disconnected,
+    Reconnecting,
+    Reconnected,
+}
+
+#[derive(Debug)]
+pub struct Room {
+    handle: SessionHandle,
+}
+
+impl Room {
+    pub async fn connect(url: &str, token: &str) -> RoomResult<(Self, RoomEvents)> {
+        let (emitter, events) = mpsc::unbounded_channel();
+        let handle = SessionHandle::connect(emitter, url, token).await?;
+        Ok((Self { handle }, events))
+    }
+
+    pub async fn close(self) {
+        self.handle.close().await;
+    }
+
+    pub fn session(&self) -> RoomSession {
+        self.handle.session()
+    }
+}

livekit/src/room/participant/local_participant.rs

@@ -0,0 +1,76 @@
+use super::ConnectionQuality;
+use crate::proto::{data_packet, DataPacket, ParticipantInfo, UserPacket};
+use crate::room::id::{ParticipantIdentity, ParticipantSid, TrackSid};
+use crate::room::participant::{
+    impl_participant_trait, ParticipantEvent, ParticipantInternalTrait, ParticipantShared,
+    ParticipantTrait,
+};
+use crate::room::publication::TrackPublication;
+use crate::room::RoomError;
+use crate::rtc_engine::RTCEngine;
+use parking_lot::RwLockReadGuard;
+use std::collections::HashMap;
+use std::sync::atomic::Ordering;
+use std::sync::Arc;
+use tokio::sync::mpsc;
+
+#[derive(Debug)]
+pub struct LocalParticipant {
+    shared: ParticipantShared,
+    rtc_engine: Arc<RTCEngine>,
+}
+
+impl LocalParticipant {
+    pub(crate) fn new(
+        rtc_engine: Arc<RTCEngine>,
+        sid: ParticipantSid,
+        identity: ParticipantIdentity,
+        name: String,
+        metadata: String,
+    ) -> Self {
+        Self {
+            shared: ParticipantShared::new(sid, identity, name, metadata),
+            rtc_engine,
+        }
+    }
+
+    pub async fn publish_data(
+        &self,
+        data: &[u8],
+        kind: data_packet::Kind,
+    ) -> Result<(), RoomError> {
+        let data = DataPacket {
+            kind: kind as i32,
+            value: Some(data_packet::Value::User(UserPacket {
+                participant_sid: self.sid().to_string(),
+                payload: data.to_vec(),
+                destination_sids: vec![],
+            })),
+        };
+
+        self.rtc_engine
+            .publish_data(&data, kind)
+            .await
+            .map_err(Into::into)
+    }
+}
+
+impl ParticipantInternalTrait for LocalParticipant {
+    fn update_info(self: &Arc<Self>, info: ParticipantInfo, _emit_events: bool) {
+        self.shared.update_info(info);
+    }
+
+    fn set_speaking(&self, speaking: bool) {
+        self.shared.set_speaking(speaking);
+    }
+
+    fn set_audio_level(&self, level: f32) {
+        self.shared.set_audio_level(level);
+    }
+
+    fn set_connection_quality(&self, quality: ConnectionQuality) {
+        self.shared.set_connection_quality(quality);
+    }
+}
+
+impl_participant_trait!(LocalParticipant);

livekit/src/room/participant/mod.rs

@@ -0,0 +1,247 @@
+use super::publication::RemoteTrackPublication;
+use super::TrackError;
+use crate::proto;
+use crate::proto::ParticipantInfo;
+use crate::room::id::{ParticipantIdentity, ParticipantSid, TrackSid};
+use crate::room::participant::local_participant::LocalParticipant;
+use crate::room::participant::remote_participant::RemoteParticipant;
+use crate::room::publication::{TrackPublication, TrackPublicationTrait};
+use crate::room::track::remote_track::RemoteTrackHandle;
+use livekit_utils::enum_dispatch;
+use livekit_utils::observer::Dispatcher;
+use parking_lot::{Mutex, RwLock, RwLockReadGuard};
+use proto::data_packet;
+use std::collections::HashMap;
+use std::sync::atomic::{AtomicBool, AtomicU32, AtomicU8, Ordering};
+use std::sync::Arc;
+use tokio::sync::mpsc;
+
+pub mod local_participant;
+pub mod remote_participant;
+
+#[derive(Debug, Clone)]
+pub enum ParticipantEvent {
+    TrackPublished {
+        publication: RemoteTrackPublication,
+    },
+    TrackUnpublished {
+        publication: RemoteTrackPublication,
+    },
+    TrackSubscribed {
+        track: RemoteTrackHandle,
+        publication: RemoteTrackPublication,
+    },
+    TrackUnsubscribed {
+        track: RemoteTrackHandle,
+        publication: RemoteTrackPublication,
+    },
+    TrackSubscriptionFailed {
+        error: TrackError,
+        sid: TrackSid,
+    },
+    DataReceived {
+        payload: Arc<Vec<u8>>,
+        kind: data_packet::Kind,
+    },
+    SpeakingChanged {
+        speaking: bool,
+    },
+    TrackMuted {
+        publication: TrackPublication,
+    },
+    TrackUnmuted {
+        publication: TrackPublication,
+    },
+    ConnectionQualityChanged {
+        quality: ConnectionQuality,
+    },
+}
+
+#[derive(Debug, Clone, Copy, Eq, PartialEq)]
+#[repr(u8)]
+pub enum ConnectionQuality {
+    Unknown,
+    Excellent,
+    Good,
+    Poor,
+}
+
+impl From<u8> for ConnectionQuality {
+    fn from(value: u8) -> Self {
+        match value {
+            1 => Self::Excellent,
+            2 => Self::Good,
+            3 => Self::Poor,
+            _ => Self::Unknown,
+        }
+    }
+}
+
+impl From<proto::ConnectionQuality> for ConnectionQuality {
+    fn from(value: proto::ConnectionQuality) -> Self {
+        match value {
+            proto::ConnectionQuality::Excellent => Self::Excellent,
+            proto::ConnectionQuality::Good => Self::Good,
+            proto::ConnectionQuality::Poor => Self::Poor,
+        }
+    }
+}
+
+#[derive(Debug)]
+pub(super) struct ParticipantShared {
+    pub(super) sid: Mutex<ParticipantSid>,
+    pub(super) identity: Mutex<ParticipantIdentity>,
+    pub(super) name: Mutex<String>,
+    pub(super) metadata: Mutex<String>,
+    pub(super) tracks: RwLock<HashMap<TrackSid, TrackPublication>>,
+    pub(super) speaking: AtomicBool,
+    pub(super) audio_level: AtomicU32,
+    pub(super) connection_quality: AtomicU8,
+    pub(super) dispatcher: Mutex<Dispatcher<ParticipantEvent>>,
+}
+
+impl ParticipantShared {
+    pub(super) fn new(
+        sid: ParticipantSid,
+        identity: ParticipantIdentity,
+        name: String,
+        metadata: String,
+    ) -> Self {
+        Self {
+            sid: Mutex::new(sid),
+            identity: Mutex::new(identity),
+            name: Mutex::new(name),
+            metadata: Mutex::new(metadata),
+            tracks: Default::default(),
+            speaking: Default::default(),
+            audio_level: Default::default(),
+            connection_quality: AtomicU8::new(ConnectionQuality::Unknown as u8),
+            dispatcher: Default::default(),
+        }
+    }
+
+    pub(crate) fn update_info(&self, info: ParticipantInfo) {
+        *self.sid.lock() = info.sid.into();
+        *self.identity.lock() = info.identity.into();
+        *self.name.lock() = info.name;
+        *self.metadata.lock() = info.metadata; // TODO(theomonnom): callback MetadataChanged
+    }
+
+    pub(crate) fn set_speaking(&self, speaking: bool) {
+        self.speaking.store(speaking, Ordering::SeqCst);
+    }
+
+    pub(crate) fn set_audio_level(&self, audio_level: f32) {
+        self.audio_level
+            .store(audio_level.to_bits(), Ordering::SeqCst)
+    }
+
+    pub(crate) fn register_observer(&self) -> mpsc::UnboundedReceiver<ParticipantEvent> {
+        self.dispatcher.lock().register()
+    }
+
+    pub(crate) fn set_connection_quality(&self, quality: ConnectionQuality) {
+        self.connection_quality
+            .store(quality as u8, Ordering::SeqCst);
+    }
+
+    pub(crate) fn add_track_publication(&self, publication: TrackPublication) {
+        self.tracks.write().insert(publication.sid(), publication);
+    }
+}
+
+pub(crate) trait ParticipantInternalTrait {
+    fn set_speaking(&self, speaking: bool);
+    fn set_audio_level(&self, level: f32);
+    fn set_connection_quality(&self, quality: ConnectionQuality);
+    fn update_info(self: &Arc<Self>, info: ParticipantInfo, emit_events: bool);
+}
+
+pub trait ParticipantTrait {
+    fn sid(&self) -> ParticipantSid;
+    fn identity(&self) -> ParticipantIdentity;
+    fn name(&self) -> String;
+    fn metadata(&self) -> String;
+    fn is_speaking(&self) -> bool;
+    fn audio_level(&self) -> f32;
+    fn connection_quality(&self) -> ConnectionQuality;
+    fn tracks(&self) -> RwLockReadGuard<HashMap<TrackSid, TrackPublication>>;
+    fn register_observer(&self) -> mpsc::UnboundedReceiver<ParticipantEvent>;
+}
+
+#[derive(Debug, Clone)]
+pub enum Participant {
+    Local(Arc<LocalParticipant>),
+    Remote(Arc<RemoteParticipant>),
+}
+
+// TODO(theomonnom): Should I provide a WeakParticipant here ?
+
+impl Participant {
+    enum_dispatch!(
+        [Local, Remote]
+        fnc!(pub(crate), update_info, &Self, [info: ParticipantInfo, emit_events: bool], ());
+        fnc!(pub(crate), set_speaking, &Self, [speaking: bool], ());
+        fnc!(pub(crate), set_audio_level, &Self, [audio_level: f32], ());
+        fnc!(pub(crate), set_connection_quality, &Self, [quality: ConnectionQuality], ());
+    );
+}
+
+impl ParticipantTrait for Participant {
+    enum_dispatch!(
+        [Local, Remote]
+        fnc!(sid, &Self, [], ParticipantSid);
+        fnc!(identity, &Self, [], ParticipantIdentity);
+        fnc!(name, &Self, [], String);
+        fnc!(metadata, &Self, [], String);
+        fnc!(is_speaking, &Self, [], bool);
+        fnc!(audio_level, &Self, [], f32);
+        fnc!(connection_quality, &Self, [], ConnectionQuality);
+        fnc!(tracks, &Self, [], RwLockReadGuard<HashMap<TrackSid, TrackPublication>>);
+        fnc!(register_observer, &Self, [], mpsc::UnboundedReceiver<ParticipantEvent>);
+    );
+}
+
+macro_rules! impl_participant_trait {
+    ($x:ty) => {
+        impl crate::room::participant::ParticipantTrait for $x {
+            fn sid(&self) -> ParticipantSid {
+                self.shared.sid.lock().clone()
+            }
+
+            fn identity(&self) -> ParticipantIdentity {
+                self.shared.identity.lock().clone()
+            }
+
+            fn name(&self) -> String {
+                self.shared.name.lock().clone()
+            }
+
+            fn metadata(&self) -> String {
+                self.shared.metadata.lock().clone()
+            }
+
+            fn is_speaking(&self) -> bool {
+                self.shared.speaking.load(Ordering::SeqCst)
+            }
+
+            fn audio_level(&self) -> f32 {
+                f32::from_bits(self.shared.audio_level.load(Ordering::SeqCst))
+            }
+
+            fn connection_quality(&self) -> ConnectionQuality {
+                self.shared.connection_quality.load(Ordering::SeqCst).into()
+            }
+
+            fn tracks(&self) -> RwLockReadGuard<HashMap<TrackSid, TrackPublication>> {
+                self.shared.tracks.read()
+            }
+
+            fn register_observer(&self) -> mpsc::UnboundedReceiver<ParticipantEvent> {
+                self.shared.register_observer()
+            }
+        }
+    };
+}
+
+pub(super) use impl_participant_trait;

livekit/src/room/participant/remote_participant.rs

@@ -0,0 +1,222 @@
+use super::ConnectionQuality;
+use crate::proto::{data_packet, DataPacket, ParticipantInfo, UserPacket};
+use crate::room::id::{ParticipantIdentity, ParticipantSid, TrackSid};
+use crate::room::participant::{
+    impl_participant_trait, ParticipantEvent, ParticipantInternalTrait, ParticipantShared,
+    ParticipantTrait,
+};
+use crate::room::publication::{
+    RemoteTrackPublication, TrackPublication, TrackPublicationInternalTrait, TrackPublicationTrait,
+};
+use crate::room::track::remote_audio_track::RemoteAudioTrack;
+use crate::room::track::remote_track::RemoteTrackHandle;
+use crate::room::track::remote_video_track::RemoteVideoTrack;
+use crate::room::track::{TrackKind, TrackTrait};
+use crate::room::TrackError;
+use livekit_webrtc::media_stream::MediaStreamTrackHandle;
+use parking_lot::RwLockReadGuard;
+use std::collections::HashMap;
+use std::collections::HashSet;
+use std::sync::atomic::Ordering;
+use std::sync::Arc;
+use std::time::Duration;
+use tokio::sync::mpsc;
+use tokio::time::timeout;
+use tracing::{debug, error, instrument, Level};
+
+const ADD_TRACK_TIMEOUT: Duration = Duration::from_secs(5);
+
+#[derive(Debug)]
+pub struct RemoteParticipant {
+    shared: ParticipantShared,
+}
+
+impl RemoteParticipant {
+    pub(crate) fn new(
+        sid: ParticipantSid,
+        identity: ParticipantIdentity,
+        name: String,
+        metadata: String,
+    ) -> Self {
+        Self {
+            shared: ParticipantShared::new(sid, identity, name, metadata),
+        }
+    }
+
+    fn get_track_publication(&self, sid: &TrackSid) -> Option<RemoteTrackPublication> {
+        self.shared.tracks.read().get(sid).map(|track| {
+            if let TrackPublication::Remote(remote) = track {
+                remote.clone()
+            } else {
+                unreachable!()
+            }
+        })
+    }
+
+    /// Called by the RoomSession when receiving data by the RTCSession
+    /// It is just used to emit the Data event on the participant dispatcher.
+    pub(crate) fn on_data_received(&self, data: Arc<Vec<u8>>, kind: data_packet::Kind) {
+        self.shared
+            .dispatcher
+            .lock()
+            .dispatch(&ParticipantEvent::DataReceived {
+                payload: data,
+                kind,
+            });
+    }
+
+    #[instrument(level = Level::DEBUG)]
+    pub(crate) async fn add_subscribed_media_track(
+        self: Arc<Self>,
+        sid: TrackSid,
+        media_track: MediaStreamTrackHandle,
+    ) {
+        let wait_publication = {
+            let participant = self.clone();
+            let sid = sid.clone();
+            async move {
+                loop {
+                    let publication = participant.get_track_publication(&sid);
+                    if let Some(publication) = publication {
+                        return publication;
+                    }
+
+                    tokio::task::yield_now().await;
+                }
+            }
+        };
+
+        if let Ok(remote_publication) = timeout(ADD_TRACK_TIMEOUT, wait_publication).await {
+            let track = match remote_publication.kind() {
+                TrackKind::Audio => {
+                    if let MediaStreamTrackHandle::Audio(rtc_track) = media_track {
+                        let audio_track = RemoteAudioTrack::new(
+                            remote_publication.sid().into(),
+                            remote_publication.name(),
+                            rtc_track,
+                        );
+                        RemoteTrackHandle::Audio(Arc::new(audio_track))
+                    } else {
+                        unreachable!();
+                    }
+                }
+                TrackKind::Video => {
+                    if let MediaStreamTrackHandle::Video(rtc_track) = media_track {
+                        let video_track = RemoteVideoTrack::new(
+                            remote_publication.sid().into(),
+                            remote_publication.name(),
+                            rtc_track,
+                        );
+                        RemoteTrackHandle::Video(Arc::new(video_track))
+                    } else {
+                        unreachable!()
+                    }
+                }
+                _ => unreachable!(),
+            };
+
+            debug!("starting track: {:?}", sid);
+
+            remote_publication.update_track(Some(track.clone().into()));
+            self.shared
+                .add_track_publication(TrackPublication::Remote(remote_publication.clone()));
+            track.start();
+
+            self.shared
+                .dispatcher
+                .lock()
+                .dispatch(&ParticipantEvent::TrackSubscribed {
+                    track: track,
+                    publication: remote_publication,
+                });
+        } else {
+            error!("could not find published track with sid: {:?}", sid);
+
+            self.shared
+                .dispatcher
+                .lock()
+                .dispatch(&ParticipantEvent::TrackSubscriptionFailed {
+                    sid: sid.clone(),
+                    error: TrackError::TrackNotFound(sid.clone().to_string()),
+                });
+        }
+    }
+
+    pub(crate) fn unpublish_track(self: &Arc<Self>, sid: &TrackSid, emit_events: bool) {
+        if let Some(publication) = self.get_track_publication(sid) {
+            // Unsubscribe to the track if needed
+            if let Some(track) = publication.track() {
+                track.stop();
+
+                self.shared
+                    .dispatcher
+                    .lock()
+                    .dispatch(&ParticipantEvent::TrackUnsubscribed {
+                        track: track.clone(),
+                        publication: publication.clone(),
+                    });
+            }
+
+            if emit_events {
+                self.shared
+                    .dispatcher
+                    .lock()
+                    .dispatch(&ParticipantEvent::TrackUnpublished {
+                        publication: publication.clone(),
+                    });
+            }
+
+            publication.update_track(None);
+        }
+    }
+}
+
+impl ParticipantInternalTrait for RemoteParticipant {
+    fn update_info(self: &Arc<Self>, info: ParticipantInfo, emit_events: bool) {
+        self.shared.update_info(info.clone());
+
+        let mut valid_tracks = HashSet::<TrackSid>::new();
+        for track in info.tracks {
+            if let Some(publication) = self.get_track_publication(&track.sid.clone().into()) {
+                publication.update_info(track.clone());
+            } else {
+                let publication = RemoteTrackPublication::new(track.clone(), self.sid(), None);
+                self.shared
+                    .add_track_publication(TrackPublication::Remote(publication.clone()));
+
+                // This is a new track, dispatch publish event
+                if emit_events {
+                    self.shared
+                        .dispatcher
+                        .lock()
+                        .dispatch(&ParticipantEvent::TrackPublished { publication });
+                }
+            }
+
+            valid_tracks.insert(track.sid.into());
+        }
+
+        // remove tracks that are no longer valid
+        for (sid, _) in self.shared.tracks.read().iter() {
+            if valid_tracks.contains(sid) {
+                continue;
+            }
+
+            self.unpublish_track(sid, emit_events);
+        }
+    }
+
+    fn set_speaking(&self, speaking: bool) {
+        self.shared.set_speaking(speaking);
+    }
+
+    fn set_audio_level(&self, level: f32) {
+        self.shared.set_audio_level(level);
+    }
+
+    fn set_connection_quality(&self, quality: ConnectionQuality) {
+        self.shared.set_connection_quality(quality);
+    }
+}
+
+impl_participant_trait!(RemoteParticipant);

livekit/src/room/publication/mod.rs

@@ -0,0 +1,262 @@
+use crate::proto::TrackType;
+use crate::proto::{TrackInfo, TrackSource as ProtoTrackSource};
+use crate::room::id::ParticipantSid;
+use crate::room::id::TrackSid;
+use crate::room::track::local_track::LocalTrackHandle;
+use crate::room::track::remote_track::RemoteTrackHandle;
+use crate::room::track::{TrackHandle, TrackKind, TrackSource, TrackTrait};
+use livekit_utils::enum_dispatch;
+use livekit_utils::observer::Dispatcher;
+use parking_lot::Mutex;
+use std::sync::atomic::{AtomicBool, AtomicU8, Ordering};
+use std::sync::Arc;
+use tokio::sync::{mpsc, oneshot};
+
+use super::track::{TrackDimension, TrackEvent};
+
+pub(crate) trait TrackPublicationInternalTrait {
+    fn update_track(&self, track: Option<TrackHandle>);
+    fn update_info(&self, info: TrackInfo);
+}
+
+pub trait TrackPublicationTrait {
+    fn name(&self) -> String;
+    fn sid(&self) -> TrackSid;
+    fn kind(&self) -> TrackKind;
+    fn source(&self) -> TrackSource;
+    fn muted(&self) -> bool;
+    fn simulcasted(&self) -> bool;
+}
+
+#[derive(Debug)]
+pub(super) struct TrackPublicationShared {
+    pub(super) track: Mutex<Option<TrackHandle>>,
+    pub(super) name: Mutex<String>,
+    pub(super) sid: Mutex<TrackSid>,
+    pub(super) kind: AtomicU8,   // Casted to TrackKind
+    pub(super) source: AtomicU8, // Casted to TrackSource
+    pub(super) simulcasted: AtomicBool,
+    pub(super) dimension: Mutex<TrackDimension>,
+    pub(super) mime_type: Mutex<String>,
+    pub(super) muted: AtomicBool,
+    pub(super) participant: ParticipantSid,
+    pub(super) dispatcher: Mutex<Dispatcher<TrackEvent>>,
+    pub(super) close_sender: Mutex<Option<oneshot::Sender<()>>>,
+}
+
+impl TrackPublicationShared {
+    pub fn new(
+        info: TrackInfo,
+        participant: ParticipantSid,
+        track: Option<TrackHandle>,
+    ) -> Arc<Self> {
+        Arc::new(Self {
+            track: Mutex::new(track),
+            name: Mutex::new(info.name),
+            sid: Mutex::new(info.sid.into()),
+            kind: AtomicU8::new(TrackKind::from(TrackType::from_i32(info.r#type).unwrap()) as u8),
+            source: AtomicU8::new(TrackSource::from(
+                ProtoTrackSource::from_i32(info.source).unwrap(),
+            ) as u8),
+            simulcasted: AtomicBool::new(info.simulcast),
+            dimension: Mutex::new(TrackDimension(info.width, info.height)),
+            mime_type: Mutex::new(info.mime_type),
+            muted: AtomicBool::new(info.muted),
+            dispatcher: Default::default(),
+            close_sender: Default::default(),
+            participant,
+        })
+    }
+
+    pub fn update_track(self: &Arc<Self>, track: Option<TrackHandle>) {
+        let mut old_track = self.track.lock();
+
+        if let Some(close_sender) = self.close_sender.lock().take() {
+            let _ = close_sender.send(());
+        }
+
+        *old_track = track.clone();
+        if let Some(track) = track {
+            let (close_sender, close_receiver) = oneshot::channel();
+            self.close_sender.lock().replace(close_sender);
+
+            let track_receiver = track.register_observer();
+            tokio::spawn(
+                self.clone()
+                    .publication_task(close_receiver, track_receiver),
+            );
+        }
+    }
+
+    /// Task used to forward TrackHandle's events to the TrackPublications's dispatcher
+    async fn publication_task(
+        self: Arc<Self>,
+        mut close_receiver: oneshot::Receiver<()>,
+        mut track_receiver: mpsc::UnboundedReceiver<TrackEvent>,
+    ) {
+        loop {
+            tokio::select! {
+                Some(event) = track_receiver.recv() => {
+                    self.dispatcher.lock().dispatch(&event);
+                }
+                _ = &mut close_receiver => {
+                    break;
+                }
+            }
+        }
+    }
+
+    pub fn update_info(&self, info: TrackInfo) {
+        *self.name.lock() = info.name;
+        *self.sid.lock() = info.sid.into();
+        *self.dimension.lock() = TrackDimension(info.width, info.height);
+        *self.mime_type.lock() = info.mime_type;
+        self.kind.store(
+            TrackKind::from(TrackType::from_i32(info.r#type).unwrap()) as u8,
+            Ordering::SeqCst,
+        );
+        self.source.store(
+            TrackSource::from(ProtoTrackSource::from_i32(info.source).unwrap()) as u8,
+            Ordering::SeqCst,
+        );
+        self.simulcasted.store(info.simulcast, Ordering::SeqCst);
+        self.muted.store(info.muted, Ordering::SeqCst);
+
+        if let Some(track) = self.track.lock().as_ref() {
+            track.set_muted(info.muted);
+        }
+    }
+}
+
+impl Drop for TrackPublicationShared {
+    fn drop(&mut self) {
+        if let Some(close_sender) = self.close_sender.lock().take() {
+            let _ = close_sender.send(());
+        }
+    }
+}
+
+#[derive(Clone, Debug)]
+pub enum TrackPublication {
+    Local(LocalTrackPublication),
+    Remote(RemoteTrackPublication),
+}
+
+impl TrackPublication {
+    pub fn track(&self) -> Option<TrackHandle> {
+        // Not calling Local/Remote function here, we don't need "cast"
+        match self {
+            TrackPublication::Local(p) => p.shared.track.lock().clone(),
+            TrackPublication::Remote(p) => p.shared.track.lock().clone(),
+        }
+    }
+}
+
+impl TrackPublicationInternalTrait for TrackPublication {
+    enum_dispatch!(
+        [Local, Remote]
+        fnc!(update_track, &Self, [track: Option<TrackHandle>], ());
+        fnc!(update_info, &Self, [info: TrackInfo], ());
+    );
+}
+
+impl TrackPublicationTrait for TrackPublication {
+    enum_dispatch!(
+        [Local, Remote]
+        fnc!(sid, &Self, [], TrackSid);
+        fnc!(name, &Self, [], String);
+        fnc!(kind, &Self, [], TrackKind);
+        fnc!(source, &Self, [], TrackSource);
+        fnc!(muted, &Self, [], bool);
+        fnc!(simulcasted, &Self, [], bool);
+    );
+}
+
+macro_rules! impl_publication_trait {
+    ($x:ident) => {
+        impl TrackPublicationTrait for $x {
+            fn name(&self) -> String {
+                self.shared.name.lock().clone()
+            }
+
+            fn sid(&self) -> TrackSid {
+                self.shared.sid.lock().clone()
+            }
+
+            fn kind(&self) -> TrackKind {
+                self.shared.kind.load(Ordering::SeqCst).into()
+            }
+
+            fn source(&self) -> TrackSource {
+                self.shared.source.load(Ordering::SeqCst).into()
+            }
+
+            fn simulcasted(&self) -> bool {
+                self.shared.simulcasted.load(Ordering::SeqCst)
+            }
+
+            fn muted(&self) -> bool {
+                self.shared.muted.load(Ordering::SeqCst)
+            }
+        }
+    };
+}
+
+#[derive(Clone, Debug)]
+pub struct LocalTrackPublication {
+    shared: Arc<TrackPublicationShared>,
+}
+
+impl LocalTrackPublication {
+    pub fn track(&self) -> Option<LocalTrackHandle> {
+        self.shared
+            .track
+            .lock()
+            .clone()
+            .map(|local_track| local_track.try_into().unwrap())
+    }
+}
+
+impl TrackPublicationInternalTrait for LocalTrackPublication {
+    fn update_track(&self, track: Option<TrackHandle>) {
+        self.shared.update_track(track);
+    }
+
+    fn update_info(&self, info: TrackInfo) {
+        self.shared.update_info(info);
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct RemoteTrackPublication {
+    shared: Arc<TrackPublicationShared>,
+}
+
+impl RemoteTrackPublication {
+    pub fn new(info: TrackInfo, participant: ParticipantSid, track: Option<TrackHandle>) -> Self {
+        Self {
+            shared: TrackPublicationShared::new(info, participant, track),
+        }
+    }
+
+    pub fn track(&self) -> Option<RemoteTrackHandle> {
+        self.shared
+            .track
+            .lock()
+            .clone()
+            .map(|track| track.try_into().unwrap())
+    }
+}
+
+impl TrackPublicationInternalTrait for RemoteTrackPublication {
+    fn update_track(&self, track: Option<TrackHandle>) {
+        self.shared.update_track(track);
+    }
+
+    fn update_info(&self, info: TrackInfo) {
+        self.shared.update_info(info);
+    }
+}
+
+impl_publication_trait!(LocalTrackPublication);
+impl_publication_trait!(RemoteTrackPublication);

livekit/src/room/room_session.rs

@@ -0,0 +1,571 @@
+use super::id::{ParticipantIdentity, ParticipantSid};
+use super::participant::local_participant::LocalParticipant;
+use super::participant::remote_participant::RemoteParticipant;
+use super::participant::{ConnectionQuality, Participant, ParticipantEvent};
+use super::participant::{ParticipantInternalTrait, ParticipantTrait};
+use super::{RoomEmitter, RoomError, RoomEvent, RoomResult, SimulateScenario};
+use crate::proto::{self, participant_info, SpeakerInfo};
+use crate::rtc_engine::{EngineEvent, EngineEvents, EngineResult, RTCEngine};
+use crate::signal_client::SignalOptions;
+use parking_lot::{Mutex, RwLock};
+use std::collections::HashMap;
+use std::sync::atomic::{AtomicU8, Ordering};
+use std::sync::Arc;
+use tokio::sync::mpsc;
+use tokio::sync::oneshot;
+use tokio::task::JoinHandle;
+use tracing::{error, instrument, Level};
+
+#[derive(Debug, Clone, Copy, Eq, PartialEq)]
+pub enum ConnectionState {
+    Disconnected,
+    Connected,
+    Reconnecting,
+    Unknown,
+}
+
+impl From<u8> for ConnectionState {
+    fn from(value: u8) -> Self {
+        match value {
+            0 => ConnectionState::Disconnected,
+            1 => ConnectionState::Connected,
+            2 => ConnectionState::Reconnecting,
+            _ => ConnectionState::Unknown,
+        }
+    }
+}
+
+/// Internal representation of a RoomSession
+#[derive(Debug)]
+struct SessionInner {
+    state: AtomicU8, // ConnectionState
+    sid: Mutex<String>,
+    name: Mutex<String>,
+    participants: RwLock<HashMap<ParticipantSid, Arc<RemoteParticipant>>>,
+    participants_tasks: RwLock<HashMap<ParticipantSid, (JoinHandle<()>, oneshot::Sender<()>)>>,
+    active_speakers: RwLock<Vec<Participant>>,
+    rtc_engine: Arc<RTCEngine>,
+    local_participant: Arc<LocalParticipant>,
+    room_emitter: RoomEmitter,
+}
+
+#[derive(Debug)]
+pub(crate) struct SessionHandle {
+    session: RoomSession,
+    session_task: JoinHandle<()>,
+    close_emitter: oneshot::Sender<()>,
+}
+
+/// RoomSession represents a connection to a room.
+/// It can be cloned and shared across threads.
+#[derive(Debug, Clone)]
+pub struct RoomSession {
+    inner: Arc<SessionInner>,
+}
+
+impl SessionHandle {
+    pub async fn connect(room_emitter: RoomEmitter, url: &str, token: &str) -> RoomResult<Self> {
+        let (rtc_engine, engine_events) = RTCEngine::new();
+        let rtc_engine = Arc::new(rtc_engine);
+        rtc_engine
+            .connect(url, token, SignalOptions::default())
+            .await?;
+
+        let join_response = rtc_engine.join_response().unwrap();
+        let pi = join_response.participant.unwrap().clone();
+        let local_participant = Arc::new(LocalParticipant::new(
+            rtc_engine.clone(),
+            pi.sid.into(),
+            pi.identity.into(),
+            pi.name,
+            pi.metadata,
+        ));
+
+        let room_info = join_response.room.unwrap();
+        let inner = Arc::new(SessionInner {
+            state: AtomicU8::new(ConnectionState::Disconnected as u8),
+            sid: Mutex::new(room_info.sid),
+            name: Mutex::new(room_info.name),
+            participants: Default::default(),
+            participants_tasks: Default::default(),
+            active_speakers: Default::default(),
+            rtc_engine,
+            local_participant,
+            room_emitter,
+        });
+
+        for pi in join_response.other_participants {
+            let participant = {
+                let pi = pi.clone();
+                inner.create_participant(pi.sid.into(), pi.identity.into(), pi.name, pi.metadata)
+            };
+            participant.update_info(pi.clone(), false);
+        }
+
+        let (close_emitter, close_receiver) = oneshot::channel();
+        let session_task = tokio::spawn(inner.clone().room_task(engine_events, close_receiver));
+
+        inner.update_connection_state(ConnectionState::Connected);
+
+        let session = Self {
+            session: RoomSession::from(inner),
+            session_task,
+            close_emitter,
+        };
+        Ok(session)
+    }
+
+    pub async fn close(self) {
+        self.session.inner.close().await;
+        let _ = self.close_emitter.send(());
+        let _ = self.session_task.await;
+    }
+
+    pub fn session(&self) -> RoomSession {
+        self.session.clone()
+    }
+}
+
+impl RoomSession {
+    fn from(inner: Arc<SessionInner>) -> Self {
+        Self { inner }
+    }
+
+    pub fn sid(&self) -> String {
+        self.inner.sid.lock().clone()
+    }
+
+    pub fn name(&self) -> String {
+        self.inner.name.lock().clone()
+    }
+
+    pub fn local_participant(&self) -> Arc<LocalParticipant> {
+        self.inner.local_participant.clone()
+    }
+
+    pub fn connection_state(&self) -> ConnectionState {
+        self.inner.state.load(Ordering::Acquire).try_into().unwrap()
+    }
+
+    pub fn participants(&self) -> &RwLock<HashMap<ParticipantSid, Arc<RemoteParticipant>>> {
+        &self.inner.participants
+    }
+
+    pub async fn simulate_scenario(&self, scenario: SimulateScenario) -> EngineResult<()> {
+        self.inner.rtc_engine.simulate_scenario(scenario).await
+    }
+}
+
+impl SessionInner {
+    #[instrument(level = Level::DEBUG)]
+    async fn room_task(
+        self: Arc<Self>,
+        mut engine_events: EngineEvents,
+        mut close_receiver: oneshot::Receiver<()>,
+    ) {
+        loop {
+            tokio::select! {
+                res = engine_events.recv() => {
+                    match res {
+                        Some(event) => {
+                            if let Err(err) = self.on_engine_event(event).await {
+                                error!("failed to handle engine event: {:?}", err);
+                            }
+                        },
+                        _ => panic!("engine_events has been closed unexpectedly")
+                    };
+                },
+                 _ = &mut close_receiver => {
+                    break;
+                }
+            }
+        }
+    }
+
+    /// Listen to the Participant events and forward them to the Room Dispatcher
+    #[instrument(level = Level::DEBUG)]
+    async fn participant_task(
+        self: Arc<Self>,
+        participant: Participant,
+        mut participant_events: mpsc::UnboundedReceiver<ParticipantEvent>,
+        mut close_rx: oneshot::Receiver<()>,
+    ) {
+        loop {
+            tokio::select! {
+                res = participant_events.recv() => {
+                    match res {
+                        Some(event) => {
+                            if let Err(err) = self.on_participant_event(&participant, event).await {
+                                error!("failed to handle participant event for {:?}: {:?}", participant.sid(), err);
+                            }
+                        },
+                        _ => panic!("participant_events has been closed unexpectedly")
+                    };
+                },
+                _ = &mut close_rx => {
+                    break;
+                },
+            }
+        }
+    }
+
+    #[instrument(level = Level::DEBUG)]
+    async fn on_participant_event(
+        self: &Arc<Self>,
+        participant: &Participant,
+        event: ParticipantEvent,
+    ) -> RoomResult<()> {
+        if let Participant::Remote(remote_participant) = participant {
+            match event {
+                ParticipantEvent::TrackPublished { publication } => {
+                    let _ = self.room_emitter.send(RoomEvent::TrackPublished {
+                        participant: remote_participant.clone(),
+                        publication,
+                    });
+                }
+                ParticipantEvent::TrackUnpublished { publication } => {
+                    let _ = self.room_emitter.send(RoomEvent::TrackUnpublished {
+                        participant: remote_participant.clone(),
+                        publication,
+                    });
+                }
+                ParticipantEvent::TrackSubscribed { track, publication } => {
+                    let _ = self.room_emitter.send(RoomEvent::TrackSubscribed {
+                        participant: remote_participant.clone(),
+                        track,
+                        publication,
+                    });
+                }
+                ParticipantEvent::TrackUnsubscribed { track, publication } => {
+                    let _ = self.room_emitter.send(RoomEvent::TrackUnsubscribed {
+                        participant: remote_participant.clone(),
+                        track,
+                        publication,
+                    });
+                }
+                _ => {}
+            };
+        }
+
+        Ok(())
+    }
+
+    #[instrument(level = Level::DEBUG)]
+    async fn on_engine_event(self: &Arc<Self>, event: EngineEvent) -> RoomResult<()> {
+        match event {
+            EngineEvent::ParticipantUpdate(update) => self.handle_participant_update(update),
+            EngineEvent::MediaTrack {
+                track,
+                stream,
+                receiver: _,
+            } => {
+                let stream_id = stream.id();
+                let lk_stream_id = unpack_stream_id(&stream_id);
+                if lk_stream_id.is_none() {
+                    Err(RoomError::Internal(format!(
+                        "MediaTrack event with invalid track_id: {:?}",
+                        &stream_id
+                    )))?;
+                }
+
+                let (participant_sid, track_sid) = lk_stream_id.unwrap();
+                let track_sid = track_sid.to_owned().into();
+                let remote_participant = self.get_participant(&participant_sid.to_string().into());
+
+                if let Some(remote_participant) = remote_participant {
+                    tokio::spawn(async move {
+                        remote_participant
+                            .add_subscribed_media_track(track_sid, track)
+                            .await;
+                    });
+                } else {
+                    // The server should send participant updates before sending a new offer
+                    // So this should never happen.
+                    Err(RoomError::Internal(format!(
+                        "AddTrack event with invalid participant_sid: {:?}",
+                        participant_sid
+                    )))?;
+                }
+            }
+            EngineEvent::Resuming => {
+                if self.update_connection_state(ConnectionState::Reconnecting) {
+                    let _ = self.room_emitter.send(RoomEvent::Reconnecting);
+                }
+            }
+            EngineEvent::Resumed => {
+                self.update_connection_state(ConnectionState::Connected);
+                let _ = self.room_emitter.send(RoomEvent::Reconnected);
+
+                // TODO(theomonnom): Update subscriptions settings
+                // TODO(theomonnom): Send sync state
+            }
+            EngineEvent::Restarting => self.handle_restarting(),
+            EngineEvent::Restarted => self.handle_restarted(),
+            EngineEvent::Disconnected => self.handle_disconnected(),
+            EngineEvent::Data {
+                payload,
+                kind,
+                participant_sid,
+            } => {
+                let payload = Arc::new(payload);
+                if let Some(participant) = self.get_participant(&participant_sid.into()) {
+                    let _ = self.room_emitter.send(RoomEvent::DataReceived {
+                        payload: payload.clone(),
+                        kind,
+                        participant: participant.clone(),
+                    });
+
+                    participant.on_data_received(payload, kind);
+                }
+            }
+            EngineEvent::SpeakersChanged { speakers } => self.handle_speakers_changed(speakers),
+            EngineEvent::ConnectionQuality { updates } => {
+                self.handle_connection_quality_update(updates)
+            }
+        }
+
+        Ok(())
+    }
+
+    #[instrument(level = Level::DEBUG)]
+    async fn close(&self) {
+        self.rtc_engine.close().await;
+    }
+
+    /// Change the connection state and emit an event
+    /// Does nothing if the state is already the same
+    #[instrument(level = Level::DEBUG)]
+    fn update_connection_state(&self, state: ConnectionState) -> bool {
+        let old_state = self.state.load(Ordering::Acquire);
+        if old_state == state as u8 {
+            return false;
+        }
+
+        self.state.store(state as u8, Ordering::Release);
+        let _ = self
+            .room_emitter
+            .send(RoomEvent::ConnectionStateChanged(state));
+        return true;
+    }
+
+    /// Update the participants inside a Room.
+    /// It'll create, update or remove a participant
+    /// It also update the participant tracks.
+    #[instrument(level = Level::DEBUG)]
+    fn handle_participant_update(self: &Arc<Self>, update: proto::ParticipantUpdate) {
+        for pi in update.participants {
+            if pi.sid == self.local_participant.sid()
+                || pi.identity == self.local_participant.identity()
+            {
+                self.local_participant.clone().update_info(pi, true);
+                continue;
+            }
+
+            let remote_participant = self.get_participant(&pi.sid.clone().into());
+
+            if let Some(remote_participant) = remote_participant {
+                if pi.state == participant_info::State::Disconnected as i32 {
+                    // Participant disconnected
+                    self.clone()
+                        .handle_participant_disconnect(remote_participant)
+                } else {
+                    // Participant is already connected, update the it
+                    remote_participant.update_info(pi.clone(), true);
+                }
+            } else {
+                // Create a new participant
+                let remote_participant = {
+                    let pi = pi.clone();
+                    self.create_participant(pi.sid.into(), pi.identity.into(), pi.name, pi.metadata)
+                };
+
+                let _ = self
+                    .room_emitter
+                    .send(RoomEvent::ParticipantConnected(remote_participant.clone()));
+
+                remote_participant.update_info(pi.clone(), true);
+            }
+        }
+    }
+
+    /// Active speakers changed
+    /// Update the participants & sort the active_speakers by audio_level
+    #[instrument(level = Level::DEBUG)]
+    fn handle_speakers_changed(&self, speakers_info: Vec<SpeakerInfo>) {
+        let mut speakers = Vec::new();
+
+        for speaker in speakers_info {
+            let participant = {
+                if speaker.sid == self.local_participant.sid() {
+                    Participant::Local(self.local_participant.clone())
+                } else {
+                    if let Some(participant) = self.get_participant(&speaker.sid.into()) {
+                        Participant::Remote(participant)
+                    } else {
+                        continue;
+                    }
+                }
+            };
+
+            participant.set_speaking(speaker.active);
+            participant.set_audio_level(speaker.level);
+
+            if speaker.active {
+                speakers.push(participant);
+            }
+        }
+
+        speakers.sort_by(|a, b| a.audio_level().partial_cmp(&b.audio_level()).unwrap());
+        *self.active_speakers.write() = speakers.clone();
+
+        let _ = self
+            .room_emitter
+            .send(RoomEvent::ActiveSpeakersChanged { speakers });
+    }
+
+    /// Handle a connection quality update
+    /// Emit ConnectionQualityChanged event for the concerned participants
+    #[instrument(level = Level::DEBUG)]
+    fn handle_connection_quality_update(&self, updates: Vec<proto::ConnectionQualityInfo>) {
+        for update in updates {
+            let participant = {
+                if update.participant_sid == self.local_participant.sid() {
+                    Participant::Local(self.local_participant.clone())
+                } else {
+                    if let Some(participant) = self.get_participant(&update.participant_sid.into())
+                    {
+                        Participant::Remote(participant)
+                    } else {
+                        continue;
+                    }
+                }
+            };
+
+            let quality: ConnectionQuality = proto::ConnectionQuality::from_i32(update.quality)
+                .unwrap()
+                .into();
+
+            participant.set_connection_quality(quality);
+            let _ = self.room_emitter.send(RoomEvent::ConnectionQualityChanged {
+                participant,
+                quality,
+            });
+        }
+    }
+
+    #[instrument(level = Level::DEBUG)]
+    fn handle_restarting(self: &Arc<Self>) {
+        // Remove existing participants/subscriptions on full reconnect
+        for (_, participant) in self.participants.read().iter() {
+            self.clone()
+                .handle_participant_disconnect(participant.clone());
+        }
+
+        if self.update_connection_state(ConnectionState::Reconnecting) {
+            let _ = self.room_emitter.send(RoomEvent::Reconnecting);
+        }
+    }
+
+    #[instrument(level = Level::DEBUG)]
+    fn handle_restarted(self: &Arc<Self>) {
+        // Full reconnect succeeded!
+        let join_response = self.rtc_engine.join_response().unwrap();
+
+        self.update_connection_state(ConnectionState::Connected);
+        let _ = self.room_emitter.send(RoomEvent::Reconnected);
+
+        if let Some(pi) = join_response.participant {
+            self.local_participant.update_info(pi, true); // The sid may have changed
+        }
+
+        self.handle_participant_update(proto::ParticipantUpdate {
+            participants: join_response.other_participants,
+        });
+
+        // TODO(theomonnom): unpublish & republish tracks
+    }
+
+    #[instrument(level = Level::DEBUG)]
+    fn handle_disconnected(&self) {
+        if self.state.load(Ordering::Acquire) == ConnectionState::Disconnected as u8 {
+            return;
+        }
+
+        self.update_connection_state(ConnectionState::Disconnected);
+        let _ = self.room_emitter.send(RoomEvent::Disconnected);
+    }
+
+    /// Create a new participant
+    /// Also add it to the participants list
+    #[instrument(level = Level::DEBUG)]
+    fn create_participant(
+        self: &Arc<Self>,
+        sid: ParticipantSid,
+        identity: ParticipantIdentity,
+        name: String,
+        metadata: String,
+    ) -> Arc<RemoteParticipant> {
+        let participant = Arc::new(RemoteParticipant::new(
+            sid.clone(),
+            identity,
+            name,
+            metadata,
+        ));
+
+        // Create the participant task
+        let (close_tx, close_rx) = oneshot::channel();
+        let participant_task = tokio::spawn(self.clone().participant_task(
+            Participant::Remote(participant.clone()),
+            participant.register_observer(),
+            close_rx,
+        ));
+        self.participants_tasks
+            .write()
+            .insert(sid.clone(), (participant_task, close_tx));
+
+        self.participants.write().insert(sid, participant.clone());
+        participant
+    }
+
+    /// A participant has disconnected
+    /// Cleanup the participant and emit an event
+    #[instrument(level = Level::DEBUG)]
+    fn handle_participant_disconnect(self: Arc<Self>, remote_participant: Arc<RemoteParticipant>) {
+        tokio::spawn(async move {
+            for (sid, _) in &*remote_participant.tracks() {
+                remote_participant.unpublish_track(&sid, true);
+            }
+
+            // Close the participant task
+            if let Some((task, close_tx)) = self
+                .participants_tasks
+                .write()
+                .remove(&remote_participant.sid())
+            {
+                let _ = close_tx.send(());
+                let _ = task.await;
+            }
+
+            self.participants.write().remove(&remote_participant.sid());
+
+            let _ = self.room_emitter.send(RoomEvent::ParticipantDisconnected(
+                remote_participant.clone(),
+            ));
+        });
+    }
+
+    fn get_participant(&self, sid: &ParticipantSid) -> Option<Arc<RemoteParticipant>> {
+        self.participants.read().get(sid).cloned()
+    }
+}
+
+fn unpack_stream_id(stream_id: &str) -> Option<(&str, &str)> {
+    let split: Vec<&str> = stream_id.split('|').collect();
+    if split.len() == 2 {
+        let participant_sid = split.get(0).unwrap();
+        let track_sid = split.get(1).unwrap();
+        Some((participant_sid, track_sid))
+    } else {
+        None
+    }
+}

livekit/src/room/track/audio_track.rs

@@ -0,0 +1,31 @@
+use crate::room::track::local_audio_track::LocalAudioTrack;
+use crate::room::track::remote_audio_track::RemoteAudioTrack;
+use crate::room::track::TrackHandle;
+use std::sync::Arc;
+
+#[derive(Clone)]
+pub enum AudioTrackHandle {
+    Local(Arc<LocalAudioTrack>),
+    Remote(Arc<RemoteAudioTrack>),
+}
+
+impl From<AudioTrackHandle> for TrackHandle {
+    fn from(audio_track: AudioTrackHandle) -> Self {
+        match audio_track {
+            AudioTrackHandle::Local(local_audio) => Self::LocalAudio(local_audio),
+            AudioTrackHandle::Remote(remote_audio) => Self::RemoteAudio(remote_audio),
+        }
+    }
+}
+
+impl TryFrom<TrackHandle> for AudioTrackHandle {
+    type Error = &'static str;
+
+    fn try_from(track: TrackHandle) -> Result<Self, Self::Error> {
+        match track {
+            TrackHandle::LocalAudio(local_audio) => Ok(Self::Local(local_audio)),
+            TrackHandle::RemoteAudio(remote_audio) => Ok(Self::Remote(remote_audio)),
+            _ => Err("not a audio track"),
+        }
+    }
+}

livekit/src/room/track/local_audio_track.rs

@@ -0,0 +1,8 @@
+use crate::room::track::{impl_track_trait, TrackShared};
+
+#[derive(Debug)]
+pub struct LocalAudioTrack {
+    shared: TrackShared,
+}
+
+impl_track_trait!(LocalAudioTrack);

livekit/src/room/track/local_track.rs

@@ -0,0 +1,31 @@
+use crate::room::track::local_audio_track::LocalAudioTrack;
+use crate::room::track::local_video_track::LocalVideoTrack;
+use crate::room::track::TrackHandle;
+use std::sync::Arc;
+
+#[derive(Clone)]
+pub enum LocalTrackHandle {
+    Audio(Arc<LocalAudioTrack>),
+    Video(Arc<LocalVideoTrack>),
+}
+
+impl From<LocalTrackHandle> for TrackHandle {
+    fn from(local_track: LocalTrackHandle) -> Self {
+        match local_track {
+            LocalTrackHandle::Audio(local_audio) => Self::LocalAudio(local_audio),
+            LocalTrackHandle::Video(local_video) => Self::LocalVideo(local_video),
+        }
+    }
+}
+
+impl TryFrom<TrackHandle> for LocalTrackHandle {
+    type Error = &'static str;
+
+    fn try_from(track: TrackHandle) -> Result<Self, Self::Error> {
+        match track {
+            TrackHandle::LocalAudio(local_audio) => Ok(Self::Audio(local_audio)),
+            TrackHandle::LocalVideo(local_video) => Ok(Self::Video(local_video)),
+            _ => Err("not a local track"),
+        }
+    }
+}

livekit/src/room/track/local_video_track.rs

@@ -0,0 +1,8 @@
+use crate::room::track::{impl_track_trait, TrackShared};
+
+#[derive(Debug)]
+pub struct LocalVideoTrack {
+    shared: TrackShared,
+}
+
+impl_track_trait!(LocalVideoTrack);

livekit/src/room/track/mod.rs

@@ -0,0 +1,257 @@
+use crate::proto::{TrackSource as ProtoTrackSource, TrackType};
+use crate::room::id::TrackSid;
+use crate::room::track::local_audio_track::LocalAudioTrack;
+use crate::room::track::local_video_track::LocalVideoTrack;
+use crate::room::track::remote_audio_track::RemoteAudioTrack;
+use crate::room::track::remote_video_track::RemoteVideoTrack;
+use livekit_utils::enum_dispatch;
+use livekit_utils::observer::Dispatcher;
+use livekit_webrtc::media_stream::{MediaStreamTrackHandle, MediaStreamTrackTrait};
+use parking_lot::Mutex;
+use std::sync::atomic::{AtomicBool, AtomicU8, Ordering};
+use std::sync::Arc;
+use tokio::sync::mpsc;
+
+pub mod audio_track;
+pub mod local_audio_track;
+pub mod local_track;
+pub mod local_video_track;
+pub mod remote_audio_track;
+pub mod remote_track;
+pub mod remote_video_track;
+pub mod video_track;
+
+#[derive(Debug)]
+pub enum TrackKind {
+    Unknown,
+    Audio,
+    Video,
+}
+
+impl From<u8> for TrackKind {
+    fn from(val: u8) -> Self {
+        match val {
+            1 => Self::Audio,
+            2 => Self::Video,
+            _ => Self::Unknown,
+        }
+    }
+}
+
+impl From<TrackType> for TrackKind {
+    fn from(r#type: TrackType) -> Self {
+        match r#type {
+            TrackType::Audio => Self::Audio,
+            TrackType::Video => Self::Video,
+            _ => Self::Unknown,
+        }
+    }
+}
+
+#[derive(Debug)]
+pub enum StreamState {
+    Unknown,
+    Active,
+    Paused,
+}
+
+impl From<u8> for StreamState {
+    fn from(val: u8) -> Self {
+        match val {
+            1 => Self::Active,
+            2 => Self::Paused,
+            _ => Self::Unknown,
+        }
+    }
+}
+
+#[derive(Debug)]
+pub enum TrackSource {
+    Unknown,
+    Camera,
+    Microphone,
+    Screenshare,
+    ScreenshareAudio,
+}
+
+impl From<u8> for TrackSource {
+    fn from(val: u8) -> Self {
+        match val {
+            1 => Self::Camera,
+            2 => Self::Microphone,
+            3 => Self::Screenshare,
+            4 => Self::ScreenshareAudio,
+            _ => Self::Unknown,
+        }
+    }
+}
+
+impl From<ProtoTrackSource> for TrackSource {
+    fn from(source: ProtoTrackSource) -> Self {
+        match source {
+            ProtoTrackSource::Camera => Self::Camera,
+            ProtoTrackSource::Microphone => Self::Microphone,
+            ProtoTrackSource::ScreenShare => Self::Screenshare,
+            ProtoTrackSource::ScreenShareAudio => Self::ScreenshareAudio,
+            ProtoTrackSource::Unknown => Self::Unknown,
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug)]
+pub struct TrackDimension(pub u32, pub u32);
+
+pub trait TrackTrait {
+    fn sid(&self) -> TrackSid;
+    fn name(&self) -> String;
+    fn kind(&self) -> TrackKind;
+    fn stream_state(&self) -> StreamState;
+    fn start(&self);
+    fn stop(&self);
+    fn register_observer(&self) -> mpsc::UnboundedReceiver<TrackEvent>;
+    fn set_muted(&self, muted: bool);
+}
+
+#[derive(Debug, Clone)]
+pub enum TrackEvent {
+    Mute,
+    Unmute,
+}
+
+#[derive(Debug)]
+pub(super) struct TrackShared {
+    pub(super) sid: Mutex<TrackSid>,
+    pub(super) name: Mutex<String>,
+    pub(super) kind: AtomicU8,         // TrackKind
+    pub(super) stream_state: AtomicU8, // StreamState
+    pub(super) muted: AtomicBool,
+    pub(super) rtc_track: MediaStreamTrackHandle,
+    pub(super) dispatcher: Mutex<Dispatcher<TrackEvent>>,
+}
+
+impl TrackShared {
+    pub(crate) fn new(
+        sid: TrackSid,
+        name: String,
+        kind: TrackKind,
+        rtc_track: MediaStreamTrackHandle,
+    ) -> Self {
+        Self {
+            sid: Mutex::new(sid),
+            name: Mutex::new(name),
+            kind: AtomicU8::new(kind as u8),
+            stream_state: AtomicU8::new(StreamState::Active as u8),
+            muted: AtomicBool::new(false),
+            rtc_track,
+            dispatcher: Default::default(),
+        }
+    }
+
+    pub(crate) fn start(&self) {
+        self.rtc_track.set_enabled(true);
+    }
+
+    pub(crate) fn stop(&self) {
+        self.rtc_track.set_enabled(false);
+    }
+
+    pub(crate) fn set_muted(&self, muted: bool) {
+        if self.muted.load(Ordering::SeqCst) == muted {
+            return;
+        }
+
+        self.muted.store(muted, Ordering::SeqCst);
+        self.rtc_track.set_enabled(!muted);
+
+        self.dispatcher.lock().dispatch(if muted {
+            &TrackEvent::Mute
+        } else {
+            &TrackEvent::Unmute
+        });
+    }
+
+    pub(crate) fn register_observer(&self) -> mpsc::UnboundedReceiver<TrackEvent> {
+        self.dispatcher.lock().register()
+    }
+}
+
+#[derive(Clone, Debug)]
+pub enum TrackHandle {
+    LocalVideo(Arc<LocalVideoTrack>),
+    LocalAudio(Arc<LocalAudioTrack>),
+    RemoteVideo(Arc<RemoteVideoTrack>),
+    RemoteAudio(Arc<RemoteAudioTrack>),
+}
+
+impl TrackTrait for TrackHandle {
+    enum_dispatch!(
+        [LocalVideo, LocalAudio, RemoteVideo, RemoteAudio]
+        fnc!(sid, &Self, [], TrackSid);
+        fnc!(name, &Self, [], String);
+        fnc!(kind, &Self, [], TrackKind);
+        fnc!(stream_state, &Self, [], StreamState);
+        fnc!(start, &Self, [], ());
+        fnc!(stop, &Self, [], ());
+        fnc!(register_observer, &Self, [], mpsc::UnboundedReceiver<TrackEvent>);
+        fnc!(set_muted, &Self, [muted: bool], ());
+    );
+}
+
+impl TrackHandle {
+    pub fn rtc_track(&self) -> MediaStreamTrackHandle {
+        match self {
+            Self::RemoteVideo(remote_video) => {
+                MediaStreamTrackHandle::Video(remote_video.rtc_track())
+            }
+            Self::RemoteAudio(remote_audio) => {
+                MediaStreamTrackHandle::Audio(remote_audio.rtc_track())
+            }
+            _ => todo!(),
+        }
+    }
+}
+
+macro_rules! impl_track_trait {
+    ($x:ident) => {
+        use std::sync::atomic::Ordering;
+        use tokio::sync::mpsc;
+        use $crate::room::id::TrackSid;
+        use $crate::room::track::{StreamState, TrackEvent, TrackKind, TrackTrait};
+
+        impl TrackTrait for $x {
+            fn sid(&self) -> TrackSid {
+                self.shared.sid.lock().clone()
+            }
+
+            fn name(&self) -> String {
+                self.shared.name.lock().clone()
+            }
+
+            fn kind(&self) -> TrackKind {
+                self.shared.kind.load(Ordering::SeqCst).into()
+            }
+
+            fn stream_state(&self) -> StreamState {
+                self.shared.stream_state.load(Ordering::SeqCst).into()
+            }
+
+            fn start(&self) {
+                self.shared.start();
+            }
+
+            fn stop(&self) {
+                self.shared.stop();
+            }
+
+            fn register_observer(&self) -> mpsc::UnboundedReceiver<TrackEvent> {
+                self.shared.register_observer()
+            }
+
+            fn set_muted(&self, muted: bool) {
+                self.shared.set_muted(muted);
+            }
+        }
+    };
+}
+
+pub(super) use impl_track_trait;

livekit/src/room/track/remote_audio_track.rs

@@ -0,0 +1,31 @@
+use crate::room::track::{impl_track_trait, TrackShared};
+use livekit_webrtc::media_stream::{AudioTrack, MediaStreamTrackHandle};
+use std::sync::Arc;
+
+#[derive(Debug)]
+pub struct RemoteAudioTrack {
+    shared: TrackShared,
+}
+
+impl RemoteAudioTrack {
+    pub(crate) fn new(sid: TrackSid, name: String, track: Arc<AudioTrack>) -> Self {
+        Self {
+            shared: TrackShared::new(
+                sid,
+                name,
+                TrackKind::Audio,
+                MediaStreamTrackHandle::Audio(track),
+            ),
+        }
+    }
+
+    pub fn rtc_track(&self) -> Arc<AudioTrack> {
+        if let MediaStreamTrackHandle::Audio(audio) = &self.shared.rtc_track {
+            audio.clone()
+        } else {
+            unreachable!()
+        }
+    }
+}
+
+impl_track_trait!(RemoteAudioTrack);

livekit/src/room/track/remote_track.rs

@@ -0,0 +1,51 @@
+use std::sync::Arc;
+use super::{StreamState, TrackKind};
+use crate::room::id::TrackSid;
+use crate::room::track::remote_audio_track::RemoteAudioTrack;
+use crate::room::track::remote_video_track::RemoteVideoTrack;
+use crate::room::track::{TrackHandle, TrackEvent};
+use tokio::sync::mpsc;
+use livekit_utils::enum_dispatch;
+
+use super::TrackTrait;
+
+#[derive(Clone, Debug)]
+pub enum RemoteTrackHandle {
+    Audio(Arc<RemoteAudioTrack>),
+    Video(Arc<RemoteVideoTrack>),
+}
+
+impl TrackTrait for RemoteTrackHandle {
+    enum_dispatch!(
+        [Audio, Video]
+        fnc!(sid, &Self, [], TrackSid);
+        fnc!(name, &Self, [], String);
+        fnc!(kind, &Self, [], TrackKind);
+        fnc!(stream_state, &Self, [], StreamState);
+        fnc!(start, &Self, [], ());
+        fnc!(stop, &Self, [], ());
+        fnc!(register_observer, &Self, [], mpsc::UnboundedReceiver<TrackEvent>);
+        fnc!(set_muted, &Self, [muted: bool], ());
+    );
+}
+
+impl From<RemoteTrackHandle> for TrackHandle {
+    fn from(remote_track: RemoteTrackHandle) -> Self {
+        match remote_track {
+            RemoteTrackHandle::Audio(remote_audio) => Self::RemoteAudio(remote_audio),
+            RemoteTrackHandle::Video(remote_video) => Self::RemoteVideo(remote_video),
+        }
+    }
+}
+
+impl TryFrom<TrackHandle> for RemoteTrackHandle {
+    type Error = &'static str;
+
+    fn try_from(track: TrackHandle) -> Result<Self, Self::Error> {
+        match track {
+            TrackHandle::RemoteAudio(remote_audio) => Ok(Self::Audio(remote_audio)),
+            TrackHandle::RemoteVideo(remote_video) => Ok(Self::Video(remote_video)),
+            _ => Err("not a remote track"),
+        }
+    }
+}

livekit/src/room/track/remote_video_track.rs

@@ -0,0 +1,32 @@
+use livekit_webrtc::media_stream::{MediaStreamTrackHandle, VideoTrack};
+use std::sync::Arc;
+
+use crate::room::track::{impl_track_trait, TrackShared};
+
+#[derive(Debug)]
+pub struct RemoteVideoTrack {
+    shared: TrackShared,
+}
+
+impl RemoteVideoTrack {
+    pub(crate) fn new(sid: TrackSid, name: String, track: Arc<VideoTrack>) -> Self {
+        Self {
+            shared: TrackShared::new(
+                sid,
+                name,
+                TrackKind::Video,
+                MediaStreamTrackHandle::Video(track),
+            ),
+        }
+    }
+
+    pub fn rtc_track(&self) -> Arc<VideoTrack> {
+        if let MediaStreamTrackHandle::Video(video) = &self.shared.rtc_track {
+            video.clone()
+        } else {
+            unreachable!()
+        }
+    }
+}
+
+impl_track_trait!(RemoteVideoTrack);

livekit/src/room/track/video_track.rs

@@ -0,0 +1,31 @@
+use crate::room::track::local_video_track::LocalVideoTrack;
+use crate::room::track::remote_video_track::RemoteVideoTrack;
+use crate::room::track::TrackHandle;
+use std::sync::Arc;
+
+#[derive(Clone)]
+pub enum VideoTrackHandle {
+    Local(Arc<LocalVideoTrack>),
+    Remote(Arc<RemoteVideoTrack>),
+}
+
+impl From<VideoTrackHandle> for TrackHandle {
+    fn from(video_track: VideoTrackHandle) -> Self {
+        match video_track {
+            VideoTrackHandle::Local(local_video) => Self::LocalVideo(local_video),
+            VideoTrackHandle::Remote(remote_video) => Self::RemoteVideo(remote_video),
+        }
+    }
+}
+
+impl TryFrom<TrackHandle> for VideoTrackHandle {
+    type Error = &'static str;
+
+    fn try_from(track: TrackHandle) -> Result<Self, Self::Error> {
+        match track {
+            TrackHandle::LocalVideo(local_video) => Ok(Self::Local(local_video)),
+            TrackHandle::RemoteVideo(remote_video) => Ok(Self::Remote(remote_video)),
+            _ => Err("not a video track"),
+        }
+    }
+}