refactor: ♻️ signal

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 {
+    send_offer(&username, &data).await;
-        username,
-        rtc_session_offer,
-    })
-    .await;
 }
 
 pub async fn answer() {}

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 protocol::{Signal, SignalType};
-use reqwest::Response;
+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<reqwest::Client> = LazyLock::new(|| reqwest::Client::new());
 
-async fn post_json(json: &Value) -> Result<Response, reqwest::Error> {
+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();
     REQUEST_CLIENT
         .post(SIGNALLING_ADDRESS)
+        .headers(headers)
         .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();
+    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 {
+    let auth_signal = Signal::new(&username, &SignalType::Auth, &"".to_owned());
-        username,
+    let json = json!(auth_signal);
-        time: DateTime::default(),
+    match post_json(&username, &json).await {
-    };
-    let json = json!(signal);
-    match post_json(&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) {
+pub async fn send_offer(username: &String, data: &String) {
-    let rtc_session_offer = json!(rtc_session_offer);
+    let rtc_session_offer_signal = Signal::new(username, &SignalType::Offer, data);
-    match post_json(&rtc_session_offer).await {
+    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) {
+pub async fn receive_offer(username: &String) {
-    let json = json!(username);
+    match get_json(username).await {
-    match post_json(&json).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) {
+pub async fn send_answer(username: &String, data: &String) {
-    let rtc_session_offer = json!(rtc_session_offer);
+    let rtc_session_answer_signal = Signal::new(username, &SignalType::Answer, data);
-    match post_json(&rtc_session_offer).await {
+    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) {
+pub async fn receive_answer(username: &String) {
-    let json = json!(username);
+    match get_json(username).await {
-    match post_json(&json).await {
         Ok(signal_response) => log!("{:#?}", signal_response),
         Err(err_val) => {
             log!("Error: Signal Post | {}", err_val);

protocol/src/lib.rs

@@ -1,19 +1,35 @@
 use chrono::{DateTime, Utc};
 use serde::{Deserialize, Serialize};
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
-pub struct Signal {
+pub enum SignalType {
-    pub username: String,
+    Auth,
-    pub time: DateTime<Utc>,
+    Offer,
+    Answer,
 }
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct RTCSessionOffer {
+pub struct Signal {
     pub username: String,
-    pub rtc_session_offer: String,
+    pub signal_type: SignalType,
+    pub data: String,
+    time: DateTime<Utc>,
 }
-#[derive(Debug, Serialize, Deserialize)]
+
-pub struct RTCSessionAnswer {
+impl Signal {
-    pub username: String,
+    pub fn new(username: &String, signal_type: &SignalType, data: &String) -> Signal {
-    pub rtc_session_offer: String,
+        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<Utc> {
+        self.time
+    }
 }