From 85fb4fb2afd81b50fcf0c52446f39acfcfcc07b2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ahmet=20Kaan=20G=C3=BCm=C3=BC=C5=9F?= Date: Mon, 14 Apr 2025 04:58:44 +0300 Subject: [PATCH] refactor: :recycle: signal --- client/src/rtc.rs | 8 ++---- client/src/signal.rs | 68 +++++++++++++++++++++++++++++--------------- protocol/src/lib.rs | 38 ++++++++++++++++++------- 3 files changed, 74 insertions(+), 40 deletions(-) diff --git a/client/src/rtc.rs b/client/src/rtc.rs index d1699a2..123336b 100644 --- a/client/src/rtc.rs +++ b/client/src/rtc.rs @@ -1,5 +1,4 @@ use leptos::logging::log; -use protocol::RTCSessionOffer; use wasm_bindgen_futures::JsFuture; use web_sys::{ RtcConfiguration, RtcIceServer, RtcPeerConnection, RtcSessionDescriptionInit, @@ -36,12 +35,9 @@ pub async fn offer(username: String) { .as_string() .unwrap(); log!("{}", rtc_session_offer); + let data = rtc_session_offer; - send_offer(RTCSessionOffer { - username, - rtc_session_offer, - }) - .await; + send_offer(&username, &data).await; } pub async fn answer() {} diff --git a/client/src/signal.rs b/client/src/signal.rs index 585e48c..ec68f99 100644 --- a/client/src/signal.rs +++ b/client/src/signal.rs @@ -1,31 +1,53 @@ -use std::sync::LazyLock; +use std::{str::FromStr, sync::LazyLock}; -use chrono::DateTime; use leptos::logging::log; -use protocol::{RTCSessionOffer, Signal}; -use reqwest::Response; +use protocol::{Signal, SignalType}; +use reqwest::{ + Response, + header::{HeaderMap, HeaderName}, +}; use serde_json::{Value, json}; const SIGNALLING_ADDRESS: &str = "http://127.0.0.1:4546"; static REQUEST_CLIENT: LazyLock = LazyLock::new(|| reqwest::Client::new()); -async fn post_json(json: &Value) -> Result { +async fn post_json(username: &String, json: &Value) -> Result { + let mut headers = HeaderMap::new(); + headers + .try_insert( + HeaderName::from_str("username").unwrap(), + username.parse().unwrap(), + ) + .unwrap(); REQUEST_CLIENT .post(SIGNALLING_ADDRESS) + .headers(headers) .json(json) .send() .await } +async fn get_json(username: &String) -> Result { + let mut headers = HeaderMap::new(); + headers + .try_insert( + HeaderName::from_str("username").unwrap(), + username.parse().unwrap(), + ) + .unwrap(); + REQUEST_CLIENT + .get(SIGNALLING_ADDRESS) + .headers(headers) + .send() + .await +} + pub async fn start_signalling(username: String) { log!("Start Signalling"); log!("{}\n{}", username, SIGNALLING_ADDRESS); - let signal = Signal { - username, - time: DateTime::default(), - }; - let json = json!(signal); - match post_json(&json).await { + let auth_signal = Signal::new(&username, &SignalType::Auth, &"".to_owned()); + let json = json!(auth_signal); + match post_json(&username, &json).await { Ok(signal_response) => log!("{:#?}", signal_response), Err(err_val) => { log!("Error: Signal Post | {}", err_val); @@ -33,9 +55,10 @@ pub async fn start_signalling(username: String) { } } -pub async fn send_offer(rtc_session_offer: RTCSessionOffer) { - let rtc_session_offer = json!(rtc_session_offer); - match post_json(&rtc_session_offer).await { +pub async fn send_offer(username: &String, data: &String) { + let rtc_session_offer_signal = Signal::new(username, &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); @@ -43,9 +66,8 @@ pub async fn send_offer(rtc_session_offer: RTCSessionOffer) { } } -pub async fn receive_offer(username: String) { - let json = json!(username); - match post_json(&json).await { +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); @@ -53,9 +75,10 @@ pub async fn receive_offer(username: String) { } } -pub async fn send_answer(rtc_session_offer: RTCSessionOffer) { - let rtc_session_offer = json!(rtc_session_offer); - match post_json(&rtc_session_offer).await { +pub async fn send_answer(username: &String, data: &String) { + let rtc_session_answer_signal = Signal::new(username, &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); @@ -63,9 +86,8 @@ pub async fn send_answer(rtc_session_offer: RTCSessionOffer) { } } -pub async fn receive_answer(username: String) { - let json = json!(username); - match post_json(&json).await { +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); diff --git a/protocol/src/lib.rs b/protocol/src/lib.rs index f23894a..851dc52 100644 --- a/protocol/src/lib.rs +++ b/protocol/src/lib.rs @@ -1,19 +1,35 @@ use chrono::{DateTime, Utc}; use serde::{Deserialize, Serialize}; -#[derive(Debug, Serialize, Deserialize)] -pub struct Signal { - pub username: String, - pub time: DateTime, +#[derive(Debug, Clone, Copy, Serialize, Deserialize)] +pub enum SignalType { + Auth, + Offer, + Answer, } -#[derive(Debug, Serialize, Deserialize)] -pub struct RTCSessionOffer { +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct Signal { pub username: String, - pub rtc_session_offer: String, + pub signal_type: SignalType, + pub data: String, + time: DateTime, } -#[derive(Debug, Serialize, Deserialize)] -pub struct RTCSessionAnswer { - pub username: String, - pub rtc_session_offer: String, + +impl Signal { + pub fn new(username: &String, signal_type: &SignalType, data: &String) -> Signal { + let username = username.to_owned(); + let signal_type = *signal_type; + let data = data.to_owned(); + Signal { + username, + signal_type, + data, + time: DateTime::default(), + } + } + + pub fn get_time(&self) -> DateTime { + self.time + } }