Added .clang-format + reformatted code

crates/livekit-webrtc/libwebrtc-sys/.clang-format

@@ -0,0 +1,24 @@
+# Using the same .clang-format as libwebrtc
+# https://github.com/webrtc-sdk/webrtc/blob/m104_release/.clang-format
+BasedOnStyle: Chromium
+---
+Language: Java
+BasedOnStyle: Google
+---
+Language: ObjC
+BasedOnStyle: Google
+BinPackParameters: false
+BinPackArguments: false
+ColumnLimit: 100
+ObjCBlockIndentWidth: 2
+AllowAllParametersOfDeclarationOnNextLine: true
+AlignOperands: false
+AlwaysBreakBeforeMultilineStrings: false
+AllowShortFunctionsOnASingleLine: Inline
+BreakBeforeTernaryOperators: false
+IndentWrappedFunctionNames: true
+ContinuationIndentWidth: 4
+ObjCSpaceBeforeProtocolList: true
+---
+Language: Cpp
+IncludeBlocks: Regroup

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

@@ -6,23 +6,24 @@
 #define CLIENT_SDK_NATIVE_CANDIDATE_H
 
 #include <memory>
+
 #include "api/candidate.h"
 
 // cricket::Candidate
 namespace livekit {
 
-    class Candidate {
+class Candidate {
  public:
-        explicit Candidate(const cricket::Candidate &candidate);
+  explicit Candidate(const cricket::Candidate& candidate);
 
  private:
   cricket::Candidate candidate_;
-    };
+};
 
-    static std::unique_ptr<Candidate> _unique_candidate(){
+static std::unique_ptr<Candidate> _unique_candidate() {
   return nullptr;
-    }
+}
 
-} // livekit
+}  // namespace livekit
 
-#endif //CLIENT_SDK_NATIVE_CANDIDATE_H
+#endif  // CLIENT_SDK_NATIVE_CANDIDATE_H

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

@@ -6,45 +6,52 @@
 #define CLIENT_SDK_NATIVE_DATA_CHANNEL_H
 
 #include <memory>
+
 #include "api/data_channel_interface.h"
-#include "rust_types.h"
 #include "rust/cxx.h"
+#include "rust_types.h"
 
 namespace livekit {
-    using NativeDataChannelInit = webrtc::DataChannelInit;
+using NativeDataChannelInit = webrtc::DataChannelInit;
-    class NativeDataChannelObserver;
+class NativeDataChannelObserver;
 
-    class DataChannel {
+class DataChannel {
  public:
-        explicit DataChannel(rtc::scoped_refptr<webrtc::DataChannelInterface> data_channel);
+  explicit DataChannel(
+      rtc::scoped_refptr<webrtc::DataChannelInterface> data_channel);
 
-        void register_observer(NativeDataChannelObserver &observer);
+  void register_observer(NativeDataChannelObserver& observer);
   void unregister_observer();
   bool send(const DataBuffer& buffer);
   rust::String label() const;
   void close();
+
  private:
   rtc::scoped_refptr<webrtc::DataChannelInterface> data_channel_;
-    };
+};
 
-    std::unique_ptr<NativeDataChannelInit> create_data_channel_init(DataChannelInit init);
+std::unique_ptr<NativeDataChannelInit> create_data_channel_init(
+    DataChannelInit init);
 
-    static std::unique_ptr<DataChannel> _unique_data_channel(){
+static std::unique_ptr<DataChannel> _unique_data_channel() {
   return nullptr;  // Ignore
-    }
+}
 
-    class NativeDataChannelObserver : public webrtc::DataChannelObserver {
+class NativeDataChannelObserver : public webrtc::DataChannelObserver {
  public:
-        explicit NativeDataChannelObserver(rust::Box<DataChannelObserverWrapper> observer);
+  explicit NativeDataChannelObserver(
+      rust::Box<DataChannelObserverWrapper> observer);
 
   void OnStateChange() override;
   void OnMessage(const webrtc::DataBuffer& buffer) override;
   void OnBufferedAmountChange(uint64_t sent_data_size) override;
+
  private:
   rust::Box<DataChannelObserverWrapper> observer_;
-    };
+};
 
-    std::unique_ptr<NativeDataChannelObserver> create_native_data_channel_observer(rust::Box<DataChannelObserverWrapper> observer);
+std::unique_ptr<NativeDataChannelObserver> create_native_data_channel_observer(
-} // livekit
+    rust::Box<DataChannelObserverWrapper> observer);
+}  // namespace livekit
 
-#endif //CLIENT_SDK_NATIVE_DATA_CHANNEL_H
+#endif  // CLIENT_SDK_NATIVE_DATA_CHANNEL_H

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

@@ -6,29 +6,33 @@
 #define CLIENT_SDK_NATIVE_JSEP_H
 
 #include <memory>
+
 #include "api/jsep.h"
+#include "api/ref_counted_base.h"
 #include "rust/cxx.h"
 #include "rust_types.h"
-#include "api/ref_counted_base.h"
 
 namespace livekit {
 
-    class IceCandidate {
+class IceCandidate {
  public:
-        explicit IceCandidate(std::unique_ptr<webrtc::IceCandidateInterface> ice_candidate);
+  explicit IceCandidate(
+      std::unique_ptr<webrtc::IceCandidateInterface> ice_candidate);
 
   std::unique_ptr<webrtc::IceCandidateInterface> release();
+
  private:
   std::unique_ptr<webrtc::IceCandidateInterface> ice_candidate_;
-    };
+};
 
-    static std::unique_ptr<IceCandidate> _unique_ice_candidate(){
+static std::unique_ptr<IceCandidate> _unique_ice_candidate() {
   return nullptr;  // Ignore
-    }
+}
 
-    class SessionDescription {
+class SessionDescription {
  public:
-        explicit SessionDescription(std::unique_ptr<webrtc::SessionDescriptionInterface> session_description);
+  explicit SessionDescription(
+      std::unique_ptr<webrtc::SessionDescriptionInterface> session_description);
 
   rust::String stringify() const;
   std::unique_ptr<SessionDescription> clone() const;
@@ -36,63 +40,77 @@ namespace livekit {
 
  private:
   std::unique_ptr<webrtc::SessionDescriptionInterface> session_description_;
-    };
+};
 
-    static std::unique_ptr<SessionDescription> _unique_session_description(){
+static std::unique_ptr<SessionDescription> _unique_session_description() {
   return nullptr;  // Ignore
-    }
+}
 
-    // SetCreateSdpObserver
+// SetCreateSdpObserver
 
-    class NativeCreateSdpObserver : public webrtc::CreateSessionDescriptionObserver {
+class NativeCreateSdpObserver
+    : public webrtc::CreateSessionDescriptionObserver {
  public:
-        explicit NativeCreateSdpObserver(rust::Box<CreateSdpObserverWrapper> observer);
+  explicit NativeCreateSdpObserver(
+      rust::Box<CreateSdpObserverWrapper> observer);
 
   void OnSuccess(webrtc::SessionDescriptionInterface* desc) override;
   void OnFailure(webrtc::RTCError error) override;
+
  private:
   rust::Box<CreateSdpObserverWrapper> observer_;
-    };
+};
 
-    struct NativeCreateSdpObserverHandle {
+struct NativeCreateSdpObserverHandle {
   rtc::scoped_refptr<NativeCreateSdpObserver> observer;
-    };
+};
 
-    std::unique_ptr<NativeCreateSdpObserverHandle> create_native_create_sdp_observer(rust::Box<CreateSdpObserverWrapper> observer);
+std::unique_ptr<NativeCreateSdpObserverHandle>
+create_native_create_sdp_observer(rust::Box<CreateSdpObserverWrapper> observer);
 
-    // SetLocalSdpObserver
+// SetLocalSdpObserver
 
-    class NativeSetLocalSdpObserver : public webrtc::SetLocalDescriptionObserverInterface{
+class NativeSetLocalSdpObserver
+    : public webrtc::SetLocalDescriptionObserverInterface {
  public:
-        explicit NativeSetLocalSdpObserver(rust::Box<SetLocalSdpObserverWrapper> observer);
+  explicit NativeSetLocalSdpObserver(
+      rust::Box<SetLocalSdpObserverWrapper> observer);
 
   void OnSetLocalDescriptionComplete(webrtc::RTCError error) override;
+
  private:
   rust::Box<SetLocalSdpObserverWrapper> observer_;
-    };
+};
 
-    struct NativeSetLocalSdpObserverHandle {
+struct NativeSetLocalSdpObserverHandle {
   rtc::scoped_refptr<NativeSetLocalSdpObserver> observer;
-    };
+};
 
-    std::unique_ptr<NativeSetLocalSdpObserverHandle> create_native_set_local_sdp_observer(rust::Box<SetLocalSdpObserverWrapper> observer);
+std::unique_ptr<NativeSetLocalSdpObserverHandle>
+create_native_set_local_sdp_observer(
+    rust::Box<SetLocalSdpObserverWrapper> observer);
 
-    // SetRemoteSdpObserver
+// SetRemoteSdpObserver
 
-    class NativeSetRemoteSdpObserver : public webrtc::SetRemoteDescriptionObserverInterface{
+class NativeSetRemoteSdpObserver
+    : public webrtc::SetRemoteDescriptionObserverInterface {
  public:
-        explicit NativeSetRemoteSdpObserver(rust::Box<SetRemoteSdpObserverWrapper> observer);
+  explicit NativeSetRemoteSdpObserver(
+      rust::Box<SetRemoteSdpObserverWrapper> observer);
 
   void OnSetRemoteDescriptionComplete(webrtc::RTCError error) override;
+
  private:
   rust::Box<SetRemoteSdpObserverWrapper> observer_;
-    };
+};
 
-    struct NativeSetRemoteSdpObserverHandle {
+struct NativeSetRemoteSdpObserverHandle {
   rtc::scoped_refptr<NativeSetRemoteSdpObserver> observer;
-    };
+};
 
-    std::unique_ptr<NativeSetRemoteSdpObserverHandle> create_native_set_remote_sdp_observer(rust::Box<SetRemoteSdpObserverWrapper> observer);
+std::unique_ptr<NativeSetRemoteSdpObserverHandle>
-} // livekit
+create_native_set_remote_sdp_observer(
+    rust::Box<SetRemoteSdpObserverWrapper> observer);
+}  // namespace livekit
 
