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

refactor: ♻️ error, send and receive signals

Browse source
This commit is contained in:
Ahmet Kaan Gümüş 2025-04-14 16:13:42 +03:00
parent 85fb4fb2af
commit f781afe995
3 changed files with 89 additions and 58 deletions
Download patch file Download diff file Expand all files Collapse all files

97
client/src/signal.rs
View file

@ -1,43 +1,38 @@
use std::{str::FromStr, sync::LazyLock};
use std::sync::LazyLock;
use leptos::logging::log;
use protocol::{Signal, SignalType};
use reqwest::{
Response,
header::{HeaderMap, HeaderName},
};
use reqwest::{Response, header::HeaderMap};
use serde_json::{Value, json};
const SIGNALLING_ADDRESS: &str = "http://127.0.0.1:4546";
static REQUEST_CLIENT: LazyLock<reqwest::Client> = LazyLock::new(|| reqwest::Client::new());
async fn create_headers(headers: Vec<(&'static str, String)>) -> HeaderMap {
let mut header_map = HeaderMap::new();
for (key, val) in headers {
header_map.insert(key, val.parse().unwrap());
}
header_map
}
async fn post_json(username: &String, json: &Value) -> Result<Response, reqwest::Error> {
let mut headers = HeaderMap::new();
headers
.try_insert(
HeaderName::from_str("username").unwrap(),
username.parse().unwrap(),
)
.unwrap();
let headers = create_headers(vec![]).await;
REQUEST_CLIENT
.post(SIGNALLING_ADDRESS)
.headers(headers)
.bearer_auth(username)
.json(json)
.send()
.await
}
async fn get_json(username: &String) -> Result<Response, reqwest::Error> {
let mut headers = HeaderMap::new();
headers
.try_insert(
HeaderName::from_str("username").unwrap(),
username.parse().unwrap(),
)
.unwrap();
async fn get_json(username: &String, signal_type: SignalType) -> Result<Response, reqwest::Error> {
let headers = create_headers(vec![("EXPECTED_SIGNAL", signal_type.to_string())]).await;
REQUEST_CLIENT
.get(SIGNALLING_ADDRESS)
.headers(headers)
.bearer_auth(username)
.send()
.await
}
@ -45,7 +40,7 @@ async fn get_json(username: &String) -> Result<Response, reqwest::Error> {
pub async fn start_signalling(username: String) {
log!("Start Signalling");
log!("{}\n{}", username, SIGNALLING_ADDRESS);
let auth_signal = Signal::new(&username, &SignalType::Auth, &"".to_owned());
let auth_signal = Signal::new(&SignalType::Auth, &"".to_owned());
let json = json!(auth_signal);
match post_json(&username, &json).await {
Ok(signal_response) => log!("{:#?}", signal_response),
@ -55,42 +50,42 @@ pub async fn start_signalling(username: String) {
}
}
pub async fn send_offer(username: &String, data: &String) {
let rtc_session_offer_signal = Signal::new(username, &SignalType::Offer, data);
pub async fn send_offer(username: &String, data: &String) -> Result<(), reqwest::Error> {
let rtc_session_offer_signal = Signal::new(&SignalType::Offer, data);
let rtc_session_offer_signal = json!(rtc_session_offer_signal);
match post_json(username, &rtc_session_offer_signal).await {
Ok(signal_response) => log!("{:#?}", signal_response),
Err(err_val) => {
log!("Error: Signal Post | {}", err_val);
}
post_json(username, &rtc_session_offer_signal)
.await
.map(|_| Ok(()))?
}
pub async fn receive_offer(username: &String) -> Result<Signal, Box<dyn std::error::Error>> {
let result = get_json(username, SignalType::Offer)
.await
.map(async |response| response.json::<Signal>().await)?
.await?;
if result.get_signal_type() == SignalType::Offer {
Ok(result)
} else {
Err(protocol::Error::SignalType(result.get_signal_type()))?
}
}
pub async fn receive_offer(username: &String) {
match get_json(username).await {
Ok(signal_response) => log!("{:#?}", signal_response),
Err(err_val) => {
log!("Error: Signal Post | {}", err_val);
}
}
}
pub async fn send_answer(username: &String, data: &String) {
let rtc_session_answer_signal = Signal::new(username, &SignalType::Answer, data);
pub async fn send_answer(username: &String, data: &String) -> Result<(), reqwest::Error> {
let rtc_session_answer_signal = Signal::new(&SignalType::Answer, data);
let rtc_session_answer_signal = json!(rtc_session_answer_signal);
match post_json(username, &rtc_session_answer_signal).await {
Ok(signal_response) => log!("{:#?}", signal_response),
Err(err_val) => {
log!("Error: Signal Post | {}", err_val);
}
}
post_json(username, &rtc_session_answer_signal)
.await
.map(|_| Ok(()))?
}
pub async fn receive_answer(username: &String) {
match get_json(username).await {
Ok(signal_response) => log!("{:#?}", signal_response),
Err(err_val) => {
log!("Error: Signal Post | {}", err_val);
}
pub async fn receive_answer(username: &String) -> Result<Signal, Box<dyn std::error::Error>> {
let result = get_json(username, SignalType::Answer)
.await
.map(async |response| response.json::<Signal>().await)?
.await?;
if result.get_signal_type() == SignalType::Answer {
Ok(result)
} else {
Err(protocol::Error::SignalType(result.get_signal_type()))?
}
}