From f643f458f8884aeec49ec98eeae2d708be1965fa Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Th=C3=A9o=20Monnom?= Date: Wed, 14 Sep 2022 21:33:34 +0200 Subject: [PATCH] test #1 --- crates/livekit-core/src/rtc_engine.rs | 1 - crates/livekit-webrtc/libwebrtc-sys/build.rs | 12 +- .../libwebrtc-sys/include/livekit/jsep.h | 6 +- .../libwebrtc-sys/src/candidate.rs | 2 +- .../livekit-webrtc/libwebrtc-sys/src/jsep.cpp | 6 + .../livekit-webrtc/libwebrtc-sys/src/jsep.rs | 48 ++- .../livekit-webrtc/libwebrtc-sys/src/lib.rs | 9 +- .../src/media_stream_interface.rs | 1 - .../libwebrtc-sys/src/peer_connection.rs | 207 ++++++++---- .../src/peer_connection_factory.cpp | 2 +- .../src/peer_connection_factory.rs | 37 +-- .../libwebrtc-sys/src/rtc_error.rs | 32 +- crates/livekit-webrtc/src/data_channel.rs | 6 +- crates/livekit-webrtc/src/ice_candidate.rs | 4 - crates/livekit-webrtc/src/jsep.rs | 24 ++ crates/livekit-webrtc/src/lib.rs | 9 +- crates/livekit-webrtc/src/media_stream.rs | 3 +- crates/livekit-webrtc/src/peer_connection.rs | 303 +++++++++++++----- .../src/peer_connection_factory.rs | 44 +-- crates/livekit-webrtc/src/rtc_error.rs | 2 +- crates/livekit-webrtc/src/rtp_receiver.rs | 4 +- crates/livekit-webrtc/src/rtp_transceiver.rs | 4 +- .../livekit-webrtc/src/session_description.rs | 5 - 23 files changed, 519 insertions(+), 252 deletions(-) delete mode 100644 crates/livekit-webrtc/src/ice_candidate.rs create mode 100644 crates/livekit-webrtc/src/jsep.rs delete mode 100644 crates/livekit-webrtc/src/session_description.rs diff --git a/crates/livekit-core/src/rtc_engine.rs b/crates/livekit-core/src/rtc_engine.rs index 0354acb..fa61959 100644 --- a/crates/livekit-core/src/rtc_engine.rs +++ b/crates/livekit-core/src/rtc_engine.rs @@ -24,7 +24,6 @@ impl RTCEngine { Ok(()) } - pub fn update(&self) {} async fn handle_rtc(mut signal_receiver: broadcast::Receiver) { diff --git a/crates/livekit-webrtc/libwebrtc-sys/build.rs b/crates/livekit-webrtc/libwebrtc-sys/build.rs index f02d219..536833e 100644 --- a/crates/livekit-webrtc/libwebrtc-sys/build.rs +++ b/crates/livekit-webrtc/libwebrtc-sys/build.rs @@ -1,9 +1,9 @@ +use regex::Regex; use std::env; use std::fs; use std::io::Write; use std::path; use std::process::Command; -use regex::Regex; const MAC_SDKS: &str = "/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs"; @@ -241,16 +241,10 @@ fn main() { builder.warnings(false).compile("lkwebrtc"); for entry in glob::glob("./src/**/*.cpp").unwrap() { - println!( - "cargo:rerun-if-changed={}", - entry.unwrap().display() - ); + println!("cargo:rerun-if-changed={}", entry.unwrap().display()); } for entry in glob::glob("./include/**/*.h").unwrap() { - println!( - "cargo:rerun-if-changed={}", - entry.unwrap().display() - ); + println!("cargo:rerun-if-changed={}", entry.unwrap().display()); } } diff --git a/crates/livekit-webrtc/libwebrtc-sys/include/livekit/jsep.h b/crates/livekit-webrtc/libwebrtc-sys/include/livekit/jsep.h index a7ffab3..bc08972 100644 --- a/crates/livekit-webrtc/libwebrtc-sys/include/livekit/jsep.h +++ b/crates/livekit-webrtc/libwebrtc-sys/include/livekit/jsep.h @@ -16,7 +16,6 @@ namespace livekit { class IceCandidate { public: explicit IceCandidate(std::unique_ptr ice_candidate); - private: std::unique_ptr ice_candidate_; }; @@ -29,6 +28,7 @@ namespace livekit { public: explicit SessionDescription(std::unique_ptr session_description); + rust::String stringify() const; std::unique_ptr clone() const; std::unique_ptr release(); @@ -40,6 +40,10 @@ namespace livekit { return nullptr; // Ignore } + static std::shared_ptr _shared_session_description(){ + return nullptr; // Ignore + } + // SetCreateSdpObserver class NativeCreateSdpObserver : public webrtc::CreateSessionDescriptionObserver { diff --git a/crates/livekit-webrtc/libwebrtc-sys/src/candidate.rs b/crates/livekit-webrtc/libwebrtc-sys/src/candidate.rs index daa49c5..8e442b8 100644 --- a/crates/livekit-webrtc/libwebrtc-sys/src/candidate.rs +++ b/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; // Ignore } } diff --git a/crates/livekit-webrtc/libwebrtc-sys/src/jsep.cpp b/crates/livekit-webrtc/libwebrtc-sys/src/jsep.cpp index 06e80b3..4617325 100644 --- a/crates/livekit-webrtc/libwebrtc-sys/src/jsep.cpp +++ b/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::clone() const { return std::make_unique(session_description_->Clone()); } diff --git a/crates/livekit-webrtc/libwebrtc-sys/src/jsep.rs b/crates/livekit-webrtc/libwebrtc-sys/src/jsep.rs index 0b80e47..fc8299a 100644 --- a/crates/livekit-webrtc/libwebrtc-sys/src/jsep.rs +++ b/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); + fn on_success( + self: &CreateSdpObserverWrapper, + session_description: UniquePtr, + ); 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) -> UniquePtr; - fn create_native_set_local_sdp_observer(observer: Box) -> UniquePtr; - fn create_native_set_remote_sdp_observer(observer: Box) -> UniquePtr; + fn stringify(self: &SessionDescription) -> String; + + fn create_native_create_sdp_observer( + observer: Box, + ) -> UniquePtr; + fn create_native_set_local_sdp_observer( + observer: Box, + ) -> UniquePtr; + fn create_native_set_remote_sdp_observer( + observer: Box, + ) -> UniquePtr; fn _unique_ice_candidate() -> UniquePtr; // Ignore + fn _shared_session_description() -> SharedPtr; // Ignore fn _unique_session_description() -> UniquePtr; // 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); fn on_failure(&self, error: RTCError); } @@ -51,9 +71,7 @@ pub struct CreateSdpObserverWrapper { impl CreateSdpObserverWrapper { pub fn new(observer: Box) -> Self { - Self { - observer - } + Self { observer } } fn on_success(&self, session_description: UniquePtr) { @@ -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) -> 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) -> Self { - Self { - observer - } + Self { observer } } fn on_set_remote_description_complete(&self, error: RTCError) { diff --git a/crates/livekit-webrtc/libwebrtc-sys/src/lib.rs b/crates/livekit-webrtc/libwebrtc-sys/src/lib.rs index 19ff3ad..db03eaa 100644 --- a/crates/livekit-webrtc/libwebrtc-sys/src/lib.rs +++ b/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; - diff --git a/crates/livekit-webrtc/libwebrtc-sys/src/media_stream_interface.rs b/crates/livekit-webrtc/libwebrtc-sys/src/media_stream_interface.rs index 7242ba7..5ae33c8 100644 --- a/crates/livekit-webrtc/libwebrtc-sys/src/media_stream_interface.rs +++ b/crates/livekit-webrtc/libwebrtc-sys/src/media_stream_interface.rs @@ -9,5 +9,4 @@ pub mod ffi { fn _unique_media_stream() -> UniquePtr; // Ignore } - } diff --git a/crates/livekit-webrtc/libwebrtc-sys/src/peer_connection.rs b/crates/livekit-webrtc/libwebrtc-sys/src/peer_connection.rs index fbfac94..d028187 100644 --- a/crates/livekit-webrtc/libwebrtc-sys/src/peer_connection.rs +++ b/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 + pub ptr: UniquePtr, } - struct CandidatePtr { - pub ptr: UniquePtr + struct CandidatePtr { + pub ptr: UniquePtr, } unsafe extern "C++" { @@ -109,13 +111,31 @@ pub mod ffi { type NativePeerConnectionObserver; type PeerConnection; - fn create_offer(self: Pin<&mut PeerConnection>, observer: UniquePtr, options: RTCOfferAnswerOptions); - fn create_answer(self: Pin<&mut PeerConnection>, observer: UniquePtr, options: RTCOfferAnswerOptions); - fn set_local_description(self: Pin<&mut PeerConnection>, desc: UniquePtr, observer: UniquePtr); - fn set_remote_description(self: Pin<&mut PeerConnection>, desc: UniquePtr, observer: UniquePtr); + fn create_offer( + self: Pin<&mut PeerConnection>, + observer: UniquePtr, + options: RTCOfferAnswerOptions, + ); + fn create_answer( + self: Pin<&mut PeerConnection>, + observer: UniquePtr, + options: RTCOfferAnswerOptions, + ); + fn set_local_description( + self: Pin<&mut PeerConnection>, + desc: UniquePtr, + observer: UniquePtr, + ); + fn set_remote_description( + self: Pin<&mut PeerConnection>, + desc: UniquePtr, + observer: UniquePtr, + ); fn close(self: Pin<&mut PeerConnection>); - fn create_native_peer_connection_observer(observer: Box) -> UniquePtr; + fn create_native_peer_connection_observer( + observer: Box, + ) -> UniquePtr; fn _unique_peer_connection() -> UniquePtr; // 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); - fn on_remove_stream(self: &mut PeerConnectionObserverWrapper, stream: UniquePtr); - fn on_data_channel(self: &mut PeerConnectionObserverWrapper, data_channel: UniquePtr); + fn on_add_stream( + self: &mut PeerConnectionObserverWrapper, + stream: UniquePtr, + ); + fn on_remove_stream( + self: &mut PeerConnectionObserverWrapper, + stream: UniquePtr, + ); + fn on_data_channel( + self: &mut PeerConnectionObserverWrapper, + data_channel: UniquePtr, + ); 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); - 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); - 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, streams: Vec); - fn on_track(self: &mut PeerConnectionObserverWrapper, transceiver: UniquePtr); - fn on_remove_track(self: &mut PeerConnectionObserverWrapper, receiver: UniquePtr); + 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, + ); + 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, + ); + 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, + streams: Vec, + ); + fn on_track( + self: &mut PeerConnectionObserverWrapper, + transceiver: UniquePtr, + ); + fn on_remove_track( + self: &mut PeerConnectionObserverWrapper, + receiver: UniquePtr, + ); 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); - 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>); 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, streams: Vec>); + fn on_add_track( + &mut self, + receiver: UniquePtr, + streams: Vec>, + ); fn on_track(&mut self, transceiver: UniquePtr); fn on_remove_track(&mut self, receiver: UniquePtr); fn on_interesting_usage(&mut self, usage_pattern: i32); } pub struct PeerConnectionObserverWrapper { - observer: Box, + observer: Rc>, } impl PeerConnectionObserverWrapper { - pub fn new(observer: Box) -> Self { - Self { - observer - } + pub fn new(observer: Rc>) -> 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) { - self.observer.on_add_stream(stream); + self.observer.borrow_mut().on_add_stream(stream); } fn on_remove_stream(&mut self, stream: UniquePtr) { - self.observer.on_remove_stream(stream); + self.observer.borrow_mut().on_remove_stream(stream); } fn on_data_channel(&mut self, data_channel: UniquePtr) { - 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) { - 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) { @@ -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, streams: Vec) { + fn on_add_track( + &mut self, + receiver: UniquePtr, + streams: Vec, + ) { 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) { - self.observer.on_track(transceiver); + self.observer.borrow_mut().on_track(transceiver); } fn on_remove_track(&mut self, receiver: UniquePtr) { - 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); } } diff --git a/crates/livekit-webrtc/libwebrtc-sys/src/peer_connection_factory.cpp b/crates/livekit-webrtc/libwebrtc-sys/src/peer_connection_factory.cpp index 94eba75..a3eacd0 100644 --- a/crates/livekit-webrtc/libwebrtc-sys/src/peer_connection_factory.cpp +++ b/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); diff --git a/crates/livekit-webrtc/libwebrtc-sys/src/peer_connection_factory.rs b/crates/livekit-webrtc/libwebrtc-sys/src/peer_connection_factory.rs index 0c4e2a1..290ac3a 100644 --- a/crates/livekit-webrtc/libwebrtc-sys/src/peer_connection_factory.rs +++ b/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; fn create_rtc_configuration(conf: RTCConfiguration) -> UniquePtr; - unsafe fn create_peer_connection(self: &PeerConnectionFactory, config: UniquePtr, observer: UniquePtr) -> Result>; + fn create_peer_connection( + self: &PeerConnectionFactory, + config: UniquePtr, + observer: UniquePtr, + ) -> Result>; } - } - - - - - - +} /* @@ -183,4 +185,3 @@ mod test { } */ - diff --git a/crates/livekit-webrtc/libwebrtc-sys/src/rtc_error.rs b/crates/livekit-webrtc/libwebrtc-sys/src/rtc_error.rs index 68623bb..8ac3bc0 100644 --- a/crates/livekit-webrtc/libwebrtc-sys/src/rtc_error.rs +++ b/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!"); } -} \ No newline at end of file +} diff --git a/crates/livekit-webrtc/src/data_channel.rs b/crates/livekit-webrtc/src/data_channel.rs index bd017b3..93fcf85 100644 --- a/crates/livekit-webrtc/src/data_channel.rs +++ b/crates/livekit-webrtc/src/data_channel.rs @@ -1,6 +1,4 @@ - - +#[derive(Debug)] pub struct DataChannel { - -} \ No newline at end of file +} diff --git a/crates/livekit-webrtc/src/ice_candidate.rs b/crates/livekit-webrtc/src/ice_candidate.rs deleted file mode 100644 index f9c307c..0000000 --- a/crates/livekit-webrtc/src/ice_candidate.rs +++ /dev/null @@ -1,4 +0,0 @@ - -pub struct IceCandidate { - -} \ No newline at end of file diff --git a/crates/livekit-webrtc/src/jsep.rs b/crates/livekit-webrtc/src/jsep.rs new file mode 100644 index 0000000..3c2c460 --- /dev/null +++ b/crates/livekit-webrtc/src/jsep.rs @@ -0,0 +1,24 @@ +use cxx::{SharedPtr, UniquePtr}; +use libwebrtc_sys::jsep as sys_jsep; + +#[derive(Debug)] +pub struct IceCandidate { + +} + +#[derive(Debug)] +pub struct SessionDescription { + cxx_handle: UniquePtr +} + +impl SessionDescription { + pub(crate) fn new(cxx_handle: UniquePtr) -> Self { + Self { + cxx_handle + } + } + + pub(crate) fn release(self) -> UniquePtr{ + self.cxx_handle + } +} \ No newline at end of file diff --git a/crates/livekit-webrtc/src/lib.rs b/crates/livekit-webrtc/src/lib.rs index 8ff3aaf..e99192a 100644 --- a/crates/livekit-webrtc/src/lib.rs +++ b/crates/livekit-webrtc/src/lib.rs @@ -1,9 +1,8 @@ -pub mod peer_connection_factory; -pub mod peer_connection; -pub mod rtc_error; pub mod data_channel; pub mod media_stream; +pub mod peer_connection; +pub mod peer_connection_factory; +pub mod rtc_error; pub mod rtp_receiver; pub mod rtp_transceiver; -pub mod ice_candidate; -pub mod session_description; \ No newline at end of file +pub mod jsep; diff --git a/crates/livekit-webrtc/src/media_stream.rs b/crates/livekit-webrtc/src/media_stream.rs index f4adade..4f62fac 100644 --- a/crates/livekit-webrtc/src/media_stream.rs +++ b/crates/livekit-webrtc/src/media_stream.rs @@ -1,4 +1,5 @@ +#[derive(Debug)] pub struct MediaStream { -} \ No newline at end of file +} diff --git a/crates/livekit-webrtc/src/peer_connection.rs b/crates/livekit-webrtc/src/peer_connection.rs index 580ac93..fee7c0a 100644 --- a/crates/livekit-webrtc/src/peer_connection.rs +++ b/crates/livekit-webrtc/src/peer_connection.rs @@ -1,23 +1,22 @@ -use std::sync::{Arc, Mutex}; use cxx::UniquePtr; -use tokio::sync::{mpsc, oneshot}; -use libwebrtc_sys::peer_connection as sys_pc; use libwebrtc_sys::jsep as sys_jsep; +use libwebrtc_sys::peer_connection as sys_pc; +use std::sync::{Arc, Mutex}; use thiserror::Error; +use tokio::sync::{mpsc, oneshot}; use crate::data_channel::DataChannel; use crate::media_stream::MediaStream; -use crate::ice_candidate::IceCandidate; +use crate::rtc_error::RTCError; use crate::rtp_receiver::RtpReceiver; use crate::rtp_transceiver::RtpTransceiver; -use crate::session_description::SessionDescription; -use crate::rtc_error::RTCError; +use crate::jsep::{SessionDescription, IceCandidate}; -pub use libwebrtc_sys::peer_connection::ffi::PeerConnectionState; -pub use libwebrtc_sys::peer_connection::ffi::SignalingState; 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 { @@ -29,44 +28,27 @@ pub enum SdpError { pub struct PeerConnection { cxx_handle: UniquePtr, - observer: InternalObserver + observer: InternalObserver, } impl PeerConnection { - pub fn new(cxx_handle: UniquePtr) -> Self { + pub(crate) fn new(cxx_handle: UniquePtr) -> Self { Self { cxx_handle, - observer: InternalObserver { - on_signaling_change_handler: Arc::new(Default::default()), - on_add_stream_handler: Arc::new(Default::default()), - on_remove_stream_handler: Arc::new(Default::default()), - on_data_channel_handler: Arc::new(Default::default()), - on_renegotiation_needed_handler: Arc::new(Default::default()), - on_negotiation_needed_event_handler: Arc::new(Default::default()), - on_ice_connection_change_handler: Arc::new(Default::default()), - on_standardized_ice_connection_change_handler: Arc::new(Default::default()), - on_connection_change_handler: Arc::new(Default::default()), - on_ice_gathering_change_handler: Arc::new(Default::default()), - on_ice_candidate_handler: Arc::new(Default::default()), - on_ice_candidate_error_handler: Arc::new(Default::default()), - on_ice_candidates_removed_handler: Arc::new(Default::default()), - on_ice_connection_receiving_change_handler: Arc::new(Default::default()), - on_ice_selected_candidate_pair_changed_handler: Arc::new(Default::default()), - on_add_track_handler: Arc::new(Default::default()), - on_track_handler: Arc::new(Default::default()), - on_remove_track_handler: Arc::new(Default::default()), - on_interesting_usage_handler: Arc::new(Default::default()) - } + observer: InternalObserver::default() } } pub async fn create_offer(&mut self) -> Result { let (tx, mut rx) = mpsc::channel(1); - let wrapper = sys_jsep::CreateSdpObserverWrapper::new(Box::new(InternalCreateSdpObserver { tx })); + let wrapper = + sys_jsep::CreateSdpObserverWrapper::new(Box::new(InternalCreateSdpObserver { tx })); let native_wrapper = sys_jsep::ffi::create_native_create_sdp_observer(Box::new(wrapper)); - self.cxx_handle.pin_mut().create_offer(native_wrapper, RTCOfferAnswerOptions::default()); + self.cxx_handle + .pin_mut() + .create_offer(native_wrapper, RTCOfferAnswerOptions::default()); match rx.recv().await { Some(value) => value.map_err(Into::into), @@ -77,10 +59,13 @@ impl PeerConnection { pub async fn create_answer(&mut self) -> Result { let (tx, mut rx) = mpsc::channel(1); - let wrapper = sys_jsep::CreateSdpObserverWrapper::new(Box::new(InternalCreateSdpObserver { tx })); + let wrapper = + sys_jsep::CreateSdpObserverWrapper::new(Box::new(InternalCreateSdpObserver { tx })); let native_wrapper = sys_jsep::ffi::create_native_create_sdp_observer(Box::new(wrapper)); - self.cxx_handle.pin_mut().create_answer(native_wrapper, RTCOfferAnswerOptions::default()); + self.cxx_handle + .pin_mut() + .create_answer(native_wrapper, RTCOfferAnswerOptions::default()); match rx.recv().await { Some(value) => value.map_err(Into::into), @@ -88,15 +73,42 @@ impl PeerConnection { } } - pub async fn set_local_description(&mut self, desc: SessionDescription) -> Result<(), SdpError> { + pub async fn set_local_description( + &mut self, + desc: SessionDescription, + ) -> Result<(), SdpError> { + let (tx, mut rx) = mpsc::channel(1); + let wrapper = + sys_jsep::SetLocalSdpObserverWrapper::new(Box::new(InternalSetLocalSdpObserver { tx })); + let native_wrapper = sys_jsep::ffi::create_native_set_local_sdp_observer(Box::new(wrapper)); + self.cxx_handle + .pin_mut() + .set_local_description(desc.release(), native_wrapper); - Ok(()) + match rx.recv().await { + Some(value) => value.map_err(Into::into), + None => Err(SdpError::RecvError("channel closed".to_string())), + } } - pub async fn set_remote_description(&mut self, desc: SessionDescription) -> Result<(), SdpError> { + pub async fn set_remote_description( + &mut self, + desc: SessionDescription, + ) -> Result<(), SdpError> { + let (tx, mut rx) = mpsc::channel(1); + let wrapper = + sys_jsep::SetRemoteSdpObserverWrapper::new(Box::new(InternalSetRemoteSdpObserver { tx })); + let native_wrapper = sys_jsep::ffi::create_native_set_remote_sdp_observer(Box::new(wrapper)); - Ok(()) + self.cxx_handle + .pin_mut() + .set_remote_description(desc.release(), native_wrapper); + + match rx.recv().await { + Some(value) => value.map_err(Into::into), + None => Err(SdpError::RecvError("channel closed".to_string())), + } } pub fn on_signaling_change(&mut self, handler: OnSignalingChangeHandler) { @@ -116,15 +128,30 @@ impl PeerConnection { } pub fn on_renegotiation_needed(&mut self, handler: OnRenegotiationNeededHandler) { - *self.observer.on_renegotiation_needed_handler.lock().unwrap() = Some(handler); + *self + .observer + .on_renegotiation_needed_handler + .lock() + .unwrap() = Some(handler); } pub fn on_ice_connection_change(&mut self, handler: OnIceConnectionChangeHandler) { - *self.observer.on_ice_connection_change_handler.lock().unwrap() = Some(handler); + *self + .observer + .on_ice_connection_change_handler + .lock() + .unwrap() = Some(handler); } - pub fn on_standardized_ice_connection_change(&mut self, handler: OnStandardizedIceConnectionChangeHandler) { - *self.observer.on_standardized_ice_connection_change_handler.lock().unwrap() = Some(handler); + pub fn on_standardized_ice_connection_change( + &mut self, + handler: OnStandardizedIceConnectionChangeHandler, + ) { + *self + .observer + .on_standardized_ice_connection_change_handler + .lock() + .unwrap() = Some(handler); } pub fn on_connection_change(&mut self, handler: OnConnectionChangeHandler) { @@ -132,7 +159,11 @@ impl PeerConnection { } pub fn on_ice_gathering_change(&mut self, handler: OnIceGatheringChangeHandler) { - *self.observer.on_ice_gathering_change_handler.lock().unwrap() = Some(handler); + *self + .observer + .on_ice_gathering_change_handler + .lock() + .unwrap() = Some(handler); } pub fn on_ice_candidate(&mut self, handler: OnIceCandidateHandler) { @@ -144,15 +175,33 @@ impl PeerConnection { } pub fn on_ice_candidates_removed(&mut self, handler: OnIceCandidatesRemovedHandler) { - *self.observer.on_ice_candidates_removed_handler.lock().unwrap() = Some(handler); + *self + .observer + .on_ice_candidates_removed_handler + .lock() + .unwrap() = Some(handler); } - pub fn on_ice_connection_receiving_change(&mut self, handler: OnIceConnectionReceivingChangeHandler) { - *self.observer.on_ice_connection_receiving_change_handler.lock().unwrap() = Some(handler); + pub fn on_ice_connection_receiving_change( + &mut self, + handler: OnIceConnectionReceivingChangeHandler, + ) { + *self + .observer + .on_ice_connection_receiving_change_handler + .lock() + .unwrap() = Some(handler); } - pub fn on_ice_selected_candidate_pair_changed(&mut self, handler: OnIceSelectedCandidatePairChangedHandler) { - *self.observer.on_ice_selected_candidate_pair_changed_handler.lock().unwrap() = Some(handler); + pub fn on_ice_selected_candidate_pair_changed( + &mut self, + handler: OnIceSelectedCandidatePairChangedHandler, + ) { + *self + .observer + .on_ice_selected_candidate_pair_changed_handler + .lock() + .unwrap() = Some(handler); } pub fn on_add_track(&mut self, handler: OnAddTrackHandler) { @@ -175,44 +224,48 @@ impl PeerConnection { // CreateSdpObserver struct InternalCreateSdpObserver { - tx: mpsc::Sender> + tx: mpsc::Sender>, } impl sys_jsep::CreateSdpObserver for InternalCreateSdpObserver { - fn on_success(&self, session_description: UniquePtr) { - self.tx.blocking_send(Ok(SessionDescription{})).unwrap(); // TODO + fn on_success( + &self, + session_description: UniquePtr, + ) { + self.tx.blocking_send(Ok(SessionDescription::new(session_description))).unwrap(); } fn on_failure(&self, error: RTCError) { - self.tx.blocking_send(Err(error)).unwrap(); // TODO + self.tx.blocking_send(Err(error)).unwrap(); } } // SetLocalSdpObserver struct InternalSetLocalSdpObserver { - tx: mpsc::Sender> + tx: mpsc::Sender>, } impl sys_jsep::SetLocalSdpObserver for InternalSetLocalSdpObserver { fn on_set_local_description_complete(&self, error: RTCError) { - self.tx.blocking_send(Ok(())).unwrap(); + let res = if error.ok() { Ok(()) } else { Err(error) }; + self.tx.blocking_send(res).unwrap(); } } // SetRemoteSdpObserver struct InternalSetRemoteSdpObserver { - + tx: mpsc::Sender>, } impl sys_jsep::SetRemoteSdpObserver for InternalSetRemoteSdpObserver { fn on_set_remote_description_complete(&self, error: RTCError) { - todo!() + let res = if error.ok() { Ok(()) } else { Err(error) }; + self.tx.blocking_send(res).unwrap(); } } - // PeerConnectionObserver // TODO(theomonnom) Should we return futures? @@ -223,20 +276,23 @@ pub type OnDataChannelHandler = Box; pub type OnRenegotiationNeededHandler = Box; pub type OnNegotiationNeededEventHandler = Box; pub type OnIceConnectionChangeHandler = Box; -pub type OnStandardizedIceConnectionChangeHandler = Box; +pub type OnStandardizedIceConnectionChangeHandler = + Box; pub type OnConnectionChangeHandler = Box; pub type OnIceGatheringChangeHandler = Box; pub type OnIceCandidateHandler = Box; -pub type OnIceCandidateErrorHandler = Box; +pub type OnIceCandidateErrorHandler = + Box; pub type OnIceCandidatesRemovedHandler = Box) + Send + Sync>; pub type OnIceConnectionReceivingChangeHandler = Box; -pub type OnIceSelectedCandidatePairChangedHandler = Box; +pub type OnIceSelectedCandidatePairChangedHandler = + Box; pub type OnAddTrackHandler = Box) + Send + Sync>; pub type OnTrackHandler = Box; pub type OnRemoveTrackHandler = Box; pub type OnInterestingUsageHandler = Box; -struct InternalObserver { +pub(crate) struct InternalObserver { on_signaling_change_handler: Arc>>, on_add_stream_handler: Arc>>, on_remove_stream_handler: Arc>>, @@ -244,18 +300,47 @@ struct InternalObserver { on_renegotiation_needed_handler: Arc>>, on_negotiation_needed_event_handler: Arc>>, on_ice_connection_change_handler: Arc>>, - on_standardized_ice_connection_change_handler: Arc>>, + on_standardized_ice_connection_change_handler: + Arc>>, on_connection_change_handler: Arc>>, on_ice_gathering_change_handler: Arc>>, on_ice_candidate_handler: Arc>>, on_ice_candidate_error_handler: Arc>>, on_ice_candidates_removed_handler: Arc>>, - on_ice_connection_receiving_change_handler: Arc>>, - on_ice_selected_candidate_pair_changed_handler: Arc>>, + on_ice_connection_receiving_change_handler: + Arc>>, + on_ice_selected_candidate_pair_changed_handler: + Arc>>, on_add_track_handler: Arc>>, on_track_handler: Arc>>, on_remove_track_handler: Arc>>, - on_interesting_usage_handler: Arc>> + on_interesting_usage_handler: Arc>>, +} + +impl Default for InternalObserver { + fn default() -> Self { + Self { + on_signaling_change_handler: Arc::new(Default::default()), + on_add_stream_handler: Arc::new(Default::default()), + on_remove_stream_handler: Arc::new(Default::default()), + on_data_channel_handler: Arc::new(Default::default()), + on_renegotiation_needed_handler: Arc::new(Default::default()), + on_negotiation_needed_event_handler: Arc::new(Default::default()), + on_ice_connection_change_handler: Arc::new(Default::default()), + on_standardized_ice_connection_change_handler: Arc::new(Default::default()), + on_connection_change_handler: Arc::new(Default::default()), + on_ice_gathering_change_handler: Arc::new(Default::default()), + on_ice_candidate_handler: Arc::new(Default::default()), + on_ice_candidate_error_handler: Arc::new(Default::default()), + on_ice_candidates_removed_handler: Arc::new(Default::default()), + on_ice_connection_receiving_change_handler: Arc::new(Default::default()), + on_ice_selected_candidate_pair_changed_handler: Arc::new(Default::default()), + on_add_track_handler: Arc::new(Default::default()), + on_track_handler: Arc::new(Default::default()), + on_remove_track_handler: Arc::new(Default::default()), + on_interesting_usage_handler: Arc::new(Default::default()), + } + } } // Observers are being called on the Signaling Thread @@ -267,21 +352,30 @@ impl sys_pc::PeerConnectionObserver for InternalObserver { } } - fn on_add_stream(&mut self, stream: UniquePtr) { + fn on_add_stream( + &mut self, + stream: UniquePtr, + ) { let mut handler = self.on_add_stream_handler.lock().unwrap(); if let Some(f) = handler.as_mut() { // TODO(theomonnom) } } - fn on_remove_stream(&mut self, stream: UniquePtr) { + fn on_remove_stream( + &mut self, + stream: UniquePtr, + ) { let mut handler = self.on_remove_stream_handler.lock().unwrap(); if let Some(f) = handler.as_mut() { // TODO(theomonnom) } } - fn on_data_channel(&mut self, data_channel: UniquePtr) { + fn on_data_channel( + &mut self, + data_channel: UniquePtr, + ) { let mut handler = self.on_data_channel_handler.lock().unwrap(); if let Some(f) = handler.as_mut() { // TODO(theomonnom) @@ -310,7 +404,10 @@ impl sys_pc::PeerConnectionObserver for InternalObserver { } fn on_standardized_ice_connection_change(&mut self, new_state: IceConnectionState) { - let mut handler = self.on_standardized_ice_connection_change_handler.lock().unwrap(); + let mut handler = self + .on_standardized_ice_connection_change_handler + .lock() + .unwrap(); if let Some(f) = handler.as_mut() { f(new_state); } @@ -337,14 +434,24 @@ impl sys_pc::PeerConnectionObserver for InternalObserver { } } - 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, + ) { let mut handler = self.on_ice_candidate_error_handler.lock().unwrap(); if let Some(f) = handler.as_mut() { f(address, port, url, error_code, error_text); } } - fn on_ice_candidates_removed(&mut self, removed: Vec>) { + fn on_ice_candidates_removed( + &mut self, + removed: Vec>, + ) { let mut handler = self.on_ice_candidates_removed_handler.lock().unwrap(); if let Some(f) = handler.as_mut() { // TODO(theomonnom) @@ -352,34 +459,53 @@ impl sys_pc::PeerConnectionObserver for InternalObserver { } fn on_ice_connection_receiving_change(&mut self, receiving: bool) { - let mut handler = self.on_ice_connection_receiving_change_handler.lock().unwrap(); + let mut handler = self + .on_ice_connection_receiving_change_handler + .lock() + .unwrap(); if let Some(f) = handler.as_mut() { f(receiving); } } - fn on_ice_selected_candidate_pair_changed(&mut self, event: libwebrtc_sys::peer_connection::ffi::CandidatePairChangeEvent) { - let mut handler = self.on_ice_selected_candidate_pair_changed_handler.lock().unwrap(); + fn on_ice_selected_candidate_pair_changed( + &mut self, + event: libwebrtc_sys::peer_connection::ffi::CandidatePairChangeEvent, + ) { + let mut handler = self + .on_ice_selected_candidate_pair_changed_handler + .lock() + .unwrap(); if let Some(f) = handler.as_mut() { f(event); } } - fn on_add_track(&mut self, receiver: UniquePtr, streams: Vec>) { + fn on_add_track( + &mut self, + receiver: UniquePtr, + streams: Vec>, + ) { let mut handler = self.on_add_track_handler.lock().unwrap(); if let Some(f) = handler.as_mut() { // TODO(theomonnom) } } - fn on_track(&mut self, transceiver: UniquePtr) { + fn on_track( + &mut self, + transceiver: UniquePtr, + ) { let mut handler = self.on_track_handler.lock().unwrap(); if let Some(f) = handler.as_mut() { // TODO(theomonnom) } } - fn on_remove_track(&mut self, receiver: UniquePtr) { + fn on_remove_track( + &mut self, + receiver: UniquePtr, + ) { let mut handler = self.on_remove_track_handler.lock().unwrap(); if let Some(f) = handler.as_mut() { // TODO(theomonnom) @@ -392,4 +518,23 @@ impl sys_pc::PeerConnectionObserver for InternalObserver { f(usage_pattern); } } -} \ No newline at end of file +} + +#[cfg(test)] +mod tests { + use libwebrtc_sys::peer_connection_factory::ffi::RTCConfiguration; + use crate::peer_connection_factory::PeerConnectionFactory; + + #[tokio::test] + async fn create_pc() { + let factory = PeerConnectionFactory::new(); + let mut pc = factory.create_peer_connection( + RTCConfiguration { + ice_servers: vec![], + }, + Box::new(()), + ).unwrap(); + + let offer = pc.create_offer().await.unwrap(); + } +} diff --git a/crates/livekit-webrtc/src/peer_connection_factory.rs b/crates/livekit-webrtc/src/peer_connection_factory.rs index 8e136bc..7ac5504 100644 --- a/crates/livekit-webrtc/src/peer_connection_factory.rs +++ b/crates/livekit-webrtc/src/peer_connection_factory.rs @@ -1,53 +1,43 @@ use cxx::UniquePtr; -use libwebrtc_sys::peer_connection_factory as sys_factory; use libwebrtc_sys::peer_connection as sys_pc; +use libwebrtc_sys::peer_connection_factory as sys_factory; use crate::peer_connection::PeerConnection; use crate::rtc_error::RTCError; -pub use sys_factory::ffi::{RTCConfiguration, ICEServer}; +pub use sys_factory::ffi::{ICEServer, RTCConfiguration}; pub struct PeerConnectionFactory { - cxx_handle: UniquePtr + cxx_handle: UniquePtr, } impl PeerConnectionFactory { pub fn new() -> Self { Self { - cxx_handle: sys_factory::ffi::create_peer_connection_factory() + cxx_handle: sys_factory::ffi::create_peer_connection_factory(), } } - pub fn create_peer_connection(&self, config: RTCConfiguration, observer: Box) -> Result { + pub fn create_peer_connection( + &self, + config: RTCConfiguration, + observer: Box, + ) -> Result { let native_config = sys_factory::ffi::create_rtc_configuration(config); - let native_observer = sys_pc::ffi::create_native_peer_connection_observer(Box::new(sys_pc::PeerConnectionObserverWrapper::new(observer))); + let native_observer = sys_pc::ffi::create_native_peer_connection_observer(Box::new( + sys_pc::PeerConnectionObserverWrapper::new(observer), + )); - let pc_result : Result, cxx::Exception> = unsafe { - self.cxx_handle.create_peer_connection(native_config, native_observer) + let pc_result: Result, cxx::Exception> = unsafe { + self.cxx_handle + .create_peer_connection(native_config, native_observer) }; match pc_result { - Ok(cxx_handle) => { - Ok(PeerConnection::new(cxx_handle)) - } + Ok(cxx_handle) => Ok(PeerConnection::new(cxx_handle)), Err(e) => { - Err(unsafe {RTCError::from(e.what()) }) // TODO + Err(unsafe { RTCError::from(e.what()) }) // TODO } } } } - - -#[cfg(test)] -mod tests { - use crate::peer_connection_factory::PeerConnectionFactory; - use crate::peer_connection_factory::{RTCConfiguration, ICEServer}; - - #[test] - fn create_pc(){ - let factory = PeerConnectionFactory::new(); - let pc = factory.create_peer_connection(RTCConfiguration{ - ice_servers: vec!() - }, Box::new(())); - } -} \ No newline at end of file diff --git a/crates/livekit-webrtc/src/rtc_error.rs b/crates/livekit-webrtc/src/rtc_error.rs index 282b2cd..e7aa9c0 100644 --- a/crates/livekit-webrtc/src/rtc_error.rs +++ b/crates/livekit-webrtc/src/rtc_error.rs @@ -1,4 +1,4 @@ use std::fmt; +// TODO(theomonnom) Wrap the RTCError ffi so we can use Option(u16) pub use libwebrtc_sys::rtc_error::ffi::RTCError; - diff --git a/crates/livekit-webrtc/src/rtp_receiver.rs b/crates/livekit-webrtc/src/rtp_receiver.rs index 6ab1a0f..e15433d 100644 --- a/crates/livekit-webrtc/src/rtp_receiver.rs +++ b/crates/livekit-webrtc/src/rtp_receiver.rs @@ -1,5 +1,5 @@ - +#[derive(Debug)] pub struct RtpReceiver { -} \ No newline at end of file +} diff --git a/crates/livekit-webrtc/src/rtp_transceiver.rs b/crates/livekit-webrtc/src/rtp_transceiver.rs index dc12234..96783c0 100644 --- a/crates/livekit-webrtc/src/rtp_transceiver.rs +++ b/crates/livekit-webrtc/src/rtp_transceiver.rs @@ -1,5 +1,5 @@ - +#[derive(Debug)] pub struct RtpTransceiver { -} \ No newline at end of file +} diff --git a/crates/livekit-webrtc/src/session_description.rs b/crates/livekit-webrtc/src/session_description.rs deleted file mode 100644 index 14eaa30..0000000 --- a/crates/livekit-webrtc/src/session_description.rs +++ /dev/null @@ -1,5 +0,0 @@ - -#[derive(Debug)] -pub struct SessionDescription { - -} \ No newline at end of file