test #1

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

@@ -6,7 +6,7 @@ pub mod ffi {
         include!("livekit/candidate.h");
 
         type Candidate; // cricket::Candidate
- 
+
         fn _unique_candidate() -> UniquePtr<Candidate>; // Ignore
     }
 }

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

@@ -19,6 +19,12 @@ namespace livekit {
 
     }
 
+    rust::String SessionDescription::stringify() const {
+        std::string str;
+        session_description_->ToString(&str);
+        return rust::String{str};
+    }
+
     std::unique_ptr<SessionDescription> SessionDescription::clone() const {
         return std::make_unique<SessionDescription>(session_description_->Clone());
     }

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

@@ -1,5 +1,5 @@
+use std::fmt::{Debug, Formatter};
 use cxx::UniquePtr;
-use cxx::{type_id, ExternType};
 
 use crate::rtc_error::ffi::RTCError;
 
@@ -8,7 +8,10 @@ pub mod ffi {
 
     extern "Rust" {
         type CreateSdpObserverWrapper;
-        fn on_success(self: &CreateSdpObserverWrapper, session_description: UniquePtr<SessionDescription>);
+        fn on_success(
+            self: &CreateSdpObserverWrapper,
+            session_description: UniquePtr<SessionDescription>,
+        );
         fn on_failure(self: &CreateSdpObserverWrapper, error: RTCError);
 
         type SetLocalSdpObserverWrapper;
@@ -29,18 +32,35 @@ pub mod ffi {
         type NativeSetLocalSdpObserverHandle;
         type NativeSetRemoteSdpObserverHandle;
 
-        fn create_native_create_sdp_observer(observer: Box<CreateSdpObserverWrapper>) -> UniquePtr<NativeCreateSdpObserverHandle>;
-        fn create_native_set_local_sdp_observer(observer: Box<SetLocalSdpObserverWrapper>) -> UniquePtr<NativeSetLocalSdpObserverHandle>;
-        fn create_native_set_remote_sdp_observer(observer: Box<SetRemoteSdpObserverWrapper>) -> UniquePtr<NativeSetRemoteSdpObserverHandle>;
+        fn stringify(self: &SessionDescription) -> String;
+
+        fn create_native_create_sdp_observer(
+            observer: Box<CreateSdpObserverWrapper>,
+        ) -> UniquePtr<NativeCreateSdpObserverHandle>;
+        fn create_native_set_local_sdp_observer(
+            observer: Box<SetLocalSdpObserverWrapper>,
+        ) -> UniquePtr<NativeSetLocalSdpObserverHandle>;
+        fn create_native_set_remote_sdp_observer(
+            observer: Box<SetRemoteSdpObserverWrapper>,
+        ) -> UniquePtr<NativeSetRemoteSdpObserverHandle>;
 
         fn _unique_ice_candidate() -> UniquePtr<IceCandidate>; // Ignore
+        fn _shared_session_description() -> SharedPtr<SessionDescription>; // Ignore
         fn _unique_session_description() -> UniquePtr<SessionDescription>; // Ignore
     }
 }
 
+impl Debug for ffi::SessionDescription {
+    fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
+        write!(f, "{}", self.stringify())
+    }
+}
+
+unsafe impl Send for ffi::SessionDescription {}
+
 // CreateSdpObserver
 
