wip

crates/livekit-core/src/room/mod.rs

@@ -23,8 +23,8 @@ use crate::signal_client::SignalOptions;
 
 pub use crate::rtc_engine::SimulateScenario;
 
+mod room_session;
 pub mod id;
-mod internal;
 pub mod participant;
 pub mod publication;
 pub mod track;
@@ -48,11 +48,11 @@ pub enum ConnectionState {
 }
 
 #[derive(Clone, Debug)]
-pub struct RoomHandle {
-    session: Arc<RoomSession>,
+pub struct RoomSession {
+    internal: Arc<RoomInternal>,
 }
 
-impl RoomHandle {
+impl RoomSession {
     pub fn sid(&self) -> String {
         self.session.sid.lock().clone()
     }
@@ -72,7 +72,7 @@ impl RoomHandle {
 
 #[derive(Debug, Default)]
 pub struct Room {
-    session: Option<RoomHandle>,
+    session: Option<Arc<RoomSession>>,
     events: Arc<RoomEvents>, // Keep the same RoomEvents across sessions
 }
 
@@ -90,9 +90,73 @@ impl Room {
         self.events.clone()
     }
 
-    pub fn get_handle(&self) -> Option<RoomHandle> {
+    pub fn session(&self) -> Option<> {
         self.internal.as_ref().map(|internal| RoomHandle {
             internal: internal.clone(),
         })
     }
 }
+
+#[derive(Debug)]
+pub struct RoomInternal {
+    inner: Arc<RoomInner>,
+    session_task: JoinHandle<()>,
+    close_emitter: oneshot::Sender<()>,
+}
+
+impl RoomInternal {
+    pub async fn connect(room_events: Arc<RoomEvents>, 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::Connecting as u8),
+            sid: Mutex::new(room_info.sid),
+            name: Mutex::new(room_info.name),
+            participants: Default::default(),
+            rtc_engine,
+            local_participant,
+            room_events,
+        });
+
+        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());
+            participant
+                .update_tracks(RoomHandle::from(inner.clone()), pi.tracks)
+                .await;
+        }
+
+        let (close_emitter, close_receiver) = oneshot::channel();
+        let session_task = tokio::spawn(inner.room_task(engine_events, close_receiver));
+
+        let session = Self {
+            inner,
+            session_task,
+            close_emitter,
+        };
+        Ok(session)
+    }
+
+    pub async fn close(self) {
+        self.inner.close();
+        let _ = self.close_emitter.send(());
+        self.session_task.await;
+    }
+}