-#endif //CLIENT_SDK_NATIVE_JSEP_H
+#endif  // CLIENT_SDK_NATIVE_JSEP_H

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

@@ -6,21 +6,23 @@
 #define CLIENT_SDK_NATIVE_MEDIA_STREAM_INTERFACE_H
 
 #include <memory>
+
 #include "api/media_stream_interface.h"
 
 namespace livekit {
 
-    class MediaStreamInterface {
+class MediaStreamInterface {
  public:
-        explicit MediaStreamInterface(rtc::scoped_refptr<webrtc::MediaStreamInterface> stream);
+  explicit MediaStreamInterface(
+      rtc::scoped_refptr<webrtc::MediaStreamInterface> stream);
 
  private:
   rtc::scoped_refptr<webrtc::MediaStreamInterface> media_stream_;
-    };
+};
 
-    static std::unique_ptr<MediaStreamInterface> _unique_media_stream(){
+static std::unique_ptr<MediaStreamInterface> _unique_media_stream() {
   return nullptr;  // Ignore
-    }
+}
-} // livekit
+}  // namespace livekit
 
-#endif //CLIENT_SDK_NATIVE_MEDIA_STREAM_INTERFACE_H
+#endif  // CLIENT_SDK_NATIVE_MEDIA_STREAM_INTERFACE_H

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

@@ -6,76 +6,128 @@
 #define CLIENT_SDK_NATIVE_PEER_CONNECTION_H
 
 #include <memory>
+
 #include "api/peer_connection_interface.h"
-#include "rust/cxx.h"
 #include "data_channel.h"
 #include "jsep.h"
+#include "rust/cxx.h"
 #include "rust_types.h"
 
 namespace livekit {
-    class NativeAddIceCandidateObserver;
+class NativeAddIceCandidateObserver;
 
-    class PeerConnection {
+class PeerConnection {
  public:
-        explicit PeerConnection(rtc::scoped_refptr<webrtc::PeerConnectionInterface> peer_connection);
+  explicit PeerConnection(
+      rtc::scoped_refptr<webrtc::PeerConnectionInterface> peer_connection);
 
-        void create_offer(NativeCreateSdpObserverHandle &observer, RTCOfferAnswerOptions options);
+  void create_offer(NativeCreateSdpObserverHandle& observer,
-        void create_answer(NativeCreateSdpObserverHandle &observer, RTCOfferAnswerOptions options);
+                    RTCOfferAnswerOptions options);
-        void set_local_description(std::unique_ptr<SessionDescription> desc, NativeSetLocalSdpObserverHandle &observer);
+  void create_answer(NativeCreateSdpObserverHandle& observer,
-        void set_remote_description(std::unique_ptr<SessionDescription> desc, NativeSetRemoteSdpObserverHandle &observer);
+                     RTCOfferAnswerOptions options);
-        std::unique_ptr<DataChannel> create_data_channel(rust::String label, std::unique_ptr<NativeDataChannelInit> init);
+  void set_local_description(std::unique_ptr<SessionDescription> desc,
-        void add_ice_candidate(std::unique_ptr<IceCandidate> candidate, NativeAddIceCandidateObserver &observer);
+                             NativeSetLocalSdpObserverHandle& observer);
+  void set_remote_description(std::unique_ptr<SessionDescription> desc,
+                              NativeSetRemoteSdpObserverHandle& observer);
+  std::unique_ptr<DataChannel> create_data_channel(
+      rust::String label,
+      std::unique_ptr<NativeDataChannelInit> init);
+  void add_ice_candidate(std::unique_ptr<IceCandidate> candidate,
+                         NativeAddIceCandidateObserver& observer);
   void close();
 
  private:
   rtc::scoped_refptr<webrtc::PeerConnectionInterface> peer_connection_;
-    };
+};
 
-    static std::unique_ptr<PeerConnection> _unique_peer_connection() {
+static std::unique_ptr<PeerConnection> _unique_peer_connection() {
   return nullptr;  // Ignore
-    }
+}
 
-    class NativeAddIceCandidateObserver {
+class NativeAddIceCandidateObserver {
  public:
-        explicit NativeAddIceCandidateObserver(rust::Box<AddIceCandidateObserverWrapper> observer);
+  explicit NativeAddIceCandidateObserver(
+      rust::Box<AddIceCandidateObserverWrapper> observer);
+
+  void OnComplete(const RTCError& error);
 
-        void OnComplete(const RTCError &error);
  private:
   rust::Box<AddIceCandidateObserverWrapper> observer_;
-    };
+};
 
-    std::unique_ptr<NativeAddIceCandidateObserver> create_native_add_ice_candidate_observer(rust::Box<AddIceCandidateObserverWrapper> observer);
+std::unique_ptr<NativeAddIceCandidateObserver>
+create_native_add_ice_candidate_observer(
+    rust::Box<AddIceCandidateObserverWrapper> observer);
 
-    class NativePeerConnectionObserver : public webrtc::PeerConnectionObserver {
+class NativePeerConnectionObserver : public webrtc::PeerConnectionObserver {
  public:
-        explicit NativePeerConnectionObserver(rust::Box<PeerConnectionObserverWrapper> observer);
+  explicit NativePeerConnectionObserver(
+      rust::Box<PeerConnectionObserverWrapper> observer);
+
+  void OnSignalingChange(
+      webrtc::PeerConnectionInterface::SignalingState new_state) override;
+
+  void OnAddStream(
+      rtc::scoped_refptr<webrtc::MediaStreamInterface> stream) override;
+
+  void OnRemoveStream(
+      rtc::scoped_refptr<webrtc::MediaStreamInterface> stream) override;
+
+  void OnDataChannel(
+      rtc::scoped_refptr<webrtc::DataChannelInterface> data_channel) override;
 
-        void OnSignalingChange(webrtc::PeerConnectionInterface::SignalingState new_state) override;
-        void OnAddStream(rtc::scoped_refptr<webrtc::MediaStreamInterface> stream) override;
-        void OnRemoveStream(rtc::scoped_refptr<webrtc::MediaStreamInterface> stream) override;
-        void OnDataChannel(rtc::scoped_refptr<webrtc::DataChannelInterface> data_channel) override;
   void OnRenegotiationNeeded() override;
+
   void OnNegotiationNeededEvent(uint32_t event_id) override;
-        void OnIceConnectionChange(webrtc::PeerConnectionInterface::IceConnectionState new_state) override;
+
-        void OnStandardizedIceConnectionChange(webrtc::PeerConnectionInterface::IceConnectionState new_state) override;
+  void OnIceConnectionChange(
-        void OnConnectionChange(webrtc::PeerConnectionInterface::PeerConnectionState new_state) override;
+      webrtc::PeerConnectionInterface::IceConnectionState new_state) override;
-        void OnIceGatheringChange(webrtc::PeerConnectionInterface::IceGatheringState new_state) override;
+
-        void OnIceCandidate(const webrtc::IceCandidateInterface *candidate) override;
+  void OnStandardizedIceConnectionChange(
-        void OnIceCandidateError(const std::string &address, int port, const std::string &url, int error_code, const std::string &error_text) override;
+      webrtc::PeerConnectionInterface::IceConnectionState new_state) override;
-        void OnIceCandidatesRemoved(const std::vector<cricket::Candidate> &candidates) override;
+
+  void OnConnectionChange(
+      webrtc::PeerConnectionInterface::PeerConnectionState new_state) override;
+
+  void OnIceGatheringChange(
+      webrtc::PeerConnectionInterface::IceGatheringState new_state) override;
+
+  void OnIceCandidate(const webrtc::IceCandidateInterface* candidate) override;
+
+  void OnIceCandidateError(const std::string& address,
+                           int port,
+                           const std::string& url,
+                           int error_code,
+                           const std::string& error_text) override;
+
+  void OnIceCandidatesRemoved(
+      const std::vector<cricket::Candidate>& candidates) override;
+
   void OnIceConnectionReceivingChange(bool receiving) override;
-        void OnIceSelectedCandidatePairChanged(const cricket::CandidatePairChangeEvent &event) override;
+
-        void OnAddTrack(rtc::scoped_refptr<webrtc::RtpReceiverInterface> receiver, const std::vector<rtc::scoped_refptr<webrtc::MediaStreamInterface>> &streams) override;
+  void OnIceSelectedCandidatePairChanged(
-        void OnTrack(rtc::scoped_refptr<webrtc::RtpTransceiverInterface> transceiver) override;
+      const cricket::CandidatePairChangeEvent& event) override;
-        void OnRemoveTrack(rtc::scoped_refptr<webrtc::RtpReceiverInterface> receiver) override;
+
+  void OnAddTrack(
+      rtc::scoped_refptr<webrtc::RtpReceiverInterface> receiver,
+      const std::vector<rtc::scoped_refptr<webrtc::MediaStreamInterface>>&
+          streams) override;
+
+  void OnTrack(
+      rtc::scoped_refptr<webrtc::RtpTransceiverInterface> transceiver) override;
+
+  void OnRemoveTrack(
+      rtc::scoped_refptr<webrtc::RtpReceiverInterface> receiver) override;
+
   void OnInterestingUsage(int usage_pattern) override;
 
  private:
   rust::Box<PeerConnectionObserverWrapper> observer_;
-    };
+};
 
-    std::unique_ptr<NativePeerConnectionObserver> create_native_peer_connection_observer(rust::Box<PeerConnectionObserverWrapper> observer);
+std::unique_ptr<NativePeerConnectionObserver>
-} // livekit
+create_native_peer_connection_observer(
-
+    rust::Box<PeerConnectionObserverWrapper> observer);
-#endif //CLIENT_SDK_NATIVE_PEER_CONNECTION_H
+}  // namespace livekit
 
