DataChannel progress

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

@@ -6,7 +6,7 @@ pub mod ffi {
 
     #[derive(Debug)]
     #[repr(u32)]
-    enum Priority {
+    pub enum Priority {
         VeryLow,
         Low,
         Medium,
@@ -14,20 +14,20 @@ pub mod ffi {
     }
 
     #[derive(Debug)]
-    #[allow(deprecated)]
     pub struct DataChannelInit {
+        #[allow(deprecated)]
         #[deprecated]
-        reliable: bool,
-        ordered: bool,
-        has_max_retransmit_time: bool,
-        max_retransmit_time: i32,
-        has_max_retransmits: bool,
-        max_retransmits: i32,
-        protocol: String,
-        negotiated: bool,
-        id: i32,
-        has_priority: bool,
-        priority: Priority,
+        pub reliable: bool,
+        pub ordered: bool,
+        pub has_max_retransmit_time: bool,
+        pub max_retransmit_time: i32,
+        pub has_max_retransmits: bool,
+        pub max_retransmits: i32,
+        pub protocol: String,
+        pub negotiated: bool,
+        pub id: i32,
+        pub has_priority: bool,
+        pub priority: Priority,
     }
 
     #[derive(Debug)]
@@ -60,6 +60,14 @@ pub mod ffi {
         type NativeDataChannelInit;
         type NativeDataChannelObserver;
 
+        /// SAFETY
+        /// The observer must live as the datachannel uses it
+        unsafe fn register_observer(
+            self: Pin<&mut DataChannel>,
+            observer: Pin<&mut NativeDataChannelObserver>,
+        );
+
+        fn unregister_observer(self: Pin<&mut DataChannel>);
         fn close(self: Pin<&mut DataChannel>);
 
         fn create_data_channel_init(init: DataChannelInit) -> UniquePtr<NativeDataChannelInit>;

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

@@ -15,6 +15,10 @@ namespace livekit {
 
     }
 
+    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)){
 
     }

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

@@ -58,6 +58,14 @@ impl Debug for ffi::SessionDescription {
 
 unsafe impl Send for ffi::SessionDescription {}
 
+impl Debug for ffi::IceCandidate {
+    fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
+        write!(f, "TODO") // TODO(theomonnom)
+    }
+}
+
+unsafe impl Send for ffi::IceCandidate {}
+
 // CreateSdpObserver
 
 pub trait CreateSdpObserver: Send {

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

@@ -7,3 +7,4 @@ pub mod peer_connection_factory;
 pub mod rtc_error;
 pub mod rtp_receiver;
 pub mod rtp_transceiver;
+pub mod webrtc;

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

@@ -51,11 +51,31 @@ namespace livekit {
         return std::make_unique<DataChannel>(result.value());
     }
 
+    void PeerConnection::add_ice_candidate(std::unique_ptr<IceCandidate> candidate, NativeAddIceCandidateObserver &observer){
+        peer_connection_->AddIceCandidate(candidate->release(), [&](const webrtc::RTCError& err){
+            observer.OnComplete(to_error(err));
+        });
+    }
+
     void PeerConnection::close() {
         peer_connection_->Close();
     }
 
-    /* Observer */
+    // AddIceCandidateObserver
+
+    NativeAddIceCandidateObserver::NativeAddIceCandidateObserver(rust::Box<AddIceCandidateObserverWrapper> observer) : observer_(std::move(observer)) {
+
+    }
+
+    void NativeAddIceCandidateObserver::OnComplete(const RTCError &error) {
+        observer_->on_complete(error);
+    }
+
+    std::unique_ptr<NativeAddIceCandidateObserver> create_native_add_ice_candidate_observer(rust::Box<AddIceCandidateObserverWrapper> observer) {
+        return std::make_unique<NativeAddIceCandidateObserver>(std::move(observer));
+    }
+
+    // PeerConnectionObserver
 
     NativePeerConnectionObserver::NativePeerConnectionObserver(rust::Box<PeerConnectionObserverWrapper> observer) : observer_(std::move(observer)) {
 

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

@@ -5,6 +5,7 @@ use crate::media_stream_interface::ffi::MediaStreamInterface;
 use crate::rtp_receiver::ffi::RtpReceiver;
 use crate::rtp_transceiver::ffi::RtpTransceiver;
 use cxx::UniquePtr;
+use crate::rtc_error::ffi::RTCError;
 
 #[cxx::bridge(namespace = "livekit")]
 pub mod ffi {
@@ -94,7 +95,9 @@ pub mod ffi {
         include!("livekit/rtp_transceiver.h");
         include!("livekit/media_stream_interface.h");
         include!("livekit/candidate.h");
+        include!("libwebrtc-sys/src/rtc_error.rs.h");
 
+        type RTCError = crate::rtc_error::ffi::RTCError;
         type Candidate = crate::candidate::ffi::Candidate;
         type IceCandidate = crate::jsep::ffi::IceCandidate;
         type DataChannel = crate::data_channel::ffi::DataChannel;
@@ -104,8 +107,10 @@ pub mod ffi {
         type NativeCreateSdpObserverHandle = crate::jsep::ffi::NativeCreateSdpObserverHandle;
         type NativeSetLocalSdpObserverHandle = crate::jsep::ffi::NativeSetLocalSdpObserverHandle;
         type NativeSetRemoteSdpObserverHandle = crate::jsep::ffi::NativeSetRemoteSdpObserverHandle;
+        type NativeDataChannelInit = crate::data_channel::ffi::NativeDataChannelInit;
         type SessionDescription = crate::jsep::ffi::SessionDescription;
 
+        type NativeAddIceCandidateObserver;
         type NativePeerConnectionObserver;
         type PeerConnection;
 
@@ -141,57 +146,80 @@ pub mod ffi {
             observer: Pin<&mut NativeSetRemoteSdpObserverHandle>,
         );
 
+        fn create_data_channel(
+            self: Pin<&mut PeerConnection>,
+            label: String,
+            init: UniquePtr<NativeDataChannelInit>,
+        ) -> Result<UniquePtr<DataChannel>>;
+
+        fn add_ice_candidate(
+            self: Pin<&mut PeerConnection>,
+            candidate: UniquePtr<IceCandidate>,
+            observer: Pin<&mut NativeAddIceCandidateObserver>,
+        );
+
         fn close(self: Pin<&mut PeerConnection>);
 
         fn create_native_peer_connection_observer(
             observer: Box<PeerConnectionObserverWrapper>,
         ) -> UniquePtr<NativePeerConnectionObserver>;
 
+        fn create_native_add_ice_candidate_observer(
+            observer: Box<AddIceCandidateObserverWrapper>,
+        ) -> UniquePtr<NativeAddIceCandidateObserver>;
+
         fn _unique_peer_connection() -> UniquePtr<PeerConnection>; // Ignore
     }
 
     extern "Rust" {
+        type AddIceCandidateObserverWrapper;
+
+        fn on_complete(
+            self: &AddIceCandidateObserverWrapper,
+            error: RTCError,
+        );
+
         type PeerConnectionObserverWrapper;
 
-        unsafe fn on_signaling_change(
+        fn on_signaling_change(
             self: &PeerConnectionObserverWrapper,
             new_state: SignalingState,
         );
-        unsafe fn on_add_stream(
+        fn on_add_stream(
             self: &PeerConnectionObserverWrapper,
             stream: UniquePtr<MediaStreamInterface>,
         );
-        unsafe fn on_remove_stream(
+        fn on_remove_stream(
             self: &PeerConnectionObserverWrapper,
             stream: UniquePtr<MediaStreamInterface>,
         );
-        unsafe fn on_data_channel(
+        fn on_data_channel(
             self: &PeerConnectionObserverWrapper,
             data_channel: UniquePtr<DataChannel>,
         );
-        unsafe fn on_renegotiation_needed(self: &PeerConnectionObserverWrapper);
-        unsafe fn on_negotiation_needed_event(self: &PeerConnectionObserverWrapper, event: u32);
-        unsafe fn on_ice_connection_change(
+        fn on_renegotiation_needed(self: &PeerConnectionObserverWrapper);
+        fn on_negotiation_needed_event(self: &PeerConnectionObserverWrapper, event: u32);
+        fn on_ice_connection_change(
             self: &PeerConnectionObserverWrapper,
             new_state: IceConnectionState,
         );
-        unsafe fn on_standardized_ice_connection_change(
+        fn on_standardized_ice_connection_change(
             self: &PeerConnectionObserverWrapper,
             new_state: IceConnectionState,
         );
-        unsafe fn on_connection_change(
+        fn on_connection_change(
             self: &PeerConnectionObserverWrapper,
             new_state: PeerConnectionState,
         );
-        unsafe fn on_ice_gathering_change(
+        fn on_ice_gathering_change(
             self: &PeerConnectionObserverWrapper,
             new_state: IceGatheringState,
         );
-        unsafe fn on_ice_candidate(
+        fn on_ice_candidate(
             self: &PeerConnectionObserverWrapper,
             candidate: UniquePtr<IceCandidate>,
         );
-        unsafe fn on_ice_candidate_error(
+        fn on_ice_candidate_error(
             self: &PeerConnectionObserverWrapper,
             address: String,
             port: i32,
@@ -199,32 +227,32 @@ pub mod ffi {
             error_code: i32,
             error_text: String,
         );
-        unsafe fn on_ice_candidates_removed(
+        fn on_ice_candidates_removed(
             self: &PeerConnectionObserverWrapper,
             removed: Vec<CandidatePtr>,
         );
-        unsafe fn on_ice_connection_receiving_change(
+        fn on_ice_connection_receiving_change(
             self: &PeerConnectionObserverWrapper,
             receiving: bool,
         );
-        unsafe fn on_ice_selected_candidate_pair_changed(
+        fn on_ice_selected_candidate_pair_changed(
             self: &PeerConnectionObserverWrapper,
             event: CandidatePairChangeEvent,
         );
-        unsafe fn on_add_track(
+        fn on_add_track(
             self: &PeerConnectionObserverWrapper,
             receiver: UniquePtr<RtpReceiver>,
             streams: Vec<MediaStreamPtr>,
         );
-        unsafe fn on_track(
+        fn on_track(
             self: &PeerConnectionObserverWrapper,
             transceiver: UniquePtr<RtpTransceiver>,
         );
-        unsafe fn on_remove_track(
+        fn on_remove_track(
             self: &PeerConnectionObserverWrapper,
             receiver: UniquePtr<RtpReceiver>,
         );
-        unsafe fn on_interesting_usage(self: &PeerConnectionObserverWrapper, usage_pattern: i32);
+        fn on_interesting_usage(self: &PeerConnectionObserverWrapper, usage_pattern: i32);
     }
 }
 
@@ -253,6 +281,21 @@ impl Default for ffi::RTCOfferAnswerOptions {
     }
 }
 
+
+pub struct AddIceCandidateObserverWrapper {
+    observer: Box<dyn Fn(RTCError) + Send>
+}
+
+impl AddIceCandidateObserverWrapper {
+    pub fn new(observer: Box<dyn Fn(RTCError) + Send>) -> Self {
+        Self { observer }
+    }
+
+    fn on_complete(&self, error: RTCError){
+        (self.observer)(error);
+    }
+}
+
 pub trait PeerConnectionObserver: Send + Sync {
     fn on_signaling_change(&self, new_state: ffi::SignalingState);
     fn on_add_stream(&self, stream: UniquePtr<MediaStreamInterface>);
@@ -298,51 +341,51 @@ impl PeerConnectionObserverWrapper {
         Self { observer }
     }
 
-    unsafe fn on_signaling_change(&self, new_state: ffi::SignalingState) {
-        (*self.observer).on_signaling_change(new_state);
+    fn on_signaling_change(&self, new_state: ffi::SignalingState) {
+        unsafe { (*self.observer).on_signaling_change(new_state); }
     }
 
-    unsafe fn on_add_stream(&self, stream: UniquePtr<MediaStreamInterface>) {
-        (*self.observer).on_add_stream(stream);
+    fn on_add_stream(&self, stream: UniquePtr<MediaStreamInterface>) {
+        unsafe { (*self.observer).on_add_stream(stream); }
     }
 
-    unsafe fn on_remove_stream(&self, stream: UniquePtr<MediaStreamInterface>) {
-        (*self.observer).on_remove_stream(stream);
+    fn on_remove_stream(&self, stream: UniquePtr<MediaStreamInterface>) {
+        unsafe { (*self.observer).on_remove_stream(stream); }
     }
 
-    unsafe fn on_data_channel(&self, data_channel: UniquePtr<DataChannel>) {
-        (*self.observer).on_data_channel(data_channel);
+    fn on_data_channel(&self, data_channel: UniquePtr<DataChannel>) {
+        unsafe { (*self.observer).on_data_channel(data_channel); }
     }
 
-    unsafe fn on_renegotiation_needed(&self) {
-        (*self.observer).on_renegotiation_needed();
+    fn on_renegotiation_needed(&self) {
+        unsafe { (*self.observer).on_renegotiation_needed(); }
     }
 
-    unsafe fn on_negotiation_needed_event(&self, event: u32) {
-        (*self.observer).on_negotiation_needed_event(event);
+    fn on_negotiation_needed_event(&self, event: u32) {
+        unsafe { (*self.observer).on_negotiation_needed_event(event); }
     }
 
-    unsafe fn on_ice_connection_change(&self, new_state: ffi::IceConnectionState) {
-        (*self.observer).on_ice_connection_change(new_state);
+    fn on_ice_connection_change(&self, new_state: ffi::IceConnectionState) {
+        unsafe { (*self.observer).on_ice_connection_change(new_state); }
     }
 
-    unsafe fn on_standardized_ice_connection_change(&self, new_state: ffi::IceConnectionState) {
-        (*self.observer).on_standardized_ice_connection_change(new_state);
+    fn on_standardized_ice_connection_change(&self, new_state: ffi::IceConnectionState) {
+        unsafe { (*self.observer).on_standardized_ice_connection_change(new_state); }
     }
 
-    unsafe fn on_connection_change(&self, new_state: ffi::PeerConnectionState) {
-        (*self.observer).on_connection_change(new_state);
+    fn on_connection_change(&self, new_state: ffi::PeerConnectionState) {
+        unsafe { (*self.observer).on_connection_change(new_state); }
     }
 
-    unsafe fn on_ice_gathering_change(&self, new_state: ffi::IceGatheringState) {
-        (*self.observer).on_ice_gathering_change(new_state);
+    fn on_ice_gathering_change(&self, new_state: ffi::IceGatheringState) {
+        unsafe { (*self.observer).on_ice_gathering_change(new_state); }
     }
 
-    unsafe fn on_ice_candidate(&self, candidate: UniquePtr<IceCandidate>) {
-        (*self.observer).on_ice_candidate(candidate);
+    fn on_ice_candidate(&self, candidate: UniquePtr<IceCandidate>) {
+        unsafe { (*self.observer).on_ice_candidate(candidate); }
     }
 
-    unsafe fn on_ice_candidate_error(
+    fn on_ice_candidate_error(
         &self,
         address: String,
         port: i32,
@@ -350,28 +393,28 @@ impl PeerConnectionObserverWrapper {
         error_code: i32,
         error_text: String,
     ) {
-        (*self.observer).on_ice_candidate_error(address, port, url, error_code, error_text);
+        unsafe { (*self.observer).on_ice_candidate_error(address, port, url, error_code, error_text); }
     }
 
-    unsafe fn on_ice_candidates_removed(&self, removed: Vec<ffi::CandidatePtr>) {
+    fn on_ice_candidates_removed(&self, removed: Vec<ffi::CandidatePtr>) {
         let mut vec = Vec::new();
 
         for v in removed {
             vec.push(v.ptr);
         }
 
-        (*self.observer).on_ice_candidates_removed(vec);
+        unsafe { (*self.observer).on_ice_candidates_removed(vec); }
     }
 
-    unsafe fn on_ice_connection_receiving_change(&self, receiving: bool) {
-        (*self.observer).on_ice_connection_receiving_change(receiving);
+    fn on_ice_connection_receiving_change(&self, receiving: bool) {
+        unsafe { (*self.observer).on_ice_connection_receiving_change(receiving); }
     }
 
-    unsafe fn on_ice_selected_candidate_pair_changed(&self, event: ffi::CandidatePairChangeEvent) {
-        (*self.observer).on_ice_selected_candidate_pair_changed(event);
+    fn on_ice_selected_candidate_pair_changed(&self, event: ffi::CandidatePairChangeEvent) {
+        unsafe { (*self.observer).on_ice_selected_candidate_pair_changed(event); }
     }
 
-    unsafe fn on_add_track(
+    fn on_add_track(
         &self,
         receiver: UniquePtr<RtpReceiver>,
         streams: Vec<ffi::MediaStreamPtr>,
@@ -382,18 +425,18 @@ impl PeerConnectionObserverWrapper {
             vec.push(v.ptr);
         }
 
-        (*self.observer).on_add_track(receiver, vec);
+        unsafe { (*self.observer).on_add_track(receiver, vec); }
     }
 
-    unsafe fn on_track(&self, transceiver: UniquePtr<RtpTransceiver>) {
-        (*self.observer).on_track(transceiver);
+    fn on_track(&self, transceiver: UniquePtr<RtpTransceiver>) {
+        unsafe { (*self.observer).on_track(transceiver); }
     }
 
-    unsafe fn on_remove_track(&self, receiver: UniquePtr<RtpReceiver>) {
-        (*self.observer).on_remove_track(receiver);
+    fn on_remove_track(&self, receiver: UniquePtr<RtpReceiver>) {
+        unsafe { (*self.observer).on_remove_track(receiver); }
     }
 
-    unsafe fn on_interesting_usage(&self, usage_pattern: i32) {
-        (*self.observer).on_interesting_usage(usage_pattern);
+    fn on_interesting_usage(&self, usage_pattern: i32) {
+        unsafe { (*self.observer).on_interesting_usage(usage_pattern); }
     }
 }

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

@@ -70,7 +70,6 @@ namespace livekit{
 
     std::unique_ptr<NativeRTCConfiguration> create_rtc_configuration(RTCConfiguration conf){
         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();

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

@@ -7,7 +7,6 @@
 #include <sstream>
 #include <string>
 
-
 namespace livekit {
 
     RTCError to_error(const webrtc::RTCError &error) {

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

@@ -0,0 +1,22 @@
+//
+// Created by theom on 18/09/2022.
+//
+
+#include "livekit/webrtc.h"
+#include "rtc_base/logging.h"
+
+namespace livekit {
+    RTCRuntime::RTCRuntime() {
+        RTC_LOG(LS_INFO) << "RTCRuntime()";
+        RTC_CHECK(rtc::InitializeSSL()) << "Failed to InitializeSSL()";
+    }
+
+    RTCRuntime::~RTCRuntime() {
+        RTC_LOG(LS_INFO) << "~RTCRuntime()";
+        RTC_CHECK(rtc::CleanupSSL()) << "Failed to CleanupSSL()";
+    }
+
+    std::unique_ptr<RTCRuntime> create_rtc_runtime(){
+        return std::make_unique<RTCRuntime>();
+    }
+} // livekit

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

@@ -0,0 +1,12 @@
+use cxx::UniquePtr;
+
+#[cxx::bridge(namespace = "livekit")]
+pub mod ffi {
+    unsafe extern "C++" {
+        include!("livekit/webrtc.h");
+
+        type RTCRuntime;
+
+        fn create_rtc_runtime() -> UniquePtr<RTCRuntime>;
+    }
+}