-pub trait CreateSdpObserver: Send + Sync {
+pub trait CreateSdpObserver: Send {
     fn on_success(&self, session_description: UniquePtr<ffi::SessionDescription>);
     fn on_failure(&self, error: RTCError);
 }
@@ -51,9 +71,7 @@ pub struct CreateSdpObserverWrapper {
 
 impl CreateSdpObserverWrapper {
     pub fn new(observer: Box<dyn CreateSdpObserver>) -> Self {
-        Self {
-            observer
-        }
+        Self { observer }
     }
 
     fn on_success(&self, session_description: UniquePtr<ffi::SessionDescription>) {
@@ -67,7 +85,7 @@ impl CreateSdpObserverWrapper {
 
 // SetLocalSdpObserver
 
-pub trait SetLocalSdpObserver: Send + Sync {
+pub trait SetLocalSdpObserver: Send {
     fn on_set_local_description_complete(&self, error: RTCError);
 }
 
@@ -77,9 +95,7 @@ pub struct SetLocalSdpObserverWrapper {
 
 impl SetLocalSdpObserverWrapper {
     pub fn new(observer: Box<dyn SetLocalSdpObserver>) -> Self {
-        Self {
-            observer
-        }
+        Self { observer }
     }
 
     fn on_set_local_description_complete(&self, error: RTCError) {
@@ -89,7 +105,7 @@ impl SetLocalSdpObserverWrapper {
 
 // SetRemoteSdpObserver
 
-pub trait SetRemoteSdpObserver: Send + Sync {
+pub trait SetRemoteSdpObserver: Send {
     fn on_set_remote_description_complete(&self, error: RTCError);
 }
 
@@ -99,9 +115,7 @@ pub struct SetRemoteSdpObserverWrapper {
 
 impl SetRemoteSdpObserverWrapper {
     pub fn new(observer: Box<dyn SetRemoteSdpObserver>) -> Self {
-        Self {
-            observer
-        }
+        Self { observer }
     }
 
     fn on_set_remote_description_complete(&self, error: RTCError) {

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

@@ -1,10 +1,9 @@
+pub mod candidate;
+pub mod data_channel;
+pub mod jsep;
 pub mod media_stream_interface;
 pub mod peer_connection;
 pub mod peer_connection_factory;
-pub mod data_channel;
-pub mod jsep;
-pub mod candidate;
+pub mod rtc_error;
 pub mod rtp_receiver;
 pub mod rtp_transceiver;
-pub mod rtc_error;
-

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

@@ -9,5 +9,4 @@ pub mod ffi {
 
         fn _unique_media_stream() -> UniquePtr<MediaStreamInterface>; // Ignore
     }
-
 }

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

@@ -1,10 +1,12 @@
-use cxx::UniquePtr;
+use std::cell::RefCell;
+use std::rc::Rc;
 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::rtp_receiver::ffi::RtpReceiver;
 use crate::rtp_transceiver::ffi::RtpTransceiver;
+use cxx::UniquePtr;
 
 #[cxx::bridge(namespace = "livekit")]
 pub mod ffi {
@@ -61,7 +63,7 @@ pub mod ffi {
     pub enum IceGatheringState {
         IceGatheringNew,
         IceGatheringGathering,
-        IceGatheringComplete
+        IceGatheringComplete,
     }
 
     #[derive(Debug)]
@@ -79,11 +81,11 @@ pub mod ffi {
     // Wrapper to opaque C++ objects
     // https://github.com/dtolnay/cxx/issues/741
     struct MediaStreamPtr {
-        pub ptr: UniquePtr<MediaStreamInterface>
+        pub ptr: UniquePtr<MediaStreamInterface>,
     }
 
-    struct CandidatePtr  {
-        pub ptr: UniquePtr<Candidate>
+    struct CandidatePtr {
+        pub ptr: UniquePtr<Candidate>,
     }
 
     unsafe extern "C++" {
@@ -109,13 +111,31 @@ pub mod ffi {
         type NativePeerConnectionObserver;
         type PeerConnection;
 
-        fn create_offer(self: Pin<&mut PeerConnection>, observer: UniquePtr<NativeCreateSdpObserverHandle>, options: RTCOfferAnswerOptions);
-        fn create_answer(self: Pin<&mut PeerConnection>, observer: UniquePtr<NativeCreateSdpObserverHandle>, options: RTCOfferAnswerOptions);
-        fn set_local_description(self: Pin<&mut PeerConnection>, desc: UniquePtr<SessionDescription>, observer: UniquePtr<NativeSetLocalSdpObserverHandle>);
-        fn set_remote_description(self: Pin<&mut PeerConnection>, desc: UniquePtr<SessionDescription>, observer: UniquePtr<NativeSetRemoteSdpObserverHandle>);
+        fn create_offer(
+            self: Pin<&mut PeerConnection>,
+            observer: UniquePtr<NativeCreateSdpObserverHandle>,
+            options: RTCOfferAnswerOptions,
+        );
+        fn create_answer(
+            self: Pin<&mut PeerConnection>,
+            observer: UniquePtr<NativeCreateSdpObserverHandle>,
+            options: RTCOfferAnswerOptions,
+        );
+        fn set_local_description(
+            self: Pin<&mut PeerConnection>,
+            desc: UniquePtr<SessionDescription>,
+            observer: UniquePtr<NativeSetLocalSdpObserverHandle>,
+        );
+        fn set_remote_description(
+            self: Pin<&mut PeerConnection>,
+            desc: UniquePtr<SessionDescription>,
+            observer: UniquePtr<NativeSetRemoteSdpObserverHandle>,
+        );
         fn close(self: Pin<&mut PeerConnection>);
 
-        fn create_native_peer_connection_observer(observer: Box<PeerConnectionObserverWrapper>) -> UniquePtr<NativePeerConnectionObserver>;
+        fn create_native_peer_connection_observer(
+            observer: Box<PeerConnectionObserverWrapper>,
+        ) -> UniquePtr<NativePeerConnectionObserver>;
 
         fn _unique_peer_connection() -> UniquePtr<PeerConnection>; // Ignore
     }
@@ -124,23 +144,73 @@ pub mod ffi {
         type PeerConnectionObserverWrapper;
 
         fn on_signaling_change(self: &mut PeerConnectionObserverWrapper, new_state: SignalingState);
-        fn on_add_stream(self: &mut PeerConnectionObserverWrapper, stream: UniquePtr<MediaStreamInterface>);
-        fn on_remove_stream(self: &mut PeerConnectionObserverWrapper, stream: UniquePtr<MediaStreamInterface>);
-        fn on_data_channel(self: &mut PeerConnectionObserverWrapper, data_channel: UniquePtr<DataChannel>);
+        fn on_add_stream(
+            self: &mut PeerConnectionObserverWrapper,
+            stream: UniquePtr<MediaStreamInterface>,
+        );
+        fn on_remove_stream(
+            self: &mut PeerConnectionObserverWrapper,
+            stream: UniquePtr<MediaStreamInterface>,
+        );
+        fn on_data_channel(
+            self: &mut PeerConnectionObserverWrapper,
+            data_channel: UniquePtr<DataChannel>,
+        );
         fn on_renegotiation_needed(self: &mut PeerConnectionObserverWrapper);
         fn on_negotiation_needed_event(self: &mut PeerConnectionObserverWrapper, event: u32);
-        fn on_ice_connection_change(self: &mut PeerConnectionObserverWrapper, new_state: IceConnectionState);
-        fn on_standardized_ice_connection_change(self: &mut PeerConnectionObserverWrapper, new_state: IceConnectionState);
-        fn on_connection_change(self: &mut PeerConnectionObserverWrapper, new_state: PeerConnectionState);
-        fn on_ice_gathering_change(self: &mut PeerConnectionObserverWrapper, new_state: IceGatheringState);
-        fn on_ice_candidate(self: &mut PeerConnectionObserverWrapper, candidate: UniquePtr<IceCandidate>);
-        fn on_ice_candidate_error(self: &mut PeerConnectionObserverWrapper, address: String, port: i32, url: String, error_code: i32, error_text: String);
-        fn on_ice_candidates_removed(self: &mut PeerConnectionObserverWrapper, removed: Vec<CandidatePtr>);
-        fn on_ice_connection_receiving_change(self: &mut PeerConnectionObserverWrapper, receiving: bool);
-        fn on_ice_selected_candidate_pair_changed(self: &mut PeerConnectionObserverWrapper, event: CandidatePairChangeEvent);
-        fn on_add_track(self: &mut PeerConnectionObserverWrapper, receiver: UniquePtr<RtpReceiver>, streams: Vec<MediaStreamPtr>);
-        fn on_track(self: &mut PeerConnectionObserverWrapper, transceiver: UniquePtr<RtpTransceiver>);
-        fn on_remove_track(self: &mut PeerConnectionObserverWrapper, receiver: UniquePtr<RtpReceiver>);
+        fn on_ice_connection_change(
+            self: &mut PeerConnectionObserverWrapper,
+            new_state: IceConnectionState,
+        );
+        fn on_standardized_ice_connection_change(
+            self: &mut PeerConnectionObserverWrapper,
+            new_state: IceConnectionState,
+        );
+        fn on_connection_change(
+            self: &mut PeerConnectionObserverWrapper,
+            new_state: PeerConnectionState,
+        );
+        fn on_ice_gathering_change(
+            self: &mut PeerConnectionObserverWrapper,
+            new_state: IceGatheringState,
+        );
+        fn on_ice_candidate(
+            self: &mut PeerConnectionObserverWrapper,
+            candidate: UniquePtr<IceCandidate>,
+        );
+        fn on_ice_candidate_error(
+            self: &mut PeerConnectionObserverWrapper,
+            address: String,
+            port: i32,
+            url: String,
+            error_code: i32,
+            error_text: String,
+        );
+        fn on_ice_candidates_removed(
+            self: &mut PeerConnectionObserverWrapper,
+            removed: Vec<CandidatePtr>,
+        );
+        fn on_ice_connection_receiving_change(
+            self: &mut PeerConnectionObserverWrapper,
+            receiving: bool,
+        );
+        fn on_ice_selected_candidate_pair_changed(
+            self: &mut PeerConnectionObserverWrapper,
+            event: CandidatePairChangeEvent,
+        );
+        fn on_add_track(
+            self: &mut PeerConnectionObserverWrapper,
+            receiver: UniquePtr<RtpReceiver>,
+            streams: Vec<MediaStreamPtr>,
+        );
+        fn on_track(
+            self: &mut PeerConnectionObserverWrapper,
+            transceiver: UniquePtr<RtpTransceiver>,
+        );
+        fn on_remove_track(
+            self: &mut PeerConnectionObserverWrapper,
+            receiver: UniquePtr<RtpReceiver>,
+        );
         fn on_interesting_usage(self: &mut PeerConnectionObserverWrapper, usage_pattern: i32);
     }
 }
@@ -151,10 +221,10 @@ unsafe impl Send for ffi::PeerConnection {}
 
 impl Default for ffi::RTCOfferAnswerOptions {
     /*
-        static const int kUndefined = -1;
-        static const int kMaxOfferToReceiveMedia = 1;
-        static const int kOfferToReceiveMediaTrue = 1;
-     */
+       static const int kUndefined = -1;
+       static const int kMaxOfferToReceiveMedia = 1;
+       static const int kOfferToReceiveMediaTrue = 1;
+    */
 
     fn default() -> Self {
         Self {
@@ -165,7 +235,7 @@ impl Default for ffi::RTCOfferAnswerOptions {
             use_rtp_mux: true,
             raw_packetization_for_video: false,
             num_simulcast_layers: 1,
-            use_obsolete_sctp_sdp: false
+            use_obsolete_sctp_sdp: false,
         }
     }
 }
@@ -182,73 +252,90 @@ pub trait PeerConnectionObserver: Send + Sync {
     fn on_connection_change(&mut self, new_state: ffi::PeerConnectionState);
     fn on_ice_gathering_change(&mut self, new_state: ffi::IceGatheringState);
     fn on_ice_candidate(&mut self, candidate: UniquePtr<IceCandidate>);
-    fn on_ice_candidate_error(&mut self, address: String, port: i32, url: String, error_code: i32, error_text: String);
+    fn on_ice_candidate_error(
+        &mut self,
+        address: String,
+        port: i32,
+        url: String,
+        error_code: i32,
+        error_text: String,
+    );
     fn on_ice_candidates_removed(&mut self, removed: Vec<UniquePtr<Candidate>>);
     fn on_ice_connection_receiving_change(&mut self, receiving: bool);
     fn on_ice_selected_candidate_pair_changed(&mut self, event: ffi::CandidatePairChangeEvent);
-    fn on_add_track(&mut self, receiver: UniquePtr<RtpReceiver>, streams: Vec<UniquePtr<MediaStreamInterface>>);
+    fn on_add_track(
+        &mut self,
+        receiver: UniquePtr<RtpReceiver>,
+        streams: Vec<UniquePtr<MediaStreamInterface>>,
+    );
     fn on_track(&mut self, transceiver: UniquePtr<RtpTransceiver>);
     fn on_remove_track(&mut self, receiver: UniquePtr<RtpReceiver>);
     fn on_interesting_usage(&mut self, usage_pattern: i32);
 }
 
 pub struct PeerConnectionObserverWrapper {
-    observer: Box<dyn PeerConnectionObserver>,
+    observer: Rc<RefCell<dyn PeerConnectionObserver>>,
 }
 
 impl PeerConnectionObserverWrapper {
-    pub fn new(observer: Box<dyn PeerConnectionObserver>) -> Self {
-        Self {
-            observer
-        }
+    pub fn new(observer: Rc<RefCell<dyn PeerConnectionObserver>>) -> Self {
+        Self { observer }
     }
 
     fn on_signaling_change(&mut self, new_state: ffi::SignalingState) {
-        self.observer.on_signaling_change(new_state);
+        self.observer.borrow_mut().on_signaling_change(new_state);
     }
 
     fn on_add_stream(&mut self, stream: UniquePtr<MediaStreamInterface>) {
-        self.observer.on_add_stream(stream);
+        self.observer.borrow_mut().on_add_stream(stream);
     }
 
     fn on_remove_stream(&mut self, stream: UniquePtr<MediaStreamInterface>) {
-        self.observer.on_remove_stream(stream);
+        self.observer.borrow_mut().on_remove_stream(stream);
     }
 
     fn on_data_channel(&mut self, data_channel: UniquePtr<DataChannel>) {
-        self.observer.on_data_channel(data_channel);
+        self.observer.borrow_mut().on_data_channel(data_channel);
     }
 
     fn on_renegotiation_needed(&mut self) {
-        self.observer.on_renegotiation_needed();
+        self.observer.borrow_mut().on_renegotiation_needed();
     }
 
     fn on_negotiation_needed_event(&mut self, event: u32) {
-        self.observer.on_negotiation_needed_event(event);
+        self.observer.borrow_mut().on_negotiation_needed_event(event);
     }
 
     fn on_ice_connection_change(&mut self, new_state: ffi::IceConnectionState) {
-        self.observer.on_ice_connection_change(new_state);
+        self.observer.borrow_mut().on_ice_connection_change(new_state);
     }
 
     fn on_standardized_ice_connection_change(&mut self, new_state: ffi::IceConnectionState) {
-        self.observer.on_standardized_ice_connection_change(new_state);
+        self.observer.borrow_mut().on_standardized_ice_connection_change(new_state);
     }
 
     fn on_connection_change(&mut self, new_state: ffi::PeerConnectionState) {
-        self.observer.on_connection_change(new_state);
+        self.observer.borrow_mut().on_connection_change(new_state);
     }
 
     fn on_ice_gathering_change(&mut self, new_state: ffi::IceGatheringState) {
-        self.observer.on_ice_gathering_change(new_state);
+        self.observer.borrow_mut().on_ice_gathering_change(new_state);
     }
 
     fn on_ice_candidate(&mut self, candidate: UniquePtr<IceCandidate>) {
-        self.observer.on_ice_candidate(candidate);
+        self.observer.borrow_mut().on_ice_candidate(candidate);
     }
 
-    fn on_ice_candidate_error(&mut self, address: String, port: i32, url: String, error_code: i32, error_text: String) {
-        self.observer.on_ice_candidate_error(address, port, url, error_code, error_text);
+    fn on_ice_candidate_error(
+        &mut self,
+        address: String,
+        port: i32,
+        url: String,
+        error_code: i32,
+        error_text: String,
+    ) {
+        self.observer
+            .borrow_mut().on_ice_candidate_error(address, port, url, error_code, error_text);
     }
 
     fn on_ice_candidates_removed(&mut self, removed: Vec<ffi::CandidatePtr>) {
@@ -258,36 +345,40 @@ impl PeerConnectionObserverWrapper {
             vec.push(v.ptr);
         }
 
-        self.observer.on_ice_candidates_removed(vec);
+        self.observer.borrow_mut().on_ice_candidates_removed(vec);
     }
 
     fn on_ice_connection_receiving_change(&mut self, receiving: bool) {
-        self.observer.on_ice_connection_receiving_change(receiving);
+        self.observer.borrow_mut().on_ice_connection_receiving_change(receiving);
     }
 
     fn on_ice_selected_candidate_pair_changed(&mut self, event: ffi::CandidatePairChangeEvent) {
-        self.observer.on_ice_selected_candidate_pair_changed(event);
+        self.observer.borrow_mut().on_ice_selected_candidate_pair_changed(event);
     }
 
-    fn on_add_track(&mut self, receiver: UniquePtr<RtpReceiver>, streams: Vec<ffi::MediaStreamPtr>) {
+    fn on_add_track(
+        &mut self,
+        receiver: UniquePtr<RtpReceiver>,
+        streams: Vec<ffi::MediaStreamPtr>,
+    ) {
         let mut vec = Vec::new();
 
         for v in streams {
             vec.push(v.ptr);
         }
 
-        self.observer.on_add_track(receiver, vec);
+        self.observer.borrow_mut().on_add_track(receiver, vec);
     }
 
     fn on_track(&mut self, transceiver: UniquePtr<RtpTransceiver>) {
-        self.observer.on_track(transceiver);
+        self.observer.borrow_mut().on_track(transceiver);
     }
 
     fn on_remove_track(&mut self, receiver: UniquePtr<RtpReceiver>) {
-        self.observer.on_remove_track(receiver);
+        self.observer.borrow_mut().on_remove_track(receiver);
     }
 
     fn on_interesting_usage(&mut self, usage_pattern: i32) {
-        self.observer.on_interesting_usage(usage_pattern);
+        self.observer.borrow_mut().on_interesting_usage(usage_pattern);
     }
 }

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

@@ -77,7 +77,7 @@ namespace livekit{
             ice_server.password = item.password.c_str();
 
             for (auto &url: item.urls){
-                ice_server.urls.push_back(url.c_str());
+                ice_server.urls.emplace_back(url.c_str());
             }
 
             rtc->servers.push_back(ice_server);

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

@@ -1,18 +1,21 @@
-use std::any::Any;
-use std::thread::sleep;
-use std::time::Duration;
-use cxx::UniquePtr;
-use log::info;
 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::{jsep, peer_connection};
 use crate::jsep::CreateSdpObserver;
-use crate::peer_connection::ffi::{CandidatePairChangeEvent, IceConnectionState, IceGatheringState, PeerConnectionState, SignalingState};
+use crate::media_stream_interface::ffi::MediaStreamInterface;
+use crate::peer_connection::ffi::{
+    CandidatePairChangeEvent, IceConnectionState, IceGatheringState, PeerConnectionState,
+    SignalingState,
+};
 use crate::peer_connection::PeerConnectionObserver;
 use crate::rtp_receiver::ffi::RtpReceiver;
 use crate::rtp_transceiver::ffi::RtpTransceiver;
+use crate::{jsep, peer_connection};
+use cxx::UniquePtr;
+use log::info;
+use std::any::Any;
+use std::thread::sleep;
+use std::time::Duration;
 
 #[cxx::bridge(namespace = "livekit")]
 pub mod ffi {
@@ -33,22 +36,21 @@ pub mod ffi {
         include!("livekit/peer_connection_factory.h");
 
         type PeerConnection = crate::peer_connection::ffi::PeerConnection;
-        type NativePeerConnectionObserver = crate::peer_connection::ffi::NativePeerConnectionObserver;
+        type NativePeerConnectionObserver =
+            crate::peer_connection::ffi::NativePeerConnectionObserver;
         type PeerConnectionFactory;
         type NativeRTCConfiguration;
 
         fn create_peer_connection_factory() -> UniquePtr<PeerConnectionFactory>;
         fn create_rtc_configuration(conf: RTCConfiguration) -> UniquePtr<NativeRTCConfiguration>;
 
-        unsafe fn create_peer_connection(self: &PeerConnectionFactory, config: UniquePtr<NativeRTCConfiguration>, observer: UniquePtr<NativePeerConnectionObserver>) -> Result<UniquePtr<PeerConnection>>;
+        fn create_peer_connection(
+            self: &PeerConnectionFactory,
+            config: UniquePtr<NativeRTCConfiguration>,
+            observer: UniquePtr<NativePeerConnectionObserver>,
+        ) -> Result<UniquePtr<PeerConnection>>;
     }
-  }
-
-
-
-
-
-
+}
 
 /*
 
@@ -183,4 +185,3 @@ mod test {
 }
 
 */
-

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

@@ -1,5 +1,8 @@
-use std::fmt::{Display, Formatter};
+use crate::rtc_error::ffi::RTCErrorType;
 use std::error::Error;
+use std::fmt::{Display, Formatter};
+
+// cxx doesn't support custom Exception type, so we serialize RTCError inside the cxx::Exception "what" string
 
 #[cxx::bridge(namespace = "livekit")]
 pub mod ffi {
@@ -40,7 +43,7 @@ pub mod ffi {
         pub message: String,
         pub error_detail: RTCErrorDetailType,
         pub has_sctp_cause_code: bool, // cxx doesn't support the Option trait
-        pub sctp_cause_code: u16
+        pub sctp_cause_code: u16,
     }
 }
 
@@ -63,15 +66,21 @@ impl ffi::RTCError {
             message,
         }
     }
+
+    pub fn ok(&self) -> bool {
+        return self.error_type == RTCErrorType::None;
+    }
 }
 
-impl Error for ffi::RTCError {
-
-}
+impl Error for ffi::RTCError {}
 
 impl Display for ffi::RTCError {
     fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
-        write!(f, "RtcError occurred {:?}: {}", self.error_type, self.message)
+        write!(
+            f,
+            "RtcError occurred {:?}: {}",
+            self.error_type, self.message
+        )
     }
 }
 
@@ -90,7 +99,7 @@ mod tests {
     }
 
     #[test]
-    fn serialize_deserialize(){
+    fn serialize_deserialize() {
         let str = ffi::serialize_deserialize();
         let error = unsafe { RTCError::from(&str) };
 
@@ -98,11 +107,14 @@ mod tests {
         assert_eq!(error.error_detail, RTCErrorDetailType::DataChannelFailure);
         assert_eq!(error.has_sctp_cause_code, true);
         assert_eq!(error.sctp_cause_code, 24);
-        assert_eq!(error.message, "this is not a test, I repeat, this is not a test");
+        assert_eq!(
+            error.message,
+            "this is not a test, I repeat, this is not a test"
+        );
     }
 
     #[test]
-    fn throw_error(){
+    fn throw_error() {
         let exc: cxx::Exception = ffi::throw_error().err().unwrap();
         let error = unsafe { RTCError::from(exc.what()) };
 
@@ -112,4 +124,4 @@ mod tests {
         assert_eq!(error.sctp_cause_code, 0);
         assert_eq!(error.message, "exception is thrown!");
     }
-}
+}