+#endif  // CLIENT_SDK_NATIVE_PEER_CONNECTION_H

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

@@ -2,7 +2,6 @@
 // Created by Théo Monnom on 03/08/2022.
 //
 
-
 #ifndef PEER_CONNECTION_FACTORY_H
 #define PEER_CONNECTION_FACTORY_H
 
@@ -11,13 +10,16 @@
 #include "rust_types.h"
 
 namespace livekit {
-    using NativeRTCConfiguration = webrtc::PeerConnectionInterface::RTCConfiguration;
+using NativeRTCConfiguration =
+    webrtc::PeerConnectionInterface::RTCConfiguration;
 
-    class PeerConnectionFactory {
+class PeerConnectionFactory {
  public:
   PeerConnectionFactory();
 
-        std::unique_ptr<PeerConnection> create_peer_connection(std::unique_ptr<NativeRTCConfiguration> config, NativePeerConnectionObserver &observer) const;
+  std::unique_ptr<PeerConnection> create_peer_connection(
+      std::unique_ptr<NativeRTCConfiguration> config,
+      NativePeerConnectionObserver& observer) const;
 
  private:
   std::unique_ptr<rtc::Thread> network_thread_;
@@ -25,11 +27,11 @@ namespace livekit {
   std::unique_ptr<rtc::Thread> signaling_thread_;
 
   rtc::scoped_refptr<webrtc::PeerConnectionFactoryInterface> peer_factory_;
-    };
+};
 
-    std::unique_ptr<PeerConnectionFactory> create_peer_connection_factory();
+std::unique_ptr<PeerConnectionFactory> create_peer_connection_factory();
-    std::unique_ptr<NativeRTCConfiguration> create_rtc_configuration(RTCConfiguration conf);
+std::unique_ptr<NativeRTCConfiguration> create_rtc_configuration(
-} // livekit
+    RTCConfiguration conf);
+}  // namespace livekit
 
-
+#endif  // PEER_CONNECTION_FACTORY_H
-#endif //PEER_CONNECTION_FACTORY_H

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

@@ -7,19 +7,20 @@
 
 #include "api/rtc_error.h"
 #include "libwebrtc-sys/src/rtc_error.rs.h"
-#include "rust_types.h"
 #include "rust/cxx.h"
+#include "rust_types.h"
 
 namespace livekit {
 
-    RTCError to_error(const webrtc::RTCError &error);
+RTCError to_error(const webrtc::RTCError& error);
-    std::string serialize_error(const RTCError &error); // to be used inside cxx::Exception msg
+std::string serialize_error(
+    const RTCError& error);  // to be used inside cxx::Exception msg
 
 #ifdef LIVEKIT_TEST
-    rust::String serialize_deserialize();
+rust::String serialize_deserialize();
-    void throw_error();
+void throw_error();
 #endif
 
-} // livekit
+}  // namespace livekit
 
-#endif //CLIENT_SDK_NATIVE_RTC_ERROR_H
+#endif  // CLIENT_SDK_NATIVE_RTC_ERROR_H

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

@@ -6,21 +6,23 @@
 #define CLIENT_SDK_NATIVE_RTP_RECEIVER_H
 
 #include <memory>
+
 #include "api/rtp_receiver_interface.h"
 
 namespace livekit {
 
-    class RtpReceiver {
+class RtpReceiver {
  public:
-        explicit RtpReceiver(rtc::scoped_refptr<webrtc::RtpReceiverInterface> receiver);
+  explicit RtpReceiver(
+      rtc::scoped_refptr<webrtc::RtpReceiverInterface> receiver);
 
  private:
   rtc::scoped_refptr<webrtc::RtpReceiverInterface> receiver_;
-    };
+};
 
-    static std::unique_ptr<RtpReceiver> _unique_rtp_receiver(){
+static std::unique_ptr<RtpReceiver> _unique_rtp_receiver() {
   return nullptr;  // Ignore
-    }
+}
-} // livekit
+}  // namespace livekit
 
-#endif //CLIENT_SDK_NATIVE_RTP_RECEIVER_H
+#endif  // CLIENT_SDK_NATIVE_RTP_RECEIVER_H

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

@@ -6,21 +6,23 @@
 #define CLIENT_SDK_NATIVE_RTP_TRANSCEIVER_H
 
 #include <memory>
+
 #include "api/rtp_transceiver_interface.h"
 
 namespace livekit {
 
-    class RtpTransceiver {
+class RtpTransceiver {
  public:
-        explicit RtpTransceiver(rtc::scoped_refptr<webrtc::RtpTransceiverInterface> transceiver);
+  explicit RtpTransceiver(
+      rtc::scoped_refptr<webrtc::RtpTransceiverInterface> transceiver);
 
  private:
   rtc::scoped_refptr<webrtc::RtpTransceiverInterface> transceiver_;
-    };
+};
 
-    static std::unique_ptr<RtpTransceiver> _unique_rtp_transceiver(){
+static std::unique_ptr<RtpTransceiver> _unique_rtp_transceiver() {
   return nullptr;  // Ignore
-    }
+}
-} // livekit
+}  // namespace livekit
 
-#endif //CLIENT_SDK_NATIVE_RTP_TRANSCEIVER_H
+#endif  // CLIENT_SDK_NATIVE_RTP_TRANSCEIVER_H

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

@@ -2,26 +2,25 @@
 // Created by Théo Monnom on 30/08/2022.
 //
 
-
 #ifndef RUST_TYPES_H
 #define RUST_TYPES_H
 
 #include "api/peer_connection_interface.h"
 
 namespace livekit {
-    struct RTCConfiguration;
+struct RTCConfiguration;
-    struct PeerConnectionObserverWrapper;
+struct PeerConnectionObserverWrapper;
-    struct CreateSdpObserverWrapper;
+struct CreateSdpObserverWrapper;
-    struct SetLocalSdpObserverWrapper;
+struct SetLocalSdpObserverWrapper;
-    struct SetRemoteSdpObserverWrapper;
+struct SetRemoteSdpObserverWrapper;
-    struct DataChannelObserverWrapper;
+struct DataChannelObserverWrapper;
-    struct AddIceCandidateObserverWrapper;
+struct AddIceCandidateObserverWrapper;
 
-    // Shared types
+// Shared types
-    struct RTCOfferAnswerOptions;
+struct RTCOfferAnswerOptions;
-    struct RTCError;
+struct RTCError;
-    struct DataChannelInit;
+struct DataChannelInit;
-    struct DataBuffer;
+struct DataBuffer;
-}
+}  // namespace livekit
 
-#endif //RUST_TYPES_H
+#endif  // RUST_TYPES_H

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

@@ -5,8 +5,8 @@
 #ifndef LIVEKIT_WEBRTC_WEBRTC_H
 #define LIVEKIT_WEBRTC_WEBRTC_H
 
-#include "rtc_base/ssl_adapter.h"
 #include "rtc_base/physical_socket_server.h"
+#include "rtc_base/ssl_adapter.h"
 
 #ifdef WEBRTC_WIN
 #include "rtc_base/win32_socket_init.h"
@@ -14,21 +14,22 @@
 
 namespace livekit {
 
-    class RTCRuntime {
+class RTCRuntime {
  public:
   RTCRuntime();
   ~RTCRuntime();
 
   RTCRuntime(const RTCRuntime&) = delete;
   RTCRuntime& operator=(const RTCRuntime&) = delete;
+
  private:
-    #ifdef WEBRTC_WIN
+#ifdef WEBRTC_WIN
   rtc::WinsockInitializer winsock_;
-    #endif
+#endif
-    };
+};
 
-    std::unique_ptr<RTCRuntime> create_rtc_runtime();
+std::unique_ptr<RTCRuntime> create_rtc_runtime();
 
-} // livekit
+}  // namespace livekit
 
-#endif //LIVEKIT_WEBRTC_WEBRTC_H
+#endif  // LIVEKIT_WEBRTC_WEBRTC_H

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

