Initial Room

Switching computer

crates/livekit-webrtc/src/data_channel.rs

@@ -99,6 +99,12 @@ impl DataChannel {
     }
 }
 
+impl Drop for DataChannel {
+    fn drop(&mut self) {
+        self.cxx_handle.pin_mut().unregister_observer();
+    }
+}
+
 pub type OnStateChangeHandler = Box<dyn FnMut() + Send + Sync>;
 pub type OnMessageHandler = Box<dyn FnMut(&[u8], bool) + Send + Sync>;
 // data, is_binary

crates/livekit-webrtc/src/jsep.rs

@@ -17,8 +17,16 @@ impl Debug for IceCandidate {
 }
 
 impl IceCandidate {
-    pub fn from(sdp_mid: &str, sdp_mline_index: i32, sdp: &str) -> Result<IceCandidate, SdpParseError> {
-        let res = sys_jsep::ffi::create_ice_candidate(sdp_mid.to_string(), sdp_mline_index, sdp.to_string());
+    pub fn from(
+        sdp_mid: &str,
+        sdp_mline_index: i32,
+        sdp: &str,
+    ) -> Result<IceCandidate, SdpParseError> {
+        let res = sys_jsep::ffi::create_ice_candidate(
+            sdp_mid.to_string(),
+            sdp_mline_index,
+            sdp.to_string(),
+        );
 
         match res {
             Ok(cxx_handle) => Ok(IceCandidate::new(cxx_handle)),

crates/livekit-webrtc/src/media_stream.rs

@@ -1,2 +1,51 @@
-#[derive(Debug)]
-pub struct MediaStream {}
+use cxx::UniquePtr;
+
+use libwebrtc_sys::media_stream as sys_ms;
+
+pub use sys_ms::ffi::TrackState;
+
+pub struct MediaStreamTrack {
+    cxx_handle: UniquePtr<sys_ms::ffi::MediaStreamTrack>,
+}
+
+impl MediaStreamTrack {
+    pub(crate) fn new(cxx_handle: UniquePtr<sys_ms::ffi::MediaStreamTrack>) -> Self {
+        Self { cxx_handle }
+    }
+
+    fn kind(&self) -> String {
+        self.cxx_handle.kind()
+    }
+
+    fn id(&self) -> String {
+        self.cxx_handle.id()
+    }
+
+    fn enabled(&self) -> bool {
+        self.cxx_handle.enabled()
+    }
+
+    fn set_enabled(&mut self, enable: bool) -> bool {
+        self.cxx_handle.pin_mut().set_enabled(enable)
+    }
+
+    fn state(&self) -> TrackState {
+        self.cxx_handle.state()
+    }
+}
+
+pub struct MediaStream {
+    cxx_handle: UniquePtr<sys_ms::ffi::MediaStream>,
+}
+
+impl MediaStream {
+    pub(crate) fn new(cxx_handle: UniquePtr<sys_ms::ffi::MediaStream>) -> Self {
+        Self {
+            cxx_handle
+        }
+    }
+
+    pub fn id(&self) -> String {
+        self.cxx_handle.id()
+    }
+}

crates/livekit-webrtc/src/peer_connection.rs

@@ -402,10 +402,7 @@ impl sys_pc::PeerConnectionObserver for InternalObserver {
         }
     }
 
-    fn on_add_stream(
-        &self,
-        stream: UniquePtr<libwebrtc_sys::media_stream_interface::ffi::MediaStreamInterface>,
-    ) {
+    fn on_add_stream(&self, stream: UniquePtr<libwebrtc_sys::media_stream::ffi::MediaStream>) {
         trace!("on_add_stream");
         let mut handler = self.on_add_stream_handler.lock().unwrap();
         if let Some(f) = handler.as_mut() {
@@ -413,10 +410,7 @@ impl sys_pc::PeerConnectionObserver for InternalObserver {
         }
     }
 
-    fn on_remove_stream(
-        &self,
-        stream: UniquePtr<libwebrtc_sys::media_stream_interface::ffi::MediaStreamInterface>,
-    ) {
+    fn on_remove_stream(&self, stream: UniquePtr<libwebrtc_sys::media_stream::ffi::MediaStream>) {
         trace!("on_remove_stream");
         let mut handler = self.on_remove_stream_handler.lock().unwrap();
         if let Some(f) = handler.as_mut() {
@@ -548,12 +542,13 @@ impl sys_pc::PeerConnectionObserver for InternalObserver {
     fn on_add_track(
         &self,
         receiver: UniquePtr<libwebrtc_sys::rtp_receiver::ffi::RtpReceiver>,
-        streams: Vec<UniquePtr<libwebrtc_sys::media_stream_interface::ffi::MediaStreamInterface>>,
+        streams: Vec<UniquePtr<libwebrtc_sys::media_stream::ffi::MediaStream>>,
     ) {
         trace!("on_add_track");
         let mut handler = self.on_add_track_handler.lock().unwrap();
         if let Some(f) = handler.as_mut() {
-            // TODO(theomonnom)
+            let streams = streams.into_iter().map(MediaStream::new).collect();
+            f(RtpReceiver::new(receiver), streams)
         }
     }
 

crates/livekit-webrtc/src/peer_connection_factory.rs

@@ -18,7 +18,9 @@ pub struct PeerConnectionFactory {
 impl PeerConnectionFactory {
     pub fn new(rtc_runtime: RTCRuntime) -> Self {
         Self {
-            cxx_handle: sys_factory::ffi::create_peer_connection_factory(rtc_runtime.clone().release()),
+            cxx_handle: sys_factory::ffi::create_peer_connection_factory(
+                rtc_runtime.clone().release(),
+            ),
             rtc_runtime,
         }
     }
@@ -31,8 +33,9 @@ impl PeerConnectionFactory {
 
         unsafe {
             let mut observer = Box::new(InternalObserver::default());
-            let mut native_observer = sys_pc::ffi::create_native_peer_connection_observer(self.rtc_runtime.clone().release(),
-                                                                                          Box::new(sys_pc::PeerConnectionObserverWrapper::new(&mut *observer)),
+            let mut native_observer = sys_pc::ffi::create_native_peer_connection_observer(
+                self.rtc_runtime.clone().release(),
+                Box::new(sys_pc::PeerConnectionObserverWrapper::new(&mut *observer)),
             );
 
             let res = self

crates/livekit-webrtc/src/rtc_error.rs

@@ -1,3 +1,2 @@
 // TODO(theomonnom) Wrap the RTCError ffi so we can use Option(u16)
 pub use libwebrtc_sys::rtc_error::ffi::RTCError;
-

crates/livekit-webrtc/src/rtp_receiver.rs

@@ -1,2 +1,17 @@
-#[derive(Debug)]
-pub struct RtpReceiver {}
+use crate::media_stream::MediaStreamTrack;
+use cxx::UniquePtr;
+use libwebrtc_sys::rtp_receiver as sys_rec;
+
+pub struct RtpReceiver {
+    cxx_handle: UniquePtr<sys_rec::ffi::RtpReceiver>,
+}
+
+impl RtpReceiver {
+    pub(crate) fn new(cxx_handle: UniquePtr<sys_rec::ffi::RtpReceiver>) -> Self {
+        Self { cxx_handle }
+    }
+
+    pub fn track(&self) -> MediaStreamTrack {
+        MediaStreamTrack::new(self.cxx_handle.track())
+    }
+}