rtc_config

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

@@ -3,7 +3,7 @@ use std::slice;
 #[cxx::bridge(namespace = "livekit")]
 pub mod ffi {
     #[derive(Debug)]
-    #[repr(u32)]
+    #[repr(i32)]
     pub enum Priority {
         VeryLow,
         Low,
@@ -36,7 +36,7 @@ pub mod ffi {
     }
 
     #[derive(Debug)]
-    #[repr(u32)]
+    #[repr(i32)]
     pub enum DataState {
         Connecting,
         Open,

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

@@ -16,6 +16,12 @@ IceCandidate::IceCandidate(
     std::unique_ptr<webrtc::IceCandidateInterface> ice_candidate)
     : ice_candidate_(std::move(ice_candidate)) {}
 
+rust::String IceCandidate::stringify() const {
+  std::string str;
+  ice_candidate_->ToString(&str);
+  return rust::String{str};
+}
+
 std::unique_ptr<webrtc::IceCandidateInterface> IceCandidate::release() {
   return std::move(ice_candidate_);
 }

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

@@ -32,6 +32,8 @@ pub mod ffi {
         type NativeSetLocalSdpObserverHandle;
         type NativeSetRemoteSdpObserverHandle;
 
+        fn stringify(self: &IceCandidate) -> String;
+
         fn stringify(self: &SessionDescription) -> String;
         fn clone(self: &SessionDescription) -> UniquePtr<SessionDescription>;
 
@@ -46,7 +48,7 @@ pub mod ffi {
         ) -> UniquePtr<NativeSetRemoteSdpObserverHandle>;
 
         fn _unique_ice_candidate() -> UniquePtr<IceCandidate>; // Ignore
-    fn _unique_session_description() -> UniquePtr<SessionDescription>; // Ignore
+        fn _unique_session_description() -> UniquePtr<SessionDescription>; // Ignore
     }
 }
 
@@ -60,12 +62,14 @@ unsafe impl Send for ffi::SessionDescription {}
 
 impl Debug for ffi::IceCandidate {
     fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
-        write!(f, "TODO") // TODO(theomonnom)
+        write!(f, "{}", self.stringify())
     }
 }
 
 unsafe impl Send for ffi::IceCandidate {}
 
+unsafe impl Sync for ffi::IceCandidate {}
+
 // CreateSdpObserver
 
 pub trait CreateSdpObserver: Send {

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

@@ -76,10 +76,35 @@ void PeerConnection::add_ice_candidate(
       [&](const webrtc::RTCError& err) { observer.OnComplete(to_error(err)); });
 }
 
+std::unique_ptr<SessionDescription> PeerConnection::local_description() const {
+  auto local_description = peer_connection_->local_description();
+  if (local_description)
+    return std::make_unique<SessionDescription>(local_description->Clone());
+
+  return std::unique_ptr<SessionDescription>();
+}
+
+std::unique_ptr<SessionDescription> PeerConnection::remote_description() const {
+  auto remote_description = peer_connection_->remote_description();
+  if (remote_description)
+    return std::make_unique<SessionDescription>(remote_description->Clone());
+
+  return std::unique_ptr<SessionDescription>();
+}
+
+SignalingState PeerConnection::signaling_state() const {
+  return static_cast<SignalingState>(peer_connection_->signaling_state());
+}
+
+IceGatheringState PeerConnection::ice_gathering_state() const {
+  return static_cast<IceGatheringState>(peer_connection_->ice_gathering_state());
+}
+
 void PeerConnection::close() {
   peer_connection_->Close();
 }
 
+
 // AddIceCandidateObserver
 
 NativeAddIceCandidateObserver::NativeAddIceCandidateObserver(

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

@@ -23,7 +23,7 @@ pub mod ffi {
     }
 
     #[derive(Debug)]
-    #[repr(u32)]
+    #[repr(i32)]
     pub enum PeerConnectionState {
         New,
         Connecting,
@@ -34,7 +34,7 @@ pub mod ffi {
     }
 
     #[derive(Debug)]
-    #[repr(u32)]
+    #[repr(i32)]
     pub enum SignalingState {
         Stable,
         HaveLocalOffer,
@@ -45,7 +45,7 @@ pub mod ffi {
     }
 
     #[derive(Debug)]
-    #[repr(u32)]
+    #[repr(i32)]
     pub enum IceConnectionState {
         IceConnectionNew,
         IceConnectionChecking,
@@ -58,7 +58,7 @@ pub mod ffi {
     }
 
     #[derive(Debug)]
-    #[repr(u32)]
+    #[repr(i32)]
     pub enum IceGatheringState {
         IceGatheringNew,
         IceGatheringGathering,
@@ -158,6 +158,14 @@ pub mod ffi {
             observer: Pin<&mut NativeAddIceCandidateObserver>,
         );
 
+        fn local_description(self: &PeerConnection) -> UniquePtr<SessionDescription>;
+
+        fn remote_description(self: &PeerConnection) -> UniquePtr<SessionDescription>;
+
+        fn signaling_state(self: &PeerConnection) -> SignalingState;
+
+        fn ice_gathering_state(self: &PeerConnection) -> IceGatheringState;
+
         fn close(self: Pin<&mut PeerConnection>);
 
         fn create_native_peer_connection_observer(

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

@@ -86,8 +86,13 @@ std::unique_ptr<NativeRTCConfiguration> create_rtc_configuration(
     for (auto& url : item.urls) {
       ice_server.urls.emplace_back(url.c_str());
     }
-
     rtc->servers.push_back(ice_server);
+    rtc->continual_gathering_policy =
+        static_cast<webrtc::PeerConnectionInterface::ContinualGatheringPolicy>(
+            conf.continual_gathering_policy);
+
+    rtc->type = static_cast<webrtc::PeerConnectionInterface::IceTransportsType>(
+        conf.ice_transport_type);
   }
 
   return rtc;

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

@@ -12,9 +12,27 @@ pub mod ffi {
         pub password: String,
     }
 
+    #[derive(Debug)]
+    #[repr(i32)]
+    pub enum ContinualGatheringPolicy {
+        GatherOnce,
+        GatherContinually,
+    }
+
+    #[derive(Debug)]
+    #[repr(i32)]
+    pub enum IceTransportsType {
+        None,
+        Relay,
+        NoHost,
+        All,
+    }
+
     #[derive(Debug, Clone)]
     pub struct RTCConfiguration {
         pub ice_servers: Vec<ICEServer>,
+        pub continual_gathering_policy: ContinualGatheringPolicy,
+        pub ice_transport_type: IceTransportsType,
     }
 
     unsafe extern "C++" {
@@ -22,7 +40,7 @@ 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;
 
@@ -38,3 +56,6 @@ pub mod ffi {
         ) -> Result<UniquePtr<PeerConnection>>;
     }
 }
+
+unsafe impl Send for ffi::PeerConnectionFactory {}
+unsafe impl Sync for ffi::PeerConnectionFactory {}

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

@@ -7,7 +7,7 @@ use std::fmt::{Display, Formatter};
 #[cxx::bridge(namespace = "livekit")]
 pub mod ffi {
     #[derive(Debug)]
-    #[repr(u32)]
+    #[repr(i32)]
     pub enum RTCErrorType {
         None,
         UnsupportedOperation,
@@ -24,7 +24,7 @@ pub mod ffi {
     }
 
     #[derive(Debug)]
-    #[repr(u32)]
+    #[repr(i32)]
     pub enum RTCErrorDetailType {
         None,
         DataChannelFailure,

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

@@ -10,3 +10,6 @@ pub mod ffi {
         fn create_rtc_runtime() -> UniquePtr<RTCRuntime>;
     }
 }
+
+unsafe impl Send for ffi::RTCRuntime {}
+unsafe impl Sync for ffi::RTCRuntime {}