rustfmt & signal_client improvememts

- handle ping message
- recv now only returns on SignalResponse

crates/livekit-webrtc/src/data_channel.rs

@@ -1,12 +1,12 @@
 use std::error::Error;
 use std::fmt::{Debug, Display, 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, DataState};
+pub use sys_dc::ffi::{DataState, Priority};
 
 pub struct DataChannel {
     cxx_handle: UniquePtr<sys_dc::ffi::DataChannel>,
@@ -31,7 +31,7 @@ impl Display for DataSendError {
     }
 }
 
-impl Error for DataSendError { }
+impl Error for DataSendError {}
 
 impl DataChannel {
     pub(crate) fn new(cxx_handle: UniquePtr<sys_dc::ffi::DataChannel>) -> Self {
@@ -100,7 +100,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,8 +1,9 @@
-use std::fmt::{Debug, Display, Formatter, write};
-use cxx::UniquePtr;
-use libwebrtc_sys::jsep as sys_jsep;
+use std::fmt::{Debug, Display, Formatter};
 
-pub use sys_jsep::ffi::{SdpType, SdpParseError};
+use cxx::UniquePtr;
+
+use libwebrtc_sys::jsep as sys_jsep;
+pub use sys_jsep::ffi::{SdpParseError, SdpType};
 
 // TODO Maybe we can replace that by a serialized IceCandidateInit
 pub struct IceCandidate {

crates/livekit-webrtc/src/peer_connection.rs

@@ -363,16 +363,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>;
@@ -387,16 +387,16 @@ pub(crate) struct InternalObserver {
     on_negotiation_needed_event_handler: Arc<Mutex<Option<OnNegotiationNeededEventHandler>>>,
     on_ice_connection_change_handler: Arc<Mutex<Option<OnIceConnectionChangeHandler>>>,
     on_standardized_ice_connection_change_handler:
-        Arc<Mutex<Option<OnStandardizedIceConnectionChangeHandler>>>,
+    Arc<Mutex<Option<OnStandardizedIceConnectionChangeHandler>>>,
     on_connection_change_handler: Arc<Mutex<Option<OnConnectionChangeHandler>>>,
     on_ice_gathering_change_handler: Arc<Mutex<Option<OnIceGatheringChangeHandler>>>,
     on_ice_candidate_handler: Arc<Mutex<Option<OnIceCandidateHandler>>>,
     on_ice_candidate_error_handler: Arc<Mutex<Option<OnIceCandidateErrorHandler>>>,
     on_ice_candidates_removed_handler: Arc<Mutex<Option<OnIceCandidatesRemovedHandler>>>,
     on_ice_connection_receiving_change_handler:
-        Arc<Mutex<Option<OnIceConnectionReceivingChangeHandler>>>,
+    Arc<Mutex<Option<OnIceConnectionReceivingChangeHandler>>>,
     on_ice_selected_candidate_pair_changed_handler:
-        Arc<Mutex<Option<OnIceSelectedCandidatePairChangedHandler>>>,
+    Arc<Mutex<Option<OnIceSelectedCandidatePairChangedHandler>>>,
     on_add_track_handler: Arc<Mutex<Option<OnAddTrackHandler>>>,
     on_track_handler: Arc<Mutex<Option<OnTrackHandler>>>,
     on_remove_track_handler: Arc<Mutex<Option<OnRemoveTrackHandler>>>,
@@ -626,6 +626,7 @@ impl sys_pc::PeerConnectionObserver for InternalObserver {
 mod tests {
     use log::trace;
     use tokio::sync::mpsc;
+
     use libwebrtc_sys::peer_connection::ffi::RTCOfferAnswerOptions;
     use libwebrtc_sys::peer_connection_factory::ffi::{ContinualGatheringPolicy, IceTransportsType};
 
@@ -652,7 +653,7 @@ mod tests {
                 password: "".into(),
             }],
             continual_gathering_policy: ContinualGatheringPolicy::GatherOnce,
-            ice_transport_type: IceTransportsType::All
+            ice_transport_type: IceTransportsType::All,
         };
 
         let mut bob = factory.create_peer_connection(config.clone()).unwrap();

crates/livekit-webrtc/src/rtc_error.rs

@@ -1,2 +1,3 @@
 // 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,4 @@
-use cxx::{SharedPtr};
+use cxx::SharedPtr;
 
 use libwebrtc_sys::webrtc as sys_rtc;