Initial Room

Switching computer

crates/livekit-webrtc/libwebrtc-sys/build.rs

@@ -71,7 +71,7 @@ fn main() {
     let mut builder = cxx_build::bridges(&[
         "src/peer_connection.rs",
         "src/peer_connection_factory.rs",
-        "src/media_stream_interface.rs",
+        "src/media_stream.rs",
         "src/data_channel.rs",
         "src/jsep.rs",
         "src/candidate.rs",
@@ -83,7 +83,7 @@ fn main() {
 
     builder.file("src/peer_connection.cpp");
     builder.file("src/peer_connection_factory.cpp");
-    builder.file("src/media_stream_interface.cpp");
+    builder.file("src/media_stream.cpp");
     builder.file("src/data_channel.cpp");
     builder.file("src/jsep.cpp");
     builder.file("src/candidate.cpp");
@@ -203,7 +203,7 @@ fn main() {
             let jni_regex = Regex::new(r"(Java_org_webrtc.*)").unwrap();
             let content = &String::from_utf8_lossy(&readelf_output.stdout);
             let mut jni_symbols = Vec::new();
-            jni_regex.captures_iter(&content).for_each(|cap| {
+            jni_regex.captures_iter(content).for_each(|cap| {
                 jni_symbols.push(cap.get(1).unwrap().as_str());
             });
 
@@ -215,7 +215,7 @@ fn main() {
 
             write!(vs_file, "JNI_WEBRTC {{\n\tglobal: ").unwrap();
             write!(vs_file, "JNI_OnLoad; ").unwrap();
-            for x in &jni_symbols {
+            for x in jni_symbols {
                 println!("cargo:rustc-link-arg=-Wl,--undefined={}", x);
                 write!(vs_file, "{}; ", x).unwrap();
             }

crates/livekit-webrtc/libwebrtc-sys/include/livekit/media_stream.h

@@ -0,0 +1,52 @@
+//
+// Created by Théo Monnom on 31/08/2022.
+//
+
+#ifndef CLIENT_SDK_NATIVE_MEDIA_STREAM_INTERFACE_H
+#define CLIENT_SDK_NATIVE_MEDIA_STREAM_INTERFACE_H
+
+#include <memory>
+
+#include "api/media_stream_interface.h"
+#include "livekit/rust_types.h"
+#include "rust/cxx.h"
+
+namespace livekit {
+
+class MediaStreamTrack {
+ public:
+  explicit MediaStreamTrack(
+      rtc::scoped_refptr<webrtc::MediaStreamTrackInterface> track);
+
+  rust::String kind() const;
+  rust::String id() const;
+
+  bool enabled() const;
+  bool set_enabled(bool enable);
+
+  TrackState state() const;
+
+ private:
+  rtc::scoped_refptr<webrtc::MediaStreamTrackInterface> track_;
+};
+
+static std::unique_ptr<MediaStreamTrack> _unique_media_stream_track() {
+  return nullptr;  // Ignore
+}
+
+class MediaStream {
+ public:
+  explicit MediaStream(rtc::scoped_refptr<webrtc::MediaStreamInterface> stream);
+
+  rust::String id() const;
+
+ private:
+  rtc::scoped_refptr<webrtc::MediaStreamInterface> media_stream_;
+};
+
+static std::unique_ptr<MediaStream> _unique_media_stream() {
+  return nullptr;  // Ignore
+}
+}  // namespace livekit
+
+#endif  // CLIENT_SDK_NATIVE_MEDIA_STREAM_INTERFACE_H

crates/livekit-webrtc/libwebrtc-sys/include/livekit/media_stream_interface.h

@@ -1,28 +0,0 @@
-//
-// Created by Théo Monnom on 31/08/2022.
-//
-
-#ifndef CLIENT_SDK_NATIVE_MEDIA_STREAM_INTERFACE_H
-#define CLIENT_SDK_NATIVE_MEDIA_STREAM_INTERFACE_H
-
-#include <memory>
-
-#include "api/media_stream_interface.h"
-
-namespace livekit {
-
-class MediaStreamInterface {
- public:
-  explicit MediaStreamInterface(
-      rtc::scoped_refptr<webrtc::MediaStreamInterface> stream);
-
- private:
-  rtc::scoped_refptr<webrtc::MediaStreamInterface> media_stream_;
-};
-
-static std::unique_ptr<MediaStreamInterface> _unique_media_stream() {
-  return nullptr;  // Ignore
-}
-}  // namespace livekit
-
-#endif  // CLIENT_SDK_NATIVE_MEDIA_STREAM_INTERFACE_H

crates/livekit-webrtc/libwebrtc-sys/include/livekit/rtp_receiver.h

@@ -8,6 +8,7 @@
 #include <memory>
 
 #include "api/rtp_receiver_interface.h"
+#include "livekit/media_stream.h"
 
 namespace livekit {
 
@@ -16,6 +17,8 @@ class RtpReceiver {
   explicit RtpReceiver(
       rtc::scoped_refptr<webrtc::RtpReceiverInterface> receiver);
 
+  std::unique_ptr<MediaStreamTrack> track() const;
+
  private:
   rtc::scoped_refptr<webrtc::RtpReceiverInterface> receiver_;
 };

crates/livekit-webrtc/libwebrtc-sys/include/livekit/rust_types.h

@@ -23,6 +23,7 @@ enum class IceConnectionState;
 enum class IceGatheringState;
 enum class SdpType;
 enum class DataState;
+enum class TrackState;
 struct SdpParseError;
 struct RTCOfferAnswerOptions;
 struct RTCError;

crates/livekit-webrtc/libwebrtc-sys/src/jsep.rs

@@ -68,11 +68,18 @@ pub mod ffi {
             observer: Box<SetRemoteSdpObserverWrapper>,
         ) -> UniquePtr<NativeSetRemoteSdpObserverHandle>;
 
-        fn create_ice_candidate(sdp_mid: String, sdp_mline_index: i32, sdp: String) -> Result<UniquePtr<IceCandidate>>;
-        fn create_session_description(sdp_type: SdpType, sdp: String) -> Result<UniquePtr<SessionDescription>>;
+        fn create_ice_candidate(
+            sdp_mid: String,
+            sdp_mline_index: i32,
+            sdp: String,
+        ) -> Result<UniquePtr<IceCandidate>>;
+        fn create_session_description(
+            sdp_type: SdpType,
+            sdp: String,
+        ) -> Result<UniquePtr<SessionDescription>>;
 
         fn _unique_ice_candidate() -> UniquePtr<IceCandidate>; // Ignore
-    fn _unique_session_description() -> UniquePtr<SessionDescription>; // Ignore
+        fn _unique_session_description() -> UniquePtr<SessionDescription>; // Ignore
     }
 }
 
@@ -80,7 +87,11 @@ impl Error for ffi::SdpParseError {}
 
 impl Display for ffi::SdpParseError {
     fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
-        write!(f, "SdpParseError occurred {}: {}", self.line, self.description)
+        write!(
+            f,
+            "SdpParseError occurred {}: {}",
+            self.line, self.description
+        )
     }
 }
 
@@ -101,10 +112,7 @@ impl ffi::SdpParseError {
         let line = String::from(&value[8..line_length]);
         let description = String::from(&value[line_length..]);
 
-        Self {
-            line,
-            description,
-        }
+        Self { line, description }
     }
 }
 

crates/livekit-webrtc/libwebrtc-sys/src/lib.rs

@@ -1,7 +1,7 @@
 pub mod candidate;
 pub mod data_channel;
 pub mod jsep;
-pub mod media_stream_interface;
+pub mod media_stream;
 pub mod peer_connection;
 pub mod peer_connection_factory;
 pub mod rtc_error;

crates/livekit-webrtc/libwebrtc-sys/src/media_stream.cpp

@@ -0,0 +1,41 @@
+//
+// Created by Théo Monnom on 31/08/2022.
+//
+
+#include "livekit/media_stream.h"
+
+namespace livekit {
+
+MediaStreamTrack::MediaStreamTrack(
+    rtc::scoped_refptr<webrtc::MediaStreamTrackInterface> track)
+    : track_(std::move(track)) {}
+
+rust::String MediaStreamTrack::kind() const {
+  return track_->kind();
+}
+
+rust::String MediaStreamTrack::id() const {
+  return track_->id();
+}
+
+bool MediaStreamTrack::enabled() const {
+  return track_->enabled();
+}
+
+bool MediaStreamTrack::set_enabled(bool enable) {
+  return track_->set_enabled(enable);
+}
+
+TrackState MediaStreamTrack::state() const {
+  return static_cast<TrackState>(track_->state());
+}
+
+MediaStream::MediaStream(
+    rtc::scoped_refptr<webrtc::MediaStreamInterface> stream)
+    : media_stream_(std::move(stream)) {}
+
+rust::String MediaStream::id() const {
+    return media_stream_->id();
+}
+
+}  // namespace livekit

crates/livekit-webrtc/libwebrtc-sys/src/media_stream.rs

@@ -0,0 +1,36 @@
+#[cxx::bridge(namespace = "livekit")]
+pub mod ffi {
+
+    #[derive(Debug)]
+    #[repr(i32)]
+    pub enum TrackState {
+        Live,
+        Ended,
+    }
+
+    unsafe extern "C++" {
+        include!("livekit/media_stream.h");
+
+        type MediaStreamTrack;
+        type MediaStream;
+
+        fn kind(self: &MediaStreamTrack) -> String;
+        fn id(self: &MediaStreamTrack) -> String;
+        fn enabled(self: &MediaStreamTrack) -> bool;
+        fn set_enabled(self: Pin<&mut MediaStreamTrack>, enable: bool) -> bool;
+        fn state(self: &MediaStreamTrack) -> TrackState;
+
+        fn id(self: &MediaStream) -> String;
+
+        fn _unique_media_stream_track() -> UniquePtr<MediaStreamTrack>; // Ignore
+        fn _unique_media_stream() -> UniquePtr<MediaStream>; // Ignore
+    }
+}
+
+unsafe impl Sync for ffi::MediaStreamTrack {}
+
+unsafe impl Send for ffi::MediaStreamTrack {}
+
+unsafe impl Sync for ffi::MediaStream {}
+
+unsafe impl Send for ffi::MediaStream {}

crates/livekit-webrtc/libwebrtc-sys/src/media_stream_interface.cpp

@@ -1,12 +0,0 @@
-//
-// Created by Théo Monnom on 31/08/2022.
-//
-
-#include "livekit/media_stream_interface.h"
-
-namespace livekit {
-
-MediaStreamInterface::MediaStreamInterface(
-    rtc::scoped_refptr<webrtc::MediaStreamInterface> stream)
-    : media_stream_(std::move(stream)) {}
-}  // namespace livekit

crates/livekit-webrtc/libwebrtc-sys/src/media_stream_interface.rs

@@ -1,10 +0,0 @@
-#[cxx::bridge(namespace = "livekit")]
-pub mod ffi {
-    unsafe extern "C++" {
-        include!("livekit/media_stream_interface.h");
-
-        type MediaStreamInterface;
-
-        fn _unique_media_stream() -> UniquePtr<MediaStreamInterface>; // Ignore
-    }
-}

crates/livekit-webrtc/libwebrtc-sys/src/peer_connection.cpp

@@ -3,6 +3,7 @@
 //
 
 #include "livekit/peer_connection.h"
+#include "livekit/media_stream.h"
 
 #include "libwebrtc-sys/src/peer_connection.rs.h"
 #include "livekit/rtc_error.h"
@@ -142,12 +143,12 @@ void NativePeerConnectionObserver::OnSignalingChange(
 
 void NativePeerConnectionObserver::OnAddStream(
     rtc::scoped_refptr<webrtc::MediaStreamInterface> stream) {
-  observer_->on_add_stream(std::make_unique<MediaStreamInterface>(stream));
+  observer_->on_add_stream(std::make_unique<MediaStream>(stream));
 }
 
 void NativePeerConnectionObserver::OnRemoveStream(
     rtc::scoped_refptr<webrtc::MediaStreamInterface> stream) {
-  observer_->on_remove_stream(std::make_unique<MediaStreamInterface>(stream));
+  observer_->on_remove_stream(std::make_unique<MediaStream>(stream));
 }
 
 void NativePeerConnectionObserver::OnDataChannel(
@@ -241,7 +242,7 @@ void NativePeerConnectionObserver::OnAddTrack(
   rust::Vec<MediaStreamPtr> vec;
 
   for (const auto& item : streams) {
-    vec.push_back(MediaStreamPtr{std::make_unique<MediaStreamInterface>(item)});
+    vec.push_back(MediaStreamPtr{std::make_unique<MediaStream>(item)});
   }
 
   observer_->on_add_track(std::make_unique<RtpReceiver>(receiver),

crates/livekit-webrtc/libwebrtc-sys/src/peer_connection.rs

@@ -6,7 +6,7 @@ use cxx::UniquePtr;
 use crate::candidate::ffi::Candidate;
 use crate::data_channel::ffi::DataChannel;
 use crate::jsep::ffi::IceCandidate;
-use crate::media_stream_interface::ffi::MediaStreamInterface;
+use crate::media_stream::ffi::MediaStream;
 use crate::rtc_error::ffi::RTCError;
 use crate::rtp_receiver::ffi::RtpReceiver;
 use crate::rtp_transceiver::ffi::RtpTransceiver;
@@ -83,7 +83,7 @@ pub mod ffi {
     // Wrapper to opaque C++ objects
     // https://github.com/dtolnay/cxx/issues/741
     struct MediaStreamPtr {
-        pub ptr: UniquePtr<MediaStreamInterface>,
+        pub ptr: UniquePtr<MediaStream>,
     }
 
     struct CandidatePtr {
@@ -96,7 +96,7 @@ pub mod ffi {
         include!("livekit/data_channel.h");
         include!("livekit/rtp_receiver.h");
         include!("livekit/rtp_transceiver.h");
-        include!("livekit/media_stream_interface.h");
+        include!("livekit/media_stream.h");
         include!("livekit/candidate.h");
         include!("libwebrtc-sys/src/rtc_error.rs.h");
 
@@ -106,7 +106,7 @@ pub mod ffi {
         type DataChannel = crate::data_channel::ffi::DataChannel;
         type RtpReceiver = crate::rtp_receiver::ffi::RtpReceiver;
         type RtpTransceiver = crate::rtp_transceiver::ffi::RtpTransceiver;
-        type MediaStreamInterface = crate::media_stream_interface::ffi::MediaStreamInterface;
+        type MediaStream = crate::media_stream::ffi::MediaStream;
         type NativeCreateSdpObserverHandle = crate::jsep::ffi::NativeCreateSdpObserverHandle;
         type NativeSetLocalSdpObserverHandle = crate::jsep::ffi::NativeSetLocalSdpObserverHandle;
         type NativeSetRemoteSdpObserverHandle = crate::jsep::ffi::NativeSetRemoteSdpObserverHandle;
@@ -194,14 +194,8 @@ pub mod ffi {
         type PeerConnectionObserverWrapper;
 
         fn on_signaling_change(self: &PeerConnectionObserverWrapper, new_state: SignalingState);
-        fn on_add_stream(
-            self: &PeerConnectionObserverWrapper,
-            stream: UniquePtr<MediaStreamInterface>,
-        );
-        fn on_remove_stream(
-            self: &PeerConnectionObserverWrapper,
-            stream: UniquePtr<MediaStreamInterface>,
-        );
+        fn on_add_stream(self: &PeerConnectionObserverWrapper, stream: UniquePtr<MediaStream>);
+        fn on_remove_stream(self: &PeerConnectionObserverWrapper, stream: UniquePtr<MediaStream>);
         fn on_data_channel(
             self: &PeerConnectionObserverWrapper,
             data_channel: UniquePtr<DataChannel>,
@@ -317,8 +311,8 @@ impl AddIceCandidateObserverWrapper {
 
 pub trait PeerConnectionObserver: Send + Sync {
     fn on_signaling_change(&self, new_state: ffi::SignalingState);
-    fn on_add_stream(&self, stream: UniquePtr<MediaStreamInterface>);
-    fn on_remove_stream(&self, stream: UniquePtr<MediaStreamInterface>);
+    fn on_add_stream(&self, stream: UniquePtr<MediaStream>);
+    fn on_remove_stream(&self, stream: UniquePtr<MediaStream>);
     fn on_data_channel(&self, data_channel: UniquePtr<DataChannel>);
     fn on_renegotiation_needed(&self);
     fn on_negotiation_needed_event(&self, event: u32);
@@ -338,11 +332,7 @@ pub trait PeerConnectionObserver: Send + Sync {
     fn on_ice_candidates_removed(&self, removed: Vec<UniquePtr<Candidate>>);
     fn on_ice_connection_receiving_change(&self, receiving: bool);
     fn on_ice_selected_candidate_pair_changed(&self, event: ffi::CandidatePairChangeEvent);
-    fn on_add_track(
-        &self,
-        receiver: UniquePtr<RtpReceiver>,
-        streams: Vec<UniquePtr<MediaStreamInterface>>,
-    );
+    fn on_add_track(&self, receiver: UniquePtr<RtpReceiver>, streams: Vec<UniquePtr<MediaStream>>);
     fn on_track(&self, transceiver: UniquePtr<RtpTransceiver>);
     fn on_remove_track(&self, receiver: UniquePtr<RtpReceiver>);
     fn on_interesting_usage(&self, usage_pattern: i32);
@@ -366,13 +356,13 @@ impl PeerConnectionObserverWrapper {
         }
     }
 
-    fn on_add_stream(&self, stream: UniquePtr<MediaStreamInterface>) {
+    fn on_add_stream(&self, stream: UniquePtr<MediaStream>) {
         unsafe {
             (*self.observer).on_add_stream(stream);
         }
     }
 
-    fn on_remove_stream(&self, stream: UniquePtr<MediaStreamInterface>) {
+    fn on_remove_stream(&self, stream: UniquePtr<MediaStream>) {
         unsafe {
             (*self.observer).on_remove_stream(stream);
         }

crates/livekit-webrtc/libwebrtc-sys/src/peer_connection_factory.rs

@@ -35,12 +35,14 @@ pub mod ffi {
 
         type PeerConnection = crate::peer_connection::ffi::PeerConnection;
         type NativePeerConnectionObserver =
-        crate::peer_connection::ffi::NativePeerConnectionObserver;
+            crate::peer_connection::ffi::NativePeerConnectionObserver;
         type PeerConnectionFactory;
         type NativeRTCConfiguration;
         type RTCRuntime = crate::webrtc::ffi::RTCRuntime;
 
-        fn create_peer_connection_factory(runtime: SharedPtr<RTCRuntime>) -> UniquePtr<PeerConnectionFactory>;
+        fn create_peer_connection_factory(
+            runtime: SharedPtr<RTCRuntime>,
+        ) -> UniquePtr<PeerConnectionFactory>;
         fn create_rtc_configuration(conf: RTCConfiguration) -> UniquePtr<NativeRTCConfiguration>;
 
         /// SAFETY

crates/livekit-webrtc/libwebrtc-sys/src/rtp_receiver.cpp

@@ -8,4 +8,9 @@ namespace livekit {
 RtpReceiver::RtpReceiver(
     rtc::scoped_refptr<webrtc::RtpReceiverInterface> receiver)
     : receiver_(std::move(receiver)) {}
+
+std::unique_ptr<MediaStreamTrack> RtpReceiver::track() const {
+  return std::make_unique<MediaStreamTrack>(receiver_->track());
+}
+
 }  // namespace livekit

crates/livekit-webrtc/libwebrtc-sys/src/rtp_receiver.rs

@@ -2,9 +2,17 @@
 pub mod ffi {
     unsafe extern "C++" {
         include!("livekit/rtp_receiver.h");
+        include!("livekit/media_stream.h");
 
+        type MediaStreamTrack = crate::media_stream::ffi::MediaStreamTrack;
         type RtpReceiver;
 
+        fn track(self: &RtpReceiver) -> UniquePtr<MediaStreamTrack>;
+
         fn _unique_rtp_receiver() -> UniquePtr<RtpReceiver>; // Ignore
     }
 }
+
+unsafe impl Sync for ffi::RtpReceiver {}
+
+unsafe impl Send for ffi::RtpReceiver {}

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())
+    }
+}