@@ -5,7 +5,6 @@
 #include "livekit/candidate.h"
 
 namespace livekit {
-    Candidate::Candidate(const cricket::Candidate &candidate) : candidate_(candidate) {
+Candidate::Candidate(const cricket::Candidate& candidate)
-
+    : candidate_(candidate) {}
-    }
+}  // namespace livekit
-} // livekit

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

@@ -1,5 +1,3 @@
-use cxx::UniquePtr;
-
 #[cxx::bridge(namespace = "livekit")]
 pub mod ffi {
     unsafe extern "C++" {

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

@@ -2,38 +2,41 @@
 // Created by Théo Monnom on 01/09/2022.
 //
 
+#include "livekit/data_channel.h"
+
 #include <utility>
 
-#include "livekit/data_channel.h"
 #include "libwebrtc-sys/src/data_channel.rs.h"
 
 namespace livekit {
 
-    DataChannel::DataChannel(rtc::scoped_refptr<webrtc::DataChannelInterface> data_channel) : data_channel_(std::move(data_channel)) {
+DataChannel::DataChannel(
+    rtc::scoped_refptr<webrtc::DataChannelInterface> data_channel)
+    : data_channel_(std::move(data_channel)) {}
 
-    }
+void DataChannel::register_observer(NativeDataChannelObserver& observer) {
-
-    void DataChannel::register_observer(NativeDataChannelObserver &observer) {
   data_channel_->RegisterObserver(&observer);
-    }
+}
 
-    void DataChannel::unregister_observer() {
+void DataChannel::unregister_observer() {
   data_channel_->UnregisterObserver();
-    }
+}
 
-    bool DataChannel::send(const DataBuffer &buffer) {
+bool DataChannel::send(const DataBuffer& buffer) {
-        return data_channel_->Send(webrtc::DataBuffer{rtc::CopyOnWriteBuffer(buffer.ptr, buffer.len), buffer.binary });
+  return data_channel_->Send(webrtc::DataBuffer{
-    }
+      rtc::CopyOnWriteBuffer(buffer.ptr, buffer.len), buffer.binary});
+}
 
-    rust::String DataChannel::label() const{
+rust::String DataChannel::label() const {
   return data_channel_->label();
-    }
+}
 
-    void DataChannel::close() {
+void DataChannel::close() {
   return data_channel_->Close();
-    }
+}
 
-    std::unique_ptr<NativeDataChannelInit> create_data_channel_init(DataChannelInit init) {
+std::unique_ptr<NativeDataChannelInit> create_data_channel_init(
+    DataChannelInit init) {
   auto rtc_init = std::make_unique<webrtc::DataChannelInit>();
   rtc_init->id = init.id;
   rtc_init->negotiated = init.negotiated;
@@ -41,39 +44,41 @@ namespace livekit {
   rtc_init->protocol = init.protocol.c_str();
   rtc_init->reliable = init.reliable;
 
-        if(init.has_max_retransmit_time)
+  if (init.has_max_retransmit_time)
     rtc_init->maxRetransmitTime = init.max_retransmit_time;
 
-        if(init.has_max_retransmits)
+  if (init.has_max_retransmits)
     rtc_init->maxRetransmits = init.max_retransmits;
 
-        if(init.has_priority)
+  if (init.has_priority)
     rtc_init->priority = static_cast<webrtc::Priority>(init.priority);
 
   return rtc_init;
-    }
+}
 
-    NativeDataChannelObserver::NativeDataChannelObserver(rust::Box<DataChannelObserverWrapper> observer) : observer_(std::move(observer)){
+NativeDataChannelObserver::NativeDataChannelObserver(
+    rust::Box<DataChannelObserverWrapper> observer)
+    : observer_(std::move(observer)) {}
 
-    }
+void NativeDataChannelObserver::OnStateChange() {
-
-    void NativeDataChannelObserver::OnStateChange() {
   observer_->on_state_change();
-    }
+}
 
-    void NativeDataChannelObserver::OnMessage(const webrtc::DataBuffer &buffer) {
+void NativeDataChannelObserver::OnMessage(const webrtc::DataBuffer& buffer) {
   DataBuffer data{};
   data.ptr = buffer.data.data();
   data.len = buffer.data.size();
   data.binary = buffer.binary;
   observer_->on_message(data);
-    }
+}
 
-    void NativeDataChannelObserver::OnBufferedAmountChange(uint64_t sent_data_size) {
+void NativeDataChannelObserver::OnBufferedAmountChange(
+    uint64_t sent_data_size) {
   observer_->on_buffered_amount_change(sent_data_size);
-    }
+}
 
-    std::unique_ptr<NativeDataChannelObserver> create_native_data_channel_observer(rust::Box<DataChannelObserverWrapper> observer){
+std::unique_ptr<NativeDataChannelObserver> create_native_data_channel_observer(
+    rust::Box<DataChannelObserverWrapper> observer) {
   return std::make_unique<NativeDataChannelObserver>(std::move(observer));
-    }
+}
-} // livekit
+}  // namespace livekit

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

@@ -1,9 +1,7 @@
-use cxx::UniquePtr;
 use std::slice;
 
 #[cxx::bridge(namespace = "livekit")]
 pub mod ffi {
-
     #[derive(Debug)]
     #[repr(u32)]
     pub enum Priority {
@@ -83,6 +81,7 @@ pub mod ffi {
 }
 
 unsafe impl Send for ffi::DataChannel {}
+
 unsafe impl Send for ffi::NativeDataChannelObserver {}
 
 // DataChannelObserver

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

@@ -2,93 +2,106 @@
 // Created by Théo Monnom on 01/09/2022.
 //
 
+#include "livekit/jsep.h"
+
 #include <memory>
 
-#include "livekit/rtc_error.h"
-#include "livekit/jsep.h"
 #include "libwebrtc-sys/src/jsep.rs.h"
+#include "livekit/rtc_error.h"
 #include "rtc_base/ref_counted_object.h"
 
 namespace livekit {
 
-    IceCandidate::IceCandidate(std::unique_ptr<webrtc::IceCandidateInterface> ice_candidate) : ice_candidate_(std::move(ice_candidate)){
+IceCandidate::IceCandidate(
+    std::unique_ptr<webrtc::IceCandidateInterface> ice_candidate)
+    : ice_candidate_(std::move(ice_candidate)) {}
 
-    }
+std::unique_ptr<webrtc::IceCandidateInterface> IceCandidate::release() {
-
-    std::unique_ptr<webrtc::IceCandidateInterface> IceCandidate::release() {
   return std::move(ice_candidate_);
-    }
+}
 
-    SessionDescription::SessionDescription(std::unique_ptr<webrtc::SessionDescriptionInterface> session_description) : session_description_(std::move(session_description)){
+SessionDescription::SessionDescription(
+    std::unique_ptr<webrtc::SessionDescriptionInterface> session_description)
+    : session_description_(std::move(session_description)) {}
 
-    }
+rust::String SessionDescription::stringify() const {
-
-    rust::String SessionDescription::stringify() const {
   std::string str;
   session_description_->ToString(&str);
   return rust::String{str};
-    }
+}
 
-    std::unique_ptr<SessionDescription> SessionDescription::clone() const {
+std::unique_ptr<SessionDescription> SessionDescription::clone() const {
   return std::make_unique<SessionDescription>(session_description_->Clone());
-    }
+}
 
-    std::unique_ptr<webrtc::SessionDescriptionInterface> SessionDescription::release() {
+std::unique_ptr<webrtc::SessionDescriptionInterface>
+SessionDescription::release() {
   return std::move(session_description_);
-    }
+}
 
-    // CreateSdpObserver
+// CreateSdpObserver
 
-    NativeCreateSdpObserver::NativeCreateSdpObserver(
+NativeCreateSdpObserver::NativeCreateSdpObserver(
-            rust::Box<CreateSdpObserverWrapper> observer) : observer_(std::move(observer)) {
+    rust::Box<CreateSdpObserverWrapper> observer)
+    : observer_(std::move(observer)) {}
 
-    }
+void NativeCreateSdpObserver::OnSuccess(
-
+    webrtc::SessionDescriptionInterface* desc) {
-    void NativeCreateSdpObserver::OnSuccess(webrtc::SessionDescriptionInterface *desc) {
   // We have ownership of desc
-        observer_->on_success(std::make_unique<SessionDescription>(std::unique_ptr<webrtc::SessionDescriptionInterface>(desc)));
+  observer_->on_success(std::make_unique<SessionDescription>(
-    }
+      std::unique_ptr<webrtc::SessionDescriptionInterface>(desc)));
+}
 
-    void NativeCreateSdpObserver::OnFailure(webrtc::RTCError error) {
+void NativeCreateSdpObserver::OnFailure(webrtc::RTCError error) {
   observer_->on_failure(to_error(error));
-    }
+}
 
-    std::unique_ptr<NativeCreateSdpObserverHandle> create_native_create_sdp_observer(rust::Box<CreateSdpObserverWrapper> observer){
+std::unique_ptr<NativeCreateSdpObserverHandle>
-        return std::make_unique<NativeCreateSdpObserverHandle>(NativeCreateSdpObserverHandle {
+create_native_create_sdp_observer(
-            rtc::make_ref_counted<NativeCreateSdpObserver>(std::move(observer))
+    rust::Box<CreateSdpObserverWrapper> observer) {
-        });
+  return std::make_unique<NativeCreateSdpObserverHandle>(
-    }
+      NativeCreateSdpObserverHandle{
+          rtc::make_ref_counted<NativeCreateSdpObserver>(std::move(observer))});
+}
 
-    // SetLocalSdpObserver
+// SetLocalSdpObserver
 
-    NativeSetLocalSdpObserver::NativeSetLocalSdpObserver(rust::Box<SetLocalSdpObserverWrapper> observer) : observer_(std::move(observer)) {
+NativeSetLocalSdpObserver::NativeSetLocalSdpObserver(
+    rust::Box<SetLocalSdpObserverWrapper> observer)
+    : observer_(std::move(observer)) {}
 
-    }
+void NativeSetLocalSdpObserver::OnSetLocalDescriptionComplete(
-
+    webrtc::RTCError error) {
-    void NativeSetLocalSdpObserver::OnSetLocalDescriptionComplete(webrtc::RTCError error) {
   observer_->on_set_local_description_complete(to_error(error));
-    }
+}
 
-    std::unique_ptr<NativeSetLocalSdpObserverHandle> create_native_set_local_sdp_observer(rust::Box<SetLocalSdpObserverWrapper> observer){
+std::unique_ptr<NativeSetLocalSdpObserverHandle>
-        return std::make_unique<NativeSetLocalSdpObserverHandle>(NativeSetLocalSdpObserverHandle {
+create_native_set_local_sdp_observer(
-                rtc::make_ref_counted<NativeSetLocalSdpObserver>(std::move(observer))
+    rust::Box<SetLocalSdpObserverWrapper> observer) {
-        });
+  return std::make_unique<NativeSetLocalSdpObserverHandle>(
-    }
+      NativeSetLocalSdpObserverHandle{
+          rtc::make_ref_counted<NativeSetLocalSdpObserver>(
+              std::move(observer))});
+}
 
-    // SetRemoteSdpObserver
+// SetRemoteSdpObserver
 
-    NativeSetRemoteSdpObserver::NativeSetRemoteSdpObserver(rust::Box<SetRemoteSdpObserverWrapper> observer) : observer_(std::move(observer)) {
+NativeSetRemoteSdpObserver::NativeSetRemoteSdpObserver(
+    rust::Box<SetRemoteSdpObserverWrapper> observer)
+    : observer_(std::move(observer)) {}
 
-    }
+void NativeSetRemoteSdpObserver::OnSetRemoteDescriptionComplete(
-
+    webrtc::RTCError error) {
-    void NativeSetRemoteSdpObserver::OnSetRemoteDescriptionComplete(webrtc::RTCError error) {
   observer_->on_set_remote_description_complete(to_error(error));
-    }
+}
 
-    std::unique_ptr<NativeSetRemoteSdpObserverHandle> create_native_set_remote_sdp_observer(rust::Box<SetRemoteSdpObserverWrapper> observer){
+std::unique_ptr<NativeSetRemoteSdpObserverHandle>
-        return std::make_unique<NativeSetRemoteSdpObserverHandle>(NativeSetRemoteSdpObserverHandle {
+create_native_set_remote_sdp_observer(
-                rtc::make_ref_counted<NativeSetRemoteSdpObserver>(std::move(observer))
+    rust::Box<SetRemoteSdpObserverWrapper> observer) {
-        });
+  return std::make_unique<NativeSetRemoteSdpObserverHandle>(
-    }
+      NativeSetRemoteSdpObserverHandle{
+          rtc::make_ref_counted<NativeSetRemoteSdpObserver>(
+              std::move(observer))});
+}
 
-} // livekit
+}  // namespace livekit

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

@@ -1,11 +1,11 @@
-use cxx::UniquePtr;
 use std::fmt::{Debug, Formatter};
 
+use cxx::UniquePtr;
+
 use crate::rtc_error::ffi::RTCError;
 
 #[cxx::bridge(namespace = "livekit")]
 pub mod ffi {
-
     extern "Rust" {
         type CreateSdpObserverWrapper;
         fn on_success(

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

@@ -6,7 +6,7 @@
 
 namespace livekit {
 
-    MediaStreamInterface::MediaStreamInterface(rtc::scoped_refptr<webrtc::MediaStreamInterface> stream) : media_stream_(std::move(stream)) {
+MediaStreamInterface::MediaStreamInterface(
-
+    rtc::scoped_refptr<webrtc::MediaStreamInterface> stream)
-    }
+    : media_stream_(std::move(stream)) {}
-} // livekit
+}  // namespace livekit

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

@@ -1,5 +1,3 @@
-use cxx::UniquePtr;
-
 #[cxx::bridge(namespace = "livekit")]
 pub mod ffi {
     unsafe extern "C++" {

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

@@ -3,12 +3,14 @@
 //
 
 #include "livekit/peer_connection.h"
+
 #include "libwebrtc-sys/src/peer_connection.rs.h"
 #include "livekit/rtc_error.h"
 
 namespace livekit {
 
-    inline webrtc::PeerConnectionInterface::RTCOfferAnswerOptions toNativeOfferAnswerOptions(const RTCOfferAnswerOptions& options) {
+inline webrtc::PeerConnectionInterface::RTCOfferAnswerOptions
+toNativeOfferAnswerOptions(const RTCOfferAnswerOptions& options) {
   webrtc::PeerConnectionInterface::RTCOfferAnswerOptions rtc_options;
   rtc_options.offer_to_receive_video = options.offer_to_receive_video;
   rtc_options.offer_to_receive_audio = options.offer_to_receive_audio;
@@ -19,177 +21,216 @@ namespace livekit {
   rtc_options.num_simulcast_layers = options.num_simulcast_layers;
   rtc_options.use_obsolete_sctp_sdp = options.use_obsolete_sctp_sdp;
   return rtc_options;
-    }
+}
 
-    PeerConnection::PeerConnection(rtc::scoped_refptr<webrtc::PeerConnectionInterface> peer_connection) : peer_connection_(std::move(peer_connection)) {
+PeerConnection::PeerConnection(
+    rtc::scoped_refptr<webrtc::PeerConnectionInterface> peer_connection)
+    : peer_connection_(std::move(peer_connection)) {}
 
-    }
+void PeerConnection::create_offer(
+    NativeCreateSdpObserverHandle& observer_handle,
+    RTCOfferAnswerOptions options) {
+  peer_connection_->CreateOffer(observer_handle.observer.get(),
+                                toNativeOfferAnswerOptions(options));
+}
 
-    void PeerConnection::create_offer(NativeCreateSdpObserverHandle &observer_handle, RTCOfferAnswerOptions options) {
+void PeerConnection::create_answer(
-        peer_connection_->CreateOffer(observer_handle.observer.get(), toNativeOfferAnswerOptions(options));
+    NativeCreateSdpObserverHandle& observer_handle,
-    }
+    RTCOfferAnswerOptions options) {
+  peer_connection_->CreateAnswer(observer_handle.observer.get(),
+                                 toNativeOfferAnswerOptions(options));
+}
 
-    void PeerConnection::create_answer(NativeCreateSdpObserverHandle &observer_handle, RTCOfferAnswerOptions options) {
+void PeerConnection::set_local_description(
-        peer_connection_->CreateAnswer(observer_handle.observer.get(), toNativeOfferAnswerOptions(options));
+    std::unique_ptr<SessionDescription> desc,
-    }
+    NativeSetLocalSdpObserverHandle& observer) {
+  peer_connection_->SetLocalDescription(desc->clone()->release(),
+                                        observer.observer);
+}
 
-    void PeerConnection::set_local_description(std::unique_ptr<SessionDescription> desc, NativeSetLocalSdpObserverHandle &observer) {
+void PeerConnection::set_remote_description(
-        peer_connection_->SetLocalDescription(desc->clone()->release(), observer.observer);
+    std::unique_ptr<SessionDescription> desc,
-    }
+    NativeSetRemoteSdpObserverHandle& observer) {
+  peer_connection_->SetRemoteDescription(desc->clone()->release(),
+                                         observer.observer);
+}
 
-    void PeerConnection::set_remote_description(std::unique_ptr<SessionDescription> desc, NativeSetRemoteSdpObserverHandle &observer) {
+std::unique_ptr<DataChannel> PeerConnection::create_data_channel(
-        peer_connection_->SetRemoteDescription(desc->clone()->release(), observer.observer);
+    rust::String label,
-    }
+    std::unique_ptr<NativeDataChannelInit> init) {
+  auto result =
+      peer_connection_->CreateDataChannelOrError(label.c_str(), init.get());
 
-    std::unique_ptr<DataChannel> PeerConnection::create_data_channel(rust::String label, std::unique_ptr<NativeDataChannelInit> init) {
+  if (!result.ok()) {
-        auto result = peer_connection_->CreateDataChannelOrError(label.c_str(), init.get());
-
-        if(!result.ok()) {
     throw std::runtime_error(serialize_error(to_error(result.error())));
   }
 
   return std::make_unique<DataChannel>(result.value());
-    }
+}
 
-    void PeerConnection::add_ice_candidate(std::unique_ptr<IceCandidate> candidate, NativeAddIceCandidateObserver &observer){
+void PeerConnection::add_ice_candidate(
-        peer_connection_->AddIceCandidate(candidate->release(), [&](const webrtc::RTCError& err){
+    std::unique_ptr<IceCandidate> candidate,
-            observer.OnComplete(to_error(err));
+    NativeAddIceCandidateObserver& observer) {
-        });
+  peer_connection_->AddIceCandidate(
-    }
+      candidate->release(),
+      [&](const webrtc::RTCError& err) { observer.OnComplete(to_error(err)); });
+}
 
-    void PeerConnection::close() {
+void PeerConnection::close() {
   peer_connection_->Close();
-    }
+}
 
-    // AddIceCandidateObserver
+// AddIceCandidateObserver
 
-    NativeAddIceCandidateObserver::NativeAddIceCandidateObserver(rust::Box<AddIceCandidateObserverWrapper> observer) : observer_(std::move(observer)) {
+NativeAddIceCandidateObserver::NativeAddIceCandidateObserver(
+    rust::Box<AddIceCandidateObserverWrapper> observer)
+    : observer_(std::move(observer)) {}
 
-    }
+void NativeAddIceCandidateObserver::OnComplete(const RTCError& error) {
-
-    void NativeAddIceCandidateObserver::OnComplete(const RTCError &error) {
   observer_->on_complete(error);
-    }
+}
 
-    std::unique_ptr<NativeAddIceCandidateObserver> create_native_add_ice_candidate_observer(rust::Box<AddIceCandidateObserverWrapper> observer) {
+std::unique_ptr<NativeAddIceCandidateObserver>
+create_native_add_ice_candidate_observer(
+    rust::Box<AddIceCandidateObserverWrapper> observer) {
   return std::make_unique<NativeAddIceCandidateObserver>(std::move(observer));
-    }
+}
 
-    // PeerConnectionObserver
+// PeerConnectionObserver
 
-    NativePeerConnectionObserver::NativePeerConnectionObserver(rust::Box<PeerConnectionObserverWrapper> observer) : observer_(std::move(observer)) {
+NativePeerConnectionObserver::NativePeerConnectionObserver(
+    rust::Box<PeerConnectionObserverWrapper> observer)
+    : observer_(std::move(observer)) {}
 
-    }
+void NativePeerConnectionObserver::OnSignalingChange(
-
+    webrtc::PeerConnectionInterface::SignalingState new_state) {
-    void NativePeerConnectionObserver::OnSignalingChange(webrtc::PeerConnectionInterface::SignalingState new_state) {
   observer_->on_signaling_change(static_cast<SignalingState>(new_state));
-    }
+}
 
-    void NativePeerConnectionObserver::OnAddStream(rtc::scoped_refptr<webrtc::MediaStreamInterface> stream) {
+void NativePeerConnectionObserver::OnAddStream(
+    rtc::scoped_refptr<webrtc::MediaStreamInterface> stream) {
   observer_->on_add_stream(std::make_unique<MediaStreamInterface>(stream));
-    }
+}
 
-    void NativePeerConnectionObserver::OnRemoveStream(rtc::scoped_refptr<webrtc::MediaStreamInterface> stream) {
+void NativePeerConnectionObserver::OnRemoveStream(
+    rtc::scoped_refptr<webrtc::MediaStreamInterface> stream) {
   observer_->on_remove_stream(std::make_unique<MediaStreamInterface>(stream));
-    }
+}
 
-    void NativePeerConnectionObserver::OnDataChannel(rtc::scoped_refptr<webrtc::DataChannelInterface> data_channel) {
+void NativePeerConnectionObserver::OnDataChannel(
+    rtc::scoped_refptr<webrtc::DataChannelInterface> data_channel) {
   observer_->on_data_channel(std::make_unique<DataChannel>(data_channel));
-    }
+}
 
-    void NativePeerConnectionObserver::OnRenegotiationNeeded() {
+void NativePeerConnectionObserver::OnRenegotiationNeeded() {
   observer_->on_renegotiation_needed();
-    }
+}
 
-    void NativePeerConnectionObserver::OnNegotiationNeededEvent(uint32_t event_id) {
+void NativePeerConnectionObserver::OnNegotiationNeededEvent(uint32_t event_id) {
   observer_->on_negotiation_needed_event(event_id);
-    }
+}
 
-    void
+void NativePeerConnectionObserver::OnIceConnectionChange(
-    NativePeerConnectionObserver::OnIceConnectionChange(webrtc::PeerConnectionInterface::IceConnectionState new_state) {
-        observer_->on_ice_connection_change(static_cast<IceConnectionState>(new_state));
-    }
-
-    void NativePeerConnectionObserver::OnStandardizedIceConnectionChange(
     webrtc::PeerConnectionInterface::IceConnectionState new_state) {
-        observer_->on_standardized_ice_connection_change(static_cast<IceConnectionState>(new_state));
+  observer_->on_ice_connection_change(
-    }
+      static_cast<IceConnectionState>(new_state));
+}
 
-    void
+void NativePeerConnectionObserver::OnStandardizedIceConnectionChange(
-    NativePeerConnectionObserver::OnConnectionChange(webrtc::PeerConnectionInterface::PeerConnectionState new_state) {
+    webrtc::PeerConnectionInterface::IceConnectionState new_state) {
+  observer_->on_standardized_ice_connection_change(
+      static_cast<IceConnectionState>(new_state));
+}
+
+void NativePeerConnectionObserver::OnConnectionChange(
+    webrtc::PeerConnectionInterface::PeerConnectionState new_state) {
   observer_->on_connection_change(static_cast<PeerConnectionState>(new_state));
-    }
+}
 
-    void
+void NativePeerConnectionObserver::OnIceGatheringChange(
-    NativePeerConnectionObserver::OnIceGatheringChange(webrtc::PeerConnectionInterface::IceGatheringState new_state) {
+    webrtc::PeerConnectionInterface::IceGatheringState new_state) {
   observer_->on_ice_gathering_change(static_cast<IceGatheringState>(new_state));
-    }
+}
 
-    void NativePeerConnectionObserver::OnIceCandidate(const webrtc::IceCandidateInterface *candidate) {
+void NativePeerConnectionObserver::OnIceCandidate(
-        auto new_candidate = webrtc::CreateIceCandidate(candidate->sdp_mid(), candidate->sdp_mline_index(),
+    const webrtc::IceCandidateInterface* candidate) {
+  auto new_candidate = webrtc::CreateIceCandidate(candidate->sdp_mid(),
+                                                  candidate->sdp_mline_index(),
                                                   candidate->candidate());
-        observer_->on_ice_candidate(std::make_unique<IceCandidate>(std::move(new_candidate)));
+  observer_->on_ice_candidate(
-    }
+      std::make_unique<IceCandidate>(std::move(new_candidate)));
+}
 
-    void NativePeerConnectionObserver::OnIceCandidateError(const std::string &address, int port, const std::string &url,
+void NativePeerConnectionObserver::OnIceCandidateError(
-                                                           int error_code, const std::string &error_text) {
+    const std::string& address,
+    int port,
+    const std::string& url,
+    int error_code,
+    const std::string& error_text) {
   observer_->on_ice_candidate_error(address, port, url, error_code, error_text);
-    }
+}
 
-    void NativePeerConnectionObserver::OnIceCandidatesRemoved(const std::vector<cricket::Candidate> &candidates) {
+void NativePeerConnectionObserver::OnIceCandidatesRemoved(
+    const std::vector<cricket::Candidate>& candidates) {
   rust::Vec<CandidatePtr> vec;
 
-        for (const auto &item: candidates) {
+  for (const auto& item : candidates) {
-            vec.push_back(CandidatePtr{
+    vec.push_back(CandidatePtr{std::make_unique<Candidate>(item)});
-                    std::make_unique<Candidate>(item)
-            });
   }
 
   observer_->on_ice_candidates_removed(std::move(vec));
-    }
+}
 
-    void NativePeerConnectionObserver::OnIceConnectionReceivingChange(bool receiving) {
+void NativePeerConnectionObserver::OnIceConnectionReceivingChange(
+    bool receiving) {
   observer_->on_ice_connection_receiving_change(receiving);
-    }
+}
 
-    void
+void NativePeerConnectionObserver::OnIceSelectedCandidatePairChanged(
-    NativePeerConnectionObserver::OnIceSelectedCandidatePairChanged(const cricket::CandidatePairChangeEvent &event) {
+    const cricket::CandidatePairChangeEvent& event) {
   CandidatePairChangeEvent e;
-        e.selected_candidate_pair.local = std::make_unique<Candidate>(event.selected_candidate_pair.local);
+  e.selected_candidate_pair.local =
-        e.selected_candidate_pair.remote = std::make_unique<Candidate>(event.selected_candidate_pair.remote);
+      std::make_unique<Candidate>(event.selected_candidate_pair.local);
+  e.selected_candidate_pair.remote =
+      std::make_unique<Candidate>(event.selected_candidate_pair.remote);
   e.last_data_received_ms = event.last_data_received_ms;
   e.reason = event.reason;
   e.estimated_disconnected_time_ms = event.estimated_disconnected_time_ms;
 
   observer_->on_ice_selected_candidate_pair_changed(std::move(e));
-    }
+}
 
-    void NativePeerConnectionObserver::OnAddTrack(rtc::scoped_refptr<webrtc::RtpReceiverInterface> receiver,
+void NativePeerConnectionObserver::OnAddTrack(
-                                                  const std::vector<rtc::scoped_refptr<webrtc::MediaStreamInterface>> &streams) {
+    rtc::scoped_refptr<webrtc::RtpReceiverInterface> receiver,
+    const std::vector<rtc::scoped_refptr<webrtc::MediaStreamInterface>>&
+        streams) {
   rust::Vec<MediaStreamPtr> vec;
 
-        for (const auto &item: streams) {
+  for (const auto& item : streams) {
-            vec.push_back(MediaStreamPtr{
+    vec.push_back(MediaStreamPtr{std::make_unique<MediaStreamInterface>(item)});
-                    std::make_unique<MediaStreamInterface>(item)
-            });
   }
 
-        observer_->on_add_track(std::make_unique<RtpReceiver>(receiver), std::move(vec));
+  observer_->on_add_track(std::make_unique<RtpReceiver>(receiver),
-    }
+                          std::move(vec));
+}
 
-    void NativePeerConnectionObserver::OnTrack(rtc::scoped_refptr<webrtc::RtpTransceiverInterface> transceiver) {
+void NativePeerConnectionObserver::OnTrack(
+    rtc::scoped_refptr<webrtc::RtpTransceiverInterface> transceiver) {
   observer_->on_track(std::make_unique<RtpTransceiver>(transceiver));
-    }
+}
 
-    void NativePeerConnectionObserver::OnRemoveTrack(rtc::scoped_refptr<webrtc::RtpReceiverInterface> receiver) {
+void NativePeerConnectionObserver::OnRemoveTrack(
+    rtc::scoped_refptr<webrtc::RtpReceiverInterface> receiver) {
   observer_->on_remove_track(std::make_unique<RtpReceiver>(receiver));
-    }
+}
 
-    void NativePeerConnectionObserver::OnInterestingUsage(int usage_pattern) {
+void NativePeerConnectionObserver::OnInterestingUsage(int usage_pattern) {
   observer_->on_interesting_usage(usage_pattern);
-    }
+}
 
-    std::unique_ptr<NativePeerConnectionObserver> create_native_peer_connection_observer(rust::Box<PeerConnectionObserverWrapper> observer) {
+std::unique_ptr<NativePeerConnectionObserver>
+create_native_peer_connection_observer(
+    rust::Box<PeerConnectionObserverWrapper> observer) {
   return std::make_unique<NativePeerConnectionObserver>(std::move(observer));
-    }
+}
-} // livekit
+}  // namespace livekit

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

@@ -1,3 +1,5 @@
+use cxx::UniquePtr;
+
 use crate::candidate::ffi::Candidate;
 use crate::data_channel::ffi::DataChannel;
 use crate::jsep::ffi::IceCandidate;
@@ -5,11 +7,9 @@ use crate::media_stream_interface::ffi::MediaStreamInterface;
 use crate::rtc_error::ffi::RTCError;
 use crate::rtp_receiver::ffi::RtpReceiver;
 use crate::rtp_transceiver::ffi::RtpTransceiver;
-use cxx::UniquePtr;
 
 #[cxx::bridge(namespace = "livekit")]
 pub mod ffi {
-
     struct CandidatePair {
         local: UniquePtr<Candidate>,
         remote: UniquePtr<Candidate>,
@@ -246,6 +246,7 @@ pub mod ffi {
 
 // https://webrtc.github.io/webrtc-org/native-code/native-apis/
 unsafe impl Sync for ffi::PeerConnection {}
+
 unsafe impl Send for ffi::PeerConnection {}
 
 unsafe impl Send for ffi::NativePeerConnectionObserver {}

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

@@ -3,19 +3,20 @@
 //
 
 #include "livekit/peer_connection_factory.h"
-#include "api/video_codecs/builtin_video_decoder_factory.h"
+
 #include "api/audio_codecs/builtin_audio_decoder_factory.h"
 #include "api/audio_codecs/builtin_audio_encoder_factory.h"
-#include "api/video_codecs/builtin_video_encoder_factory.h"
-#include "media/engine/webrtc_media_engine.h"
-#include "api/task_queue/default_task_queue_factory.h"
 #include "api/rtc_event_log/rtc_event_log_factory.h"
+#include "api/task_queue/default_task_queue_factory.h"
+#include "api/video_codecs/builtin_video_decoder_factory.h"
+#include "api/video_codecs/builtin_video_encoder_factory.h"
 #include "libwebrtc-sys/src/peer_connection_factory.rs.h"
 #include "livekit/rtc_error.h"
+#include "media/engine/webrtc_media_engine.h"
 
-namespace livekit{
+namespace livekit {
 
-    PeerConnectionFactory::PeerConnectionFactory(){
+PeerConnectionFactory::PeerConnectionFactory() {
   rtc::LogMessage::LogToDebug(rtc::LS_INFO);
   RTC_LOG(LS_INFO) << "PeerConnectionFactory::PeerConnectionFactory()";
 
@@ -34,7 +35,8 @@ namespace livekit{
   dependencies.worker_thread = worker_thread_.get();
   dependencies.signaling_thread = signaling_thread_.get();
   dependencies.task_queue_factory = webrtc::CreateDefaultTaskQueueFactory();
-        dependencies.event_log_factory = std::make_unique<webrtc::RtcEventLogFactory>(dependencies.task_queue_factory.get());
+  dependencies.event_log_factory = std::make_unique<webrtc::RtcEventLogFactory>(
+      dependencies.task_queue_factory.get());
 
   cricket::MediaEngineDependencies media_deps;
   media_deps.task_queue_factory = dependencies.task_queue_factory.get();
@@ -45,37 +47,43 @@ namespace livekit{
 
   dependencies.media_engine = cricket::CreateMediaEngine(std::move(media_deps));
 
-        peer_factory_ = webrtc::CreateModularPeerConnectionFactory(std::move(dependencies));
+  peer_factory_ =
+      webrtc::CreateModularPeerConnectionFactory(std::move(dependencies));
 
   if (peer_factory_.get() == nullptr) {
     RTC_LOG_ERR(LS_ERROR) << "Failed to create PeerConnectionFactory";
     return;
   }
-    }
+}
 
-    std::unique_ptr<PeerConnection> PeerConnectionFactory::create_peer_connection(std::unique_ptr<webrtc::PeerConnectionInterface::RTCConfiguration> config, NativePeerConnectionObserver &observer) const {
+std::unique_ptr<PeerConnection> PeerConnectionFactory::create_peer_connection(
+    std::unique_ptr<webrtc::PeerConnectionInterface::RTCConfiguration> config,
+    NativePeerConnectionObserver& observer) const {
   webrtc::PeerConnectionDependencies deps{&observer};
-        auto result = peer_factory_->CreatePeerConnectionOrError(*config, std::move(deps));
+  auto result =
+      peer_factory_->CreatePeerConnectionOrError(*config, std::move(deps));
 
-        if(!result.ok()) {
+  if (!result.ok()) {
     throw std::runtime_error(serialize_error(to_error(result.error())));
   }
 
   return std::make_unique<PeerConnection>(result.value());
-    }
+}
 
-    std::unique_ptr<PeerConnectionFactory> create_peer_connection_factory() {
+std::unique_ptr<PeerConnectionFactory> create_peer_connection_factory() {
   return std::make_unique<PeerConnectionFactory>();
-    }
+}
 
-    std::unique_ptr<NativeRTCConfiguration> create_rtc_configuration(RTCConfiguration conf){
+std::unique_ptr<NativeRTCConfiguration> create_rtc_configuration(
-        auto rtc = std::make_unique<webrtc::PeerConnectionInterface::RTCConfiguration>();
+    RTCConfiguration conf) {
-        for (auto &item: conf.ice_servers){
+  auto rtc =
+      std::make_unique<webrtc::PeerConnectionInterface::RTCConfiguration>();
+  for (auto& item : conf.ice_servers) {
     webrtc::PeerConnectionInterface::IceServer ice_server;
     ice_server.username = item.username.c_str();
     ice_server.password = item.password.c_str();
 
-            for (auto &url: item.urls){
+    for (auto& url : item.urls) {
       ice_server.urls.emplace_back(url.c_str());
     }
 
@@ -83,5 +91,5 @@ namespace livekit{
   }
 
   return rtc;
-    }
+}
-} // namespace lk
+}  // namespace livekit

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

@@ -1,25 +1,10 @@
-use crate::candidate::ffi::Candidate;
-use crate::data_channel::ffi::DataChannel;
-use crate::jsep::ffi::IceCandidate;
-use crate::jsep::CreateSdpObserver;
-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;
+use crate::jsep::CreateSdpObserver;
+use crate::peer_connection::PeerConnectionObserver;
 
 #[cxx::bridge(namespace = "livekit")]
 pub mod ffi {
-
     #[derive(Debug, Clone)]
     pub struct ICEServer {
         pub urls: Vec<String>,

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

@@ -3,13 +3,14 @@
 //
 
 #include "livekit/rtc_error.h"
+
 #include <iomanip>
 #include <sstream>
 #include <string>
 
 namespace livekit {
 
-    RTCError to_error(const webrtc::RTCError &error) {
+RTCError to_error(const webrtc::RTCError& error) {
   RTCError lk_error;
   lk_error.error_detail = static_cast<RTCErrorDetailType>(error.error_detail());
   lk_error.error_type = static_cast<RTCErrorType>(error.type());
@@ -17,21 +18,21 @@ namespace livekit {
   lk_error.sctp_cause_code = error.sctp_cause_code().value_or(0);
   lk_error.message = error.message();
   return lk_error;
-    }
+}
 
-    std::string serialize_error(const RTCError &error) {
+std::string serialize_error(const RTCError& error) {
   std::stringstream ss;
   ss << std::hex << std::setfill('0');
-        ss << std::setw(8) << (uint32_t) error.error_type;
+  ss << std::setw(8) << (uint32_t)error.error_type;
-        ss << std::setw(8) << (uint32_t) error.error_detail;
+  ss << std::setw(8) << (uint32_t)error.error_detail;
-        ss << std::setw(2) << (uint16_t) error.has_sctp_cause_code;
+  ss << std::setw(2) << (uint16_t)error.has_sctp_cause_code;
-        ss << std::setw(4) << (uint16_t) error.sctp_cause_code;
+  ss << std::setw(4) << (uint16_t)error.sctp_cause_code;
   ss << std::dec << std::setw(1) << std::string(error.message);
   return ss.str();
-    }
+}
 
 #ifdef LIVEKIT_TEST
-    rust::String serialize_deserialize(){
+rust::String serialize_deserialize() {
   RTCError lk_error;
   lk_error.error_type = RTCErrorType::InternalError;
   lk_error.error_detail = RTCErrorDetailType::DataChannelFailure;
@@ -39,9 +40,9 @@ namespace livekit {
   lk_error.sctp_cause_code = 24;
   lk_error.message = "this is not a test, I repeat, this is not a test";
   return serialize_error(lk_error);
-    }
+}
 
-    void throw_error() {
+void throw_error() {
   RTCError lk_error;
   lk_error.error_type = RTCErrorType::InvalidModification;
   lk_error.error_detail = RTCErrorDetailType::None;
@@ -49,7 +50,7 @@ namespace livekit {
   lk_error.sctp_cause_code = 0;
   lk_error.message = "exception is thrown!";
   throw std::runtime_error(serialize_error(lk_error));
-    }
+}
 #endif
 
-} // livekit
+}  // namespace livekit

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

@@ -6,7 +6,6 @@ use std::fmt::{Display, Formatter};
 
 #[cxx::bridge(namespace = "livekit")]
 pub mod ffi {
-
     #[derive(Debug)]
     #[repr(u32)]
     pub enum RTCErrorType {
@@ -42,7 +41,8 @@ pub mod ffi {
         pub error_type: RTCErrorType,
         pub message: String,
         pub error_detail: RTCErrorDetailType,
-        pub has_sctp_cause_code: bool, // cxx doesn't support the Option trait
+        pub has_sctp_cause_code: bool,
+        // cxx doesn't support the Option trait
         pub sctp_cause_code: u16,
     }
 }

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

@@ -5,7 +5,7 @@
 #include "livekit/rtp_receiver.h"
 
 namespace livekit {
-    RtpReceiver::RtpReceiver(rtc::scoped_refptr<webrtc::RtpReceiverInterface> receiver) : receiver_(std::move(receiver)) {
+RtpReceiver::RtpReceiver(
-
+    rtc::scoped_refptr<webrtc::RtpReceiverInterface> receiver)
-    }
+    : receiver_(std::move(receiver)) {}
-} // livekit
+}  // namespace livekit

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

@@ -5,7 +5,7 @@
 #include "livekit/rtp_transceiver.h"
 
 namespace livekit {
-    RtpTransceiver::RtpTransceiver(rtc::scoped_refptr<webrtc::RtpTransceiverInterface> transceiver) : transceiver_(std::move(transceiver)) {
+RtpTransceiver::RtpTransceiver(
-
+    rtc::scoped_refptr<webrtc::RtpTransceiverInterface> transceiver)
-    }
+    : transceiver_(std::move(transceiver)) {}
-} // livekit
+}  // namespace livekit

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

@@ -3,20 +3,21 @@
 //
 
 #include "livekit/webrtc.h"
+
 #include "rtc_base/logging.h"
 
 namespace livekit {
-    RTCRuntime::RTCRuntime() {
+RTCRuntime::RTCRuntime() {
   RTC_LOG(LS_INFO) << "RTCRuntime()";
   RTC_CHECK(rtc::InitializeSSL()) << "Failed to InitializeSSL()";
-    }
+}
 
-    RTCRuntime::~RTCRuntime() {
+RTCRuntime::~RTCRuntime() {
   RTC_LOG(LS_INFO) << "~RTCRuntime()";
   RTC_CHECK(rtc::CleanupSSL()) << "Failed to CleanupSSL()";
-    }
+}
 
-    std::unique_ptr<RTCRuntime> create_rtc_runtime(){
+std::unique_ptr<RTCRuntime> create_rtc_runtime() {
   return std::make_unique<RTCRuntime>();
-    }
+}
-} // livekit
+}  // namespace livekit

crates/livekit-webrtc/src/data_channel.rs

@@ -1,9 +1,10 @@
-use cxx::UniquePtr;
-use libwebrtc_sys::data_channel as sys_dc;
-use log::trace;
 use std::fmt::{Debug, Formatter};
 use std::sync::{Arc, Mutex};
 
+use cxx::UniquePtr;
+use log::trace;
+
+use libwebrtc_sys::data_channel as sys_dc;
 pub use sys_dc::ffi::Priority;
 
 pub struct DataChannel {
@@ -78,7 +79,8 @@ impl DataChannel {
 }
 
 pub type OnStateChangeHandler = Box<dyn FnMut() + Send + Sync>;
-pub type OnMessageHandler = Box<dyn FnMut(&[u8], bool) + Send + Sync>; // data, is_binary
+pub type OnMessageHandler = Box<dyn FnMut(&[u8], bool) + Send + Sync>;
+// data, is_binary
 pub type OnBufferedAmountChangeHandler = Box<dyn FnMut(u64) + Send + Sync>;
 
 struct InternalDataChannelObserver {

crates/livekit-webrtc/src/jsep.rs

@@ -1,4 +1,5 @@
-use cxx::{SharedPtr, UniquePtr};
+use cxx::UniquePtr;
+
 use libwebrtc_sys::jsep as sys_jsep;
 
 #[derive(Debug)]

crates/livekit-webrtc/src/peer_connection.rs

@@ -1,12 +1,19 @@
+use std::fmt::Debug;
+use std::sync::{Arc, Mutex};
+
 use cxx::UniquePtr;
+use log::trace;
+use thiserror::Error;
+use tokio::sync::mpsc;
+
 use libwebrtc_sys::data_channel as sys_dc;
 use libwebrtc_sys::jsep as sys_jsep;
 use libwebrtc_sys::peer_connection as sys_pc;
-use log::trace;
+pub use libwebrtc_sys::peer_connection::ffi::IceConnectionState;
-use std::fmt::{Debug, Formatter};
+pub use libwebrtc_sys::peer_connection::ffi::IceGatheringState;
-use std::sync::{Arc, Mutex};
+pub use libwebrtc_sys::peer_connection::ffi::PeerConnectionState;
-use thiserror::Error;
+pub use libwebrtc_sys::peer_connection::ffi::RTCOfferAnswerOptions;
-use tokio::sync::{mpsc, oneshot};
+pub use libwebrtc_sys::peer_connection::ffi::SignalingState;
 
 use crate::data_channel::{DataChannel, DataChannelInit};
 use crate::jsep::{IceCandidate, SessionDescription};
@@ -15,12 +22,6 @@ use crate::rtc_error::RTCError;
 use crate::rtp_receiver::RtpReceiver;
 use crate::rtp_transceiver::RtpTransceiver;
 
-pub use libwebrtc_sys::peer_connection::ffi::IceConnectionState;
-pub use libwebrtc_sys::peer_connection::ffi::IceGatheringState;
-pub use libwebrtc_sys::peer_connection::ffi::PeerConnectionState;
-pub use libwebrtc_sys::peer_connection::ffi::RTCOfferAnswerOptions;
-pub use libwebrtc_sys::peer_connection::ffi::SignalingState;
-
 #[derive(Error, Debug)]
 pub enum SdpError {
     #[error("recv failure: {0}")]
@@ -343,16 +344,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>;
@@ -604,12 +605,13 @@ impl sys_pc::PeerConnectionObserver for InternalObserver {
 
 #[cfg(test)]
 mod tests {
+    use log::trace;
+    use tokio::sync::mpsc;
+
     use crate::data_channel::{DataChannel, DataChannelInit};
     use crate::jsep::IceCandidate;
     use crate::peer_connection_factory::{ICEServer, PeerConnectionFactory, RTCConfiguration};
     use crate::webrtc::RTCRuntime;
-    use log::trace;
-    use tokio::sync::mpsc;
 
     fn init_log() {
         let _ = env_logger::builder().is_test(true).try_init();

crates/livekit-webrtc/src/peer_connection_factory.rs

@@ -1,12 +1,12 @@
 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};
 
 use crate::peer_connection::{InternalObserver, PeerConnection};
 use crate::rtc_error::RTCError;
 
-pub use sys_factory::ffi::{ICEServer, RTCConfiguration};
-
 pub struct PeerConnectionFactory {
     cxx_handle: UniquePtr<sys_factory::ffi::PeerConnectionFactory>,
 }

crates/livekit-webrtc/src/rtc_error.rs

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

crates/livekit-webrtc/src/webrtc.rs

@@ -1,4 +1,5 @@
 use cxx::UniquePtr;
+
 use libwebrtc_sys::webrtc as sys_rtc;
 
 pub struct RTCRuntime {