121 lines
4.8 KiB
Rust
121 lines
4.8 KiB
Rust
use leptos::logging::log;
|
|
use wasm_bindgen_futures::JsFuture;
|
|
use web_sys::{
|
|
RtcConfiguration, RtcIceServer, RtcPeerConnection, RtcSdpType, RtcSessionDescriptionInit,
|
|
js_sys::{Array, Reflect},
|
|
wasm_bindgen::{JsCast, JsValue},
|
|
};
|
|
|
|
use crate::{
|
|
signal::{receive_answer, receive_offer, send_answer, send_offer},
|
|
sleep,
|
|
};
|
|
|
|
async fn create_peer_connection_with_configuration() -> RtcPeerConnection {
|
|
let ice_server_addresses = vec![JsValue::from("stun:stun.l.google.com:19302")]
|
|
.into_iter()
|
|
.collect::<Array>();
|
|
let ice_server = RtcIceServer::new();
|
|
ice_server.set_urls(&JsValue::from(ice_server_addresses));
|
|
let ice_servers = vec![ice_server].into_iter().collect::<Array>();
|
|
let rtc_configuration = RtcConfiguration::new();
|
|
rtc_configuration.set_ice_servers(&ice_servers);
|
|
RtcPeerConnection::new_with_configuration(&rtc_configuration).unwrap()
|
|
}
|
|
|
|
pub async fn offer(username: String) {
|
|
let peer_connection = create_peer_connection_with_configuration().await;
|
|
let peer_connection_create_offer_promise = peer_connection.create_offer();
|
|
let peer_connection_session_offer = JsFuture::from(peer_connection_create_offer_promise)
|
|
.await
|
|
.unwrap();
|
|
log!("{:#?}", peer_connection_session_offer);
|
|
let peer_connection_session_offer = peer_connection_session_offer
|
|
.as_ref()
|
|
.unchecked_ref::<RtcSessionDescriptionInit>();
|
|
log!("{:#?}", peer_connection_session_offer);
|
|
JsFuture::from(peer_connection.set_local_description(peer_connection_session_offer))
|
|
.await
|
|
.unwrap();
|
|
let peer_connection_session_offer =
|
|
Reflect::get(&peer_connection_session_offer, &JsValue::from_str("sdp"))
|
|
.unwrap()
|
|
.as_string()
|
|
.unwrap();
|
|
log!("{}", peer_connection_session_offer);
|
|
let data = peer_connection_session_offer;
|
|
|
|
if let Err(err_val) = send_offer(&username, &data).await {
|
|
log!("Error: Send Offer | {}", err_val)
|
|
}
|
|
|
|
for _ in 0..10 {
|
|
match receive_answer(&username).await {
|
|
Ok(received_user_and_signal_answer) => {
|
|
log!("{:#?}", received_user_and_signal_answer);
|
|
let peer_connection_session_answer =
|
|
RtcSessionDescriptionInit::new(RtcSdpType::Answer);
|
|
peer_connection_session_answer
|
|
.set_sdp(received_user_and_signal_answer.signal.get_data().as_str());
|
|
JsFuture::from(
|
|
peer_connection.set_remote_description(&peer_connection_session_answer),
|
|
)
|
|
.await
|
|
.unwrap();
|
|
|
|
for _ in 0..100 {
|
|
log!("{:#?}", peer_connection.connection_state());
|
|
sleep(1000).await;
|
|
}
|
|
break;
|
|
}
|
|
Err(err_val) => log!("Error: Receive Answer | {}", err_val),
|
|
}
|
|
sleep(1000).await;
|
|
}
|
|
}
|
|
|
|
pub async fn answer(username: String) {
|
|
for _ in 0..10 {
|
|
match receive_offer(&username).await {
|
|
Ok(received_user_and_signal_offer) => {
|
|
let peer_connection = create_peer_connection_with_configuration().await;
|
|
let peer_connection_session_offer =
|
|
RtcSessionDescriptionInit::new(RtcSdpType::Offer);
|
|
peer_connection_session_offer
|
|
.set_sdp(received_user_and_signal_offer.signal.get_data().as_str());
|
|
JsFuture::from(
|
|
peer_connection.set_remote_description(&peer_connection_session_offer),
|
|
)
|
|
.await
|
|
.unwrap();
|
|
let peer_connection_create_answer_promise = peer_connection.create_answer();
|
|
let peer_connection_answer = JsFuture::from(peer_connection_create_answer_promise)
|
|
.await
|
|
.unwrap();
|
|
let peer_connection_answer = peer_connection_answer
|
|
.as_ref()
|
|
.unchecked_ref::<RtcSessionDescriptionInit>();
|
|
JsFuture::from(peer_connection.set_local_description(peer_connection_answer))
|
|
.await
|
|
.unwrap();
|
|
let session_answer = Reflect::get(&peer_connection_answer, &JsValue::from("sdp"))
|
|
.unwrap()
|
|
.as_string()
|
|
.unwrap();
|
|
log!("{}", session_answer);
|
|
let data = session_answer;
|
|
|
|
send_answer(&username, &data).await.unwrap();
|
|
|
|
for _ in 0..100 {
|
|
log!("{:#?}", peer_connection.connection_state());
|
|
sleep(1000).await;
|
|
}
|
|
break;
|
|
}
|
|
Err(err_val) => log!("Error: Receive Offer | {}", err_val),
|
|
}
|
|
sleep(1000).await;
|
|
}
|
|
}
|