talksik/client-sdk-rust
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

pc test

Browse Source
This commit is contained in:
Théo Monnom
2022-09-16 11:45:39 +02:00
parent f643f458f8
commit 06587d154f
20 changed files with 261 additions and 267 deletions
Download Patch File Download Diff File Expand all files Collapse all files
crates/livekit-webrtc/libwebrtc-sys/src/data_channel.cpp
+25 -1
View File
@@ -2,11 +2,35 @@
// Created by Théo Monnom on 01/09/2022.
//
#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_(data_channel) {
DataChannel::DataChannel(rtc::scoped_refptr<webrtc::DataChannelInterface> data_channel) : data_channel_(std::move(data_channel)) {
}
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;
rtc_init->ordered = init.ordered;
rtc_init->protocol = init.protocol.c_str();
rtc_init->reliable = init.reliable;
if(init.has_max_retransmit_time)
rtc_init->maxRetransmitTime = init.max_retransmit_time;
if(init.has_max_retransmits)
rtc_init->maxRetransmits = init.max_retransmits;
if(init.has_priority)
rtc_init->priority = static_cast<webrtc::Priority>(init.priority);
return rtc_init;
}
} // livekit
crates/livekit-webrtc/libwebrtc-sys/src/data_channel.rs
+30
View File
@@ -2,10 +2,40 @@ use cxx::UniquePtr;
#[cxx::bridge(namespace = "livekit")]
pub mod ffi {
#[derive(Debug)]
#[repr(u32)]
enum Priority {
VeryLow,
Low,
Medium,
High,
}
#[derive(Debug)]
//#[allow(deprecated)]
pub struct DataChannelInit {
#[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
}
unsafe extern "C++" {
include!("livekit/data_channel.h");
type DataChannel;
type NativeDataChannelInit;
fn create_data_channel_init(init: DataChannelInit) -> UniquePtr<NativeDataChannelInit>;
fn _unique_data_channel() -> UniquePtr<DataChannel>; // Ignore
}
crates/livekit-webrtc/libwebrtc-sys/src/jsep.rs
+2 -2
View File
@@ -1,5 +1,5 @@
use std::fmt::{Debug, Formatter};
use cxx::UniquePtr;
use std::fmt::{Debug, Formatter};
use crate::rtc_error::ffi::RTCError;
@@ -33,6 +33,7 @@ pub mod ffi {
type NativeSetRemoteSdpObserverHandle;
fn stringify(self: &SessionDescription) -> String;
fn clone(self: &SessionDescription) -> UniquePtr<SessionDescription>;
fn create_native_create_sdp_observer(
observer: Box<CreateSdpObserverWrapper>,
@@ -45,7 +46,6 @@ pub mod ffi {
) -> UniquePtr<NativeSetRemoteSdpObserverHandle>;
fn _unique_ice_candidate() -> UniquePtr<IceCandidate>; // Ignore
fn _shared_session_description() -> SharedPtr<SessionDescription>; // Ignore
fn _unique_session_description() -> UniquePtr<SessionDescription>; // Ignore
}
}
crates/livekit-webrtc/libwebrtc-sys/src/peer_connection.cpp
+15 -4
View File
@@ -4,6 +4,7 @@
#include "livekit/peer_connection.h"
#include "libwebrtc-sys/src/peer_connection.rs.h"
#include "livekit/rtc_error.h"
namespace livekit {
@@ -26,10 +27,6 @@ namespace livekit {
}
void PeerConnection::close() {
peer_connection_->Close();
}
void PeerConnection::create_offer(std::unique_ptr<NativeCreateSdpObserverHandle> observer_handle, RTCOfferAnswerOptions options) {
peer_connection_->CreateOffer(observer_handle->observer.get(), toNativeOfferAnswerOptions(options));
}
@@ -46,6 +43,20 @@ namespace livekit {
peer_connection_->SetRemoteDescription(desc->clone()->release(), observer->observer);
}
std::unique_ptr<DataChannel> PeerConnection::create_data_channel(rust::String label, std::unique_ptr<NativeDataChannelInit> init) {
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::close() {
peer_connection_->Close();
}
/* Observer */
NativePeerConnectionObserver::NativePeerConnectionObserver(rust::Box<PeerConnectionObserverWrapper> observer) : observer_(std::move(observer)) {
crates/livekit-webrtc/libwebrtc-sys/src/peer_connection.rs
+71 -62
View File
@@ -1,5 +1,3 @@
use std::cell::RefCell;
use std::rc::Rc;
use crate::candidate::ffi::Candidate;
use crate::data_channel::ffi::DataChannel;
use crate::jsep::ffi::IceCandidate;
@@ -143,42 +141,45 @@ pub mod ffi {
extern "Rust" {
type PeerConnectionObserverWrapper;
fn on_signaling_change(self: &mut PeerConnectionObserverWrapper, new_state: SignalingState);
fn on_add_stream(
unsafe fn on_signaling_change(
self: &mut PeerConnectionObserverWrapper,
new_state: SignalingState,
);
unsafe fn on_add_stream(
self: &mut PeerConnectionObserverWrapper,
stream: UniquePtr<MediaStreamInterface>,
);
fn on_remove_stream(
unsafe fn on_remove_stream(
self: &mut PeerConnectionObserverWrapper,
stream: UniquePtr<MediaStreamInterface>,
);
fn on_data_channel(
unsafe fn on_data_channel(
self: &mut PeerConnectionObserverWrapper,
data_channel: UniquePtr<DataChannel>,
);
fn on_renegotiation_needed(self: &mut PeerConnectionObserverWrapper);
fn on_negotiation_needed_event(self: &mut PeerConnectionObserverWrapper, event: u32);
fn on_ice_connection_change(
unsafe fn on_renegotiation_needed(self: &mut PeerConnectionObserverWrapper);
unsafe fn on_negotiation_needed_event(self: &mut PeerConnectionObserverWrapper, event: u32);
unsafe fn on_ice_connection_change(
self: &mut PeerConnectionObserverWrapper,
new_state: IceConnectionState,
);
fn on_standardized_ice_connection_change(
unsafe fn on_standardized_ice_connection_change(
self: &mut PeerConnectionObserverWrapper,
new_state: IceConnectionState,
);
fn on_connection_change(
unsafe fn on_connection_change(
self: &mut PeerConnectionObserverWrapper,
new_state: PeerConnectionState,
);
fn on_ice_gathering_change(
unsafe fn on_ice_gathering_change(
self: &mut PeerConnectionObserverWrapper,
new_state: IceGatheringState,
);
fn on_ice_candidate(
unsafe fn on_ice_candidate(
self: &mut PeerConnectionObserverWrapper,
candidate: UniquePtr<IceCandidate>,
);
fn on_ice_candidate_error(
unsafe fn on_ice_candidate_error(
self: &mut PeerConnectionObserverWrapper,
address: String,
port: i32,
@@ -186,32 +187,35 @@ pub mod ffi {
error_code: i32,
error_text: String,
);
fn on_ice_candidates_removed(
unsafe fn on_ice_candidates_removed(
self: &mut PeerConnectionObserverWrapper,
removed: Vec<CandidatePtr>,
);
fn on_ice_connection_receiving_change(
unsafe fn on_ice_connection_receiving_change(
self: &mut PeerConnectionObserverWrapper,
receiving: bool,
);
fn on_ice_selected_candidate_pair_changed(
unsafe fn on_ice_selected_candidate_pair_changed(
self: &mut PeerConnectionObserverWrapper,
event: CandidatePairChangeEvent,
);
fn on_add_track(
unsafe fn on_add_track(
self: &mut PeerConnectionObserverWrapper,
receiver: UniquePtr<RtpReceiver>,
streams: Vec<MediaStreamPtr>,
);
fn on_track(
unsafe fn on_track(
self: &mut PeerConnectionObserverWrapper,
transceiver: UniquePtr<RtpTransceiver>,
);
fn on_remove_track(
unsafe fn on_remove_track(
self: &mut PeerConnectionObserverWrapper,
receiver: UniquePtr<RtpReceiver>,
);
fn on_interesting_usage(self: &mut PeerConnectionObserverWrapper, usage_pattern: i32);
unsafe fn on_interesting_usage(
self: &mut PeerConnectionObserverWrapper,
usage_pattern: i32,
);
}
}
@@ -273,60 +277,63 @@ pub trait PeerConnectionObserver: Send + Sync {
fn on_interesting_usage(&mut self, usage_pattern: i32);
}
// Thread safety is handled inside PeerConnectionObserver
pub struct PeerConnectionObserverWrapper {
observer: Rc<RefCell<dyn PeerConnectionObserver>>,
observer: *mut dyn PeerConnectionObserver,
}
impl PeerConnectionObserverWrapper {
pub fn new(observer: Rc<RefCell<dyn PeerConnectionObserver>>) -> Self {
/// SAFETY
/// PeerConnectionObserver must lives as long as PeerConnectionObserverWrapper does
pub unsafe fn new(observer: *mut dyn PeerConnectionObserver) -> Self {
Self { observer }
}
fn on_signaling_change(&mut self, new_state: ffi::SignalingState) {
self.observer.borrow_mut().on_signaling_change(new_state);
unsafe fn on_signaling_change(&mut self, new_state: ffi::SignalingState) {
(*self.observer).on_signaling_change(new_state);
}
fn on_add_stream(&mut self, stream: UniquePtr<MediaStreamInterface>) {
self.observer.borrow_mut().on_add_stream(stream);
unsafe fn on_add_stream(&mut self, stream: UniquePtr<MediaStreamInterface>) {
(*self.observer).on_add_stream(stream);
}
fn on_remove_stream(&mut self, stream: UniquePtr<MediaStreamInterface>) {
self.observer.borrow_mut().on_remove_stream(stream);
unsafe fn on_remove_stream(&mut self, stream: UniquePtr<MediaStreamInterface>) {
(*self.observer).on_remove_stream(stream);
}
fn on_data_channel(&mut self, data_channel: UniquePtr<DataChannel>) {
self.observer.borrow_mut().on_data_channel(data_channel);
unsafe fn on_data_channel(&mut self, data_channel: UniquePtr<DataChannel>) {
(*self.observer).on_data_channel(data_channel);
}
fn on_renegotiation_needed(&mut self) {
self.observer.borrow_mut().on_renegotiation_needed();
unsafe fn on_renegotiation_needed(&mut self) {
(*self.observer).on_renegotiation_needed();
}
fn on_negotiation_needed_event(&mut self, event: u32) {
self.observer.borrow_mut().on_negotiation_needed_event(event);
unsafe fn on_negotiation_needed_event(&mut self, event: u32) {
(*self.observer).on_negotiation_needed_event(event);
}
fn on_ice_connection_change(&mut self, new_state: ffi::IceConnectionState) {
self.observer.borrow_mut().on_ice_connection_change(new_state);
unsafe fn on_ice_connection_change(&mut self, new_state: ffi::IceConnectionState) {
(*self.observer).on_ice_connection_change(new_state);
}
fn on_standardized_ice_connection_change(&mut self, new_state: ffi::IceConnectionState) {
self.observer.borrow_mut().on_standardized_ice_connection_change(new_state);
unsafe fn on_standardized_ice_connection_change(&mut self, new_state: ffi::IceConnectionState) {
(*self.observer).on_standardized_ice_connection_change(new_state);
}
fn on_connection_change(&mut self, new_state: ffi::PeerConnectionState) {
self.observer.borrow_mut().on_connection_change(new_state);
unsafe fn on_connection_change(&mut self, new_state: ffi::PeerConnectionState) {
(*self.observer).on_connection_change(new_state);
}
fn on_ice_gathering_change(&mut self, new_state: ffi::IceGatheringState) {
self.observer.borrow_mut().on_ice_gathering_change(new_state);
unsafe fn on_ice_gathering_change(&mut self, new_state: ffi::IceGatheringState) {
(*self.observer).on_ice_gathering_change(new_state);
}
fn on_ice_candidate(&mut self, candidate: UniquePtr<IceCandidate>) {
self.observer.borrow_mut().on_ice_candidate(candidate);
unsafe fn on_ice_candidate(&mut self, candidate: UniquePtr<IceCandidate>) {
(*self.observer).on_ice_candidate(candidate);
}
fn on_ice_candidate_error(
unsafe fn on_ice_candidate_error(
&mut self,
address: String,
port: i32,
@@ -334,29 +341,31 @@ impl PeerConnectionObserverWrapper {
error_code: i32,
error_text: String,
) {
self.observer
.borrow_mut().on_ice_candidate_error(address, port, url, error_code, error_text);
(*self.observer).on_ice_candidate_error(address, port, url, error_code, error_text);
}
fn on_ice_candidates_removed(&mut self, removed: Vec<ffi::CandidatePtr>) {
unsafe fn on_ice_candidates_removed(&mut self, removed: Vec<ffi::CandidatePtr>) {
let mut vec = Vec::new();
for v in removed {
vec.push(v.ptr);
}
self.observer.borrow_mut().on_ice_candidates_removed(vec);
(*self.observer).on_ice_candidates_removed(vec);
}
fn on_ice_connection_receiving_change(&mut self, receiving: bool) {
self.observer.borrow_mut().on_ice_connection_receiving_change(receiving);
unsafe fn on_ice_connection_receiving_change(&mut self, receiving: bool) {
(*self.observer).on_ice_connection_receiving_change(receiving);
}
fn on_ice_selected_candidate_pair_changed(&mut self, event: ffi::CandidatePairChangeEvent) {
self.observer.borrow_mut().on_ice_selected_candidate_pair_changed(event);
unsafe fn on_ice_selected_candidate_pair_changed(
&mut self,
event: ffi::CandidatePairChangeEvent,
) {
(*self.observer).on_ice_selected_candidate_pair_changed(event);
}
fn on_add_track(
unsafe fn on_add_track(
&mut self,
receiver: UniquePtr<RtpReceiver>,
streams: Vec<ffi::MediaStreamPtr>,
@@ -367,18 +376,18 @@ impl PeerConnectionObserverWrapper {
vec.push(v.ptr);
}
self.observer.borrow_mut().on_add_track(receiver, vec);
(*self.observer).on_add_track(receiver, vec);
}
fn on_track(&mut self, transceiver: UniquePtr<RtpTransceiver>) {
self.observer.borrow_mut().on_track(transceiver);
unsafe fn on_track(&mut self, transceiver: UniquePtr<RtpTransceiver>) {
(*self.observer).on_track(transceiver);
}
fn on_remove_track(&mut self, receiver: UniquePtr<RtpReceiver>) {
self.observer.borrow_mut().on_remove_track(receiver);
unsafe fn on_remove_track(&mut self, receiver: UniquePtr<RtpReceiver>) {
(*self.observer).on_remove_track(receiver);
}
fn on_interesting_usage(&mut self, usage_pattern: i32) {
self.observer.borrow_mut().on_interesting_usage(usage_pattern);
unsafe fn on_interesting_usage(&mut self, usage_pattern: i32) {
(*self.observer).on_interesting_usage(usage_pattern);
}
}
crates/livekit-webrtc/libwebrtc-sys/src/peer_connection_factory.cpp
+2 -2
View File
@@ -57,11 +57,11 @@ namespace livekit{
webrtc::PeerConnectionDependencies deps{observer.get()};
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>(std::move(result.value()), std::move(observer));
return std::make_unique<PeerConnection>(result.value(), std::move(observer));
}
std::unique_ptr<PeerConnectionFactory> create_peer_connection_factory() {
crates/livekit-webrtc/libwebrtc-sys/src/peer_connection_factory.rs
+4 -138
View File
@@ -22,12 +22,12 @@ pub mod ffi {
#[derive(Debug, Clone)]
pub struct ICEServer {
urls: Vec<String>,
username: String,
password: String,
pub urls: Vec<String>,
pub username: String,
pub password: String,
}
#[derive(Debug)]
#[derive(Debug, Clone)]
pub struct RTCConfiguration {
pub ice_servers: Vec<ICEServer>,
}
@@ -51,137 +51,3 @@ pub mod ffi {
) -> Result<UniquePtr<PeerConnection>>;
}
}
/*
#[cfg(test)]
mod test {
struct TestObserver {
}
impl PeerConnectionObserver for TestObserver {
fn on_signaling_change(&self, new_state: SignalingState) {
log::debug!("Signaling state changed: {:?}", new_state);
}
fn on_add_stream(&self, stream: UniquePtr<MediaStreamInterface>) {
todo!()
}
fn on_remove_stream(&self, stream: UniquePtr<MediaStreamInterface>) {
todo!()
}
fn on_data_channel(&self, data_channel: UniquePtr<DataChannel>) {
todo!()
}
fn on_renegotiation_needed(&self) {
todo!()
}
fn on_negotiation_needed_event(&self, event: u32) {
todo!()
}
fn on_ice_connection_change(&self, new_state: IceConnectionState) {
log::debug!("ICE connection state changed: {:?}", new_state);
}
fn on_standardized_ice_connection_change(&self, new_state: IceConnectionState) {
todo!()
}
fn on_connection_change(&self, new_state: PeerConnectionState) {
log::debug!("PeerConnection state changed: {:?}", new_state);
}
fn on_ice_gathering_change(&self, new_state: IceGatheringState) {
todo!()
}
fn on_ice_candidate(&self, candidate: UniquePtr<IceCandidate>) {
todo!()
}
fn on_ice_candidate_error(&self, address: String, port: i32, url: String, error_code: i32, error_text: String) {
todo!()
}
fn on_ice_candidates_removed(&self, removed: Vec<UniquePtr<Candidate>>) {
todo!()
}
fn on_ice_connection_receiving_change(&self, receiving: bool) {
todo!()
}
fn on_ice_selected_candidate_pair_changed(&self, event: CandidatePairChangeEvent) {
todo!()
}
fn on_add_track(&self, receiver: UniquePtr<RtpReceiver>, streams: Vec<UniquePtr<MediaStreamInterface>>) {
todo!()
}
fn on_track(&self, transceiver: UniquePtr<RtpTransceiver>) {
todo!()
}
fn on_remove_track(&self, receiver: UniquePtr<RtpReceiver>) {
todo!()
}
fn on_interesting_usage(&self, usage_pattern: i32) {
todo!()
}
}
struct SessionObserver {
}
impl CreateSdpObserver for SessionObserver {
fn on_success(&self, session_description: UniquePtr<crate::jsep::ffi::SessionDescription>) {
info!("on_success");
}
fn on_failure(&self, error: UniquePtr<crate::rtc_error::ffi::RTCError>) {
info!("on_failure");
}
}
#[test]
fn create_pc_test() {
env_logger::init();
let factory = ffi::create_peer_connection_factory(); // Default factory config is defined on the c++ side atm
unsafe {
let mut pc = factory.create_peer_connection(ffi::create_rtc_configuration(ffi::RTCConfiguration {
ice_servers: vec![ffi::ICEServer {
urls: vec!["stun:stun.l.google.com:19302".to_string()],
username: "".to_string(),
password: "".to_string(),
}],
}), peer_connection::ffi::create_native_peer_connection_observer(Box::new(peer_connection::PeerConnectionObserverWrapper::new(Box::new(TestObserver{}))))).unwrap();
let options = peer_connection::ffi::RTCOfferAnswerOptions::default();
let sdp_observer = jsep::ffi::create_native_create_sdp_observer(Box::new(jsep::CreateSdpObserverWrapper::new(Box::new(SessionObserver{}))));
pc.pin_mut().create_offer(sdp_observer, options);
sleep(Duration::from_secs(2));
pc.pin_mut().close();
}
}
}
*/
crates/livekit-webrtc/libwebrtc-sys/src/rtc_error.cpp
+1 -1
View File
@@ -15,7 +15,7 @@ namespace livekit {
lk_error.error_detail = static_cast<RTCErrorDetailType>(error.error_detail());
lk_error.error_type = static_cast<RTCErrorType>(error.type());
lk_error.has_sctp_cause_code = error.sctp_cause_code().has_value();
lk_error.sctp_cause_code = error.sctp_cause_code().value();
lk_error.sctp_cause_code = error.sctp_cause_code().value_or(0);
lk_error.message = error.message();
return lk_error;
}