Tahinli/rust_webrtc
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

feat: ✨ rtc receive offer, receive answer

Browse source
This commit is contained in:
Ahmet Kaan Gümüş 2025-04-15 04:23:38 +03:00
parent f781afe995
commit 96199f71ef
4 changed files with 134 additions and 33 deletions
Download patch file Download diff file Expand all files Collapse all files

115
client/src/rtc.rs
View file

@ -1,14 +1,17 @@
use leptos::logging::log;
use wasm_bindgen_futures::JsFuture;
use web_sys::{
RtcConfiguration, RtcIceServer, RtcPeerConnection, RtcSessionDescriptionInit,
RtcConfiguration, RtcIceServer, RtcPeerConnection, RtcSdpType, RtcSessionDescriptionInit,
js_sys::{Array, Reflect},
wasm_bindgen::{JsCast, JsValue},
};
use crate::signal::send_offer;
use crate::{
signal::{receive_answer, receive_offer, send_answer, send_offer},
sleep,
};
pub async fn offer(username: String) {
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>();
@ -17,27 +20,89 @@ pub async fn offer(username: String) {
let ice_servers = vec![ice_server].into_iter().collect::<Array>();
let rtc_configuration = RtcConfiguration::new();
rtc_configuration.set_ice_servers(&ice_servers);
let peer_connection = RtcPeerConnection::new_with_configuration(&rtc_configuration).unwrap();
let peer_connection_create_offer_promise = peer_connection.create_offer();
let rtc_session_offer = JsFuture::from(peer_connection_create_offer_promise)
.await
.unwrap();
log!("{:#?}", rtc_session_offer);
let rtc_session_offer = rtc_session_offer
.as_ref()
.unchecked_ref::<RtcSessionDescriptionInit>();
log!("{:#?}", rtc_session_offer);
JsFuture::from(peer_connection.set_local_description(rtc_session_offer))
.await
.unwrap();
let rtc_session_offer = Reflect::get(&rtc_session_offer, &JsValue::from_str("sdp"))
.unwrap()
.as_string()
.unwrap();
log!("{}", rtc_session_offer);
let data = rtc_session_offer;
send_offer(&username, &data).await.unwrap();
RtcPeerConnection::new_with_configuration(&rtc_configuration).unwrap()
}
pub async fn answer() {}
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_answer) => {
log!("{:#?}", received_answer);
let peer_connection_session_answer =
RtcSessionDescriptionInit::new(RtcSdpType::Answer);
peer_connection_session_answer.set_sdp(received_answer.get_data().as_str());
JsFuture::from(
peer_connection.set_remote_description(&peer_connection_session_answer),
)
.await
.unwrap();
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(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(offer.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();
break;
}
Err(err_val) => log!("Error: Receive Offer | {}", err_val),
}
sleep(1000).await;
}
}