rtc_config

crates/livekit-webrtc/src/data_channel.rs

@@ -128,14 +128,14 @@ impl Default for InternalDataChannelObserver {
 #[derive(Debug)]
 pub struct DataChannelInit {
     #[deprecated]
-    reliable: bool,
-    ordered: bool,
-    max_retransmit_time: Option<i32>,
-    max_retransmits: Option<i32>,
-    protocol: String,
-    negotiated: bool,
-    id: i32,
-    priority: Option<Priority>,
+    pub reliable: bool,
+    pub ordered: bool,
+    pub max_retransmit_time: Option<i32>,
+    pub max_retransmits: Option<i32>,
+    pub protocol: String,
+    pub negotiated: bool,
+    pub id: i32,
+    pub priority: Option<Priority>,
 }
 
 impl Default for DataChannelInit {

crates/livekit-webrtc/src/jsep.rs

@@ -2,6 +2,7 @@ use cxx::UniquePtr;
 
 use libwebrtc_sys::jsep as sys_jsep;
 
+// TODO Maybe we can replace that by a serialized IceCandidateInit
 #[derive(Debug)]
 pub struct IceCandidate {
     cxx_handle: UniquePtr<sys_jsep::ffi::IceCandidate>,
@@ -17,6 +18,12 @@ impl IceCandidate {
     }
 }
 
+impl ToString for IceCandidate {
+    fn to_string(&self) -> String {
+        self.cxx_handle.stringify()
+    }
+}
+
 #[derive(Debug)]
 pub struct SessionDescription {
     cxx_handle: UniquePtr<sys_jsep::ffi::SessionDescription>,
@@ -32,6 +39,12 @@ impl SessionDescription {
     }
 }
 
+impl ToString for SessionDescription {
+    fn to_string(&self) -> String {
+        self.cxx_handle.stringify()
+    }
+}
+
 impl Clone for SessionDescription {
     fn clone(&self) -> Self {
         SessionDescription::new(self.cxx_handle.clone())

crates/livekit-webrtc/src/peer_connection.rs

@@ -51,7 +51,7 @@ impl PeerConnection {
         }
     }
 
-    pub async fn create_offer(&mut self) -> Result<SessionDescription, SdpError> {
+    pub async fn create_offer(&mut self, options: RTCOfferAnswerOptions) -> Result<SessionDescription, SdpError> {
         let (tx, mut rx) = mpsc::channel(1);
 
         let wrapper =
@@ -62,7 +62,7 @@ impl PeerConnection {
         unsafe {
             self.cxx_handle
                 .pin_mut()
-                .create_offer(native_wrapper.pin_mut(), RTCOfferAnswerOptions::default());
+                .create_offer(native_wrapper.pin_mut(), options);
         }
 
         match rx.recv().await {
@@ -71,7 +71,7 @@ impl PeerConnection {
         }
     }
 
-    pub async fn create_answer(&mut self) -> Result<SessionDescription, SdpError> {
+    pub async fn create_answer(&mut self, options: RTCOfferAnswerOptions) -> Result<SessionDescription, SdpError> {
         let (tx, mut rx) = mpsc::channel(1);
 
         let wrapper =
@@ -82,7 +82,7 @@ impl PeerConnection {
         unsafe {
             self.cxx_handle
                 .pin_mut()
-                .create_answer(native_wrapper.pin_mut(), RTCOfferAnswerOptions::default());
+                .create_answer(native_wrapper.pin_mut(), options);
         }
 
         match rx.recv().await {
@@ -154,6 +154,7 @@ impl PeerConnection {
         }
     }
 
+    // TODO(theomonnom) Use IceCandidateInit instead of IceCandidate
     pub async fn add_ice_candidate(&mut self, candidate: IceCandidate) -> Result<(), SdpError> {
         let (tx, mut rx) = mpsc::channel(1);
         let observer = sys_pc::AddIceCandidateObserverWrapper::new(Box::new(move |error| {
@@ -172,6 +173,32 @@ impl PeerConnection {
         }
     }
 
+    pub fn local_description(&self) -> Option<SessionDescription> {
+        let local_description = self.cxx_handle.local_description();
+        if local_description.is_null() {
+            None
+        } else {
+            Some(SessionDescription::new(local_description))
+        }
+    }
+
+    pub fn remote_description(&self) -> Option<SessionDescription> {
+        let remote_description = self.cxx_handle.remote_description();
+        if remote_description.is_null() {
+            None
+        } else {
+            Some(SessionDescription::new(remote_description))
+        }
+    }
+
+    pub fn signaling_state(&self) -> SignalingState {
+        self.cxx_handle.signaling_state()
+    }
+
+    pub fn ice_gathering_state(&self) -> IceGatheringState {
+        self.cxx_handle.ice_gathering_state()
+    }
+
     pub fn close(&mut self) {
         self.cxx_handle.pin_mut().close();
     }
@@ -344,16 +371,16 @@ pub type OnRenegotiationNeededHandler = Box<dyn FnMut() + Send + Sync>;
 pub type OnNegotiationNeededEventHandler = Box<dyn FnMut(u32) + Send + Sync>;
 pub type OnIceConnectionChangeHandler = Box<dyn FnMut(IceConnectionState) + Send + Sync>;
 pub type OnStandardizedIceConnectionChangeHandler =
-Box<dyn FnMut(IceConnectionState) + Send + Sync>;
+    Box<dyn FnMut(IceConnectionState) + Send + Sync>;
 pub type OnConnectionChangeHandler = Box<dyn FnMut(PeerConnectionState) + Send + Sync>;
 pub type OnIceGatheringChangeHandler = Box<dyn FnMut(IceGatheringState) + Send + Sync>;
 pub type OnIceCandidateHandler = Box<dyn FnMut(IceCandidate) + Send + Sync>;
 pub type OnIceCandidateErrorHandler =
-Box<dyn FnMut(String, i32, String, i32, String) + Send + Sync>;
+    Box<dyn FnMut(String, i32, String, i32, String) + Send + Sync>;
 pub type OnIceCandidatesRemovedHandler = Box<dyn FnMut(Vec<IceCandidate>) + Send + Sync>;
 pub type OnIceConnectionReceivingChangeHandler = Box<dyn FnMut(bool) + Send + Sync>;
 pub type OnIceSelectedCandidatePairChangedHandler =
-Box<dyn FnMut(libwebrtc_sys::peer_connection::ffi::CandidatePairChangeEvent) + Send + Sync>;
+    Box<dyn FnMut(libwebrtc_sys::peer_connection::ffi::CandidatePairChangeEvent) + Send + Sync>;
 pub type OnAddTrackHandler = Box<dyn FnMut(RtpReceiver, Vec<MediaStream>) + Send + Sync>;
 pub type OnTrackHandler = Box<dyn FnMut(RtpTransceiver) + Send + Sync>;
 pub type OnRemoveTrackHandler = Box<dyn FnMut(RtpReceiver) + Send + Sync>;
@@ -368,16 +395,16 @@ pub(crate) struct InternalObserver {
     on_negotiation_needed_event_handler: Arc<Mutex<Option<OnNegotiationNeededEventHandler>>>,
     on_ice_connection_change_handler: Arc<Mutex<Option<OnIceConnectionChangeHandler>>>,
     on_standardized_ice_connection_change_handler:
-    Arc<Mutex<Option<OnStandardizedIceConnectionChangeHandler>>>,
+        Arc<Mutex<Option<OnStandardizedIceConnectionChangeHandler>>>,
     on_connection_change_handler: Arc<Mutex<Option<OnConnectionChangeHandler>>>,
     on_ice_gathering_change_handler: Arc<Mutex<Option<OnIceGatheringChangeHandler>>>,
     on_ice_candidate_handler: Arc<Mutex<Option<OnIceCandidateHandler>>>,
     on_ice_candidate_error_handler: Arc<Mutex<Option<OnIceCandidateErrorHandler>>>,
     on_ice_candidates_removed_handler: Arc<Mutex<Option<OnIceCandidatesRemovedHandler>>>,
     on_ice_connection_receiving_change_handler:
-    Arc<Mutex<Option<OnIceConnectionReceivingChangeHandler>>>,
+        Arc<Mutex<Option<OnIceConnectionReceivingChangeHandler>>>,
     on_ice_selected_candidate_pair_changed_handler:
-    Arc<Mutex<Option<OnIceSelectedCandidatePairChangedHandler>>>,
+        Arc<Mutex<Option<OnIceSelectedCandidatePairChangedHandler>>>,
     on_add_track_handler: Arc<Mutex<Option<OnAddTrackHandler>>>,
     on_track_handler: Arc<Mutex<Option<OnTrackHandler>>>,
     on_remove_track_handler: Arc<Mutex<Option<OnRemoveTrackHandler>>>,

crates/livekit-webrtc/src/peer_connection_factory.rs

@@ -2,7 +2,9 @@ use cxx::UniquePtr;
 
 use libwebrtc_sys::peer_connection as sys_pc;
 use libwebrtc_sys::peer_connection_factory as sys_factory;
-pub use sys_factory::ffi::{ICEServer, RTCConfiguration};
+pub use sys_factory::ffi::{
+    ContinualGatheringPolicy, ICEServer, IceTransportsType, RTCConfiguration,
+};
 
 use crate::peer_connection::{InternalObserver, PeerConnection};
 use crate::rtc_error::RTCError;

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;
-