feat: ✨ rtc peer connection send_offer, receive_offer

client/src/gui.rs

@@ -4,7 +4,10 @@ use leptos::{
     ev,
     html::{ElementChild, button, form, input},
     logging::log,
-    prelude::{BindAttribute, Get, OnAttribute, Read, Show, ShowProps, ToChildren, signal},
+    prelude::{
+        BindAttribute, Get, OnAttribute, Read, ReadSignal, Show, ShowProps, ToChildren,
+        WriteSignal, signal,
+    },
     server::LocalResource,
     task::spawn_local,
 };
@@ -38,42 +41,45 @@ pub fn app() -> impl IntoView {
         }))
         .fallback(|| button().child("Sad Button"))
         .build();
-    (Show(props), signalling(), rtc())
+    let username = signal(String::from(""));
+    (Show(props), signalling(username), rtc(username.0))
 }
 
-fn signalling() -> impl IntoView {
+fn signalling(username: (ReadSignal<String>, WriteSignal<String>)) -> impl IntoView {
-    let signalling_server_input_data = signal(String::new());
     let signalling_trigger = move || {
-        spawn_local(start_signalling(
+        spawn_local(start_signalling(username.0.get()));
-            "Zurna Dürüm".to_string(),
-            signalling_server_input_data.0.get(),
-        ))
     };
     let signalling_server_input = form()
         .child(
             input()
-                .bind(Value, signalling_server_input_data)
+                .bind(Value, username)
-                .placeholder("0.0.0.0:4546")
+                .placeholder("Some Username")
                 .r#type("text"),
         )
         .on(ev::submit, move |event| {
             event.prevent_default();
-            signalling_trigger()
+            signalling_trigger();
         });
 
     let signalling_submit_button = button()
-        .on(ev::click, move |_| signalling_trigger())
+        .on(ev::click, move |event| {
+            event.prevent_default();
+            signalling_trigger();
+        })
         .child("Signal");
     (signalling_server_input, signalling_submit_button)
 }
 
-fn rtc() -> impl IntoView {
+fn rtc(username: ReadSignal<String>) -> impl IntoView {
-    let rtc_trigger = || {
+    let rtc_trigger = move || {
-        spawn_local(offer());
+        spawn_local(offer(username.get()));
     };
 
     let rtc_start_button = button()
-        .on(ev::click, move |_| rtc_trigger())
+        .on(ev::click, move |event| {
+            event.prevent_default();
+            rtc_trigger();
+        })
         .child("RTC Offer");
     rtc_start_button
 }

client/src/rtc.rs

@@ -1,4 +1,5 @@
 use leptos::logging::log;
+use protocol::RTCSessionOffer;
 use wasm_bindgen_futures::JsFuture;
 use web_sys::{
     RtcConfiguration, RtcIceServer, RtcPeerConnection, RtcSessionDescriptionInit,
@@ -6,7 +7,9 @@ use web_sys::{
     wasm_bindgen::{JsCast, JsValue},
 };
 
-pub async fn offer() {
+use crate::signal::send_offer;
+
+pub async fn offer(username: String) {
     let ice_server_addresses = vec![JsValue::from("stun:stun.l.google.com:19302")]
         .into_iter()
         .collect::<Array>();
@@ -33,6 +36,12 @@ pub async fn offer() {
         .as_string()
         .unwrap();
     log!("{}", rtc_session_offer);
+
+    send_offer(RTCSessionOffer {
+        username,
+        rtc_session_offer,
+    })
+    .await;
 }
 
 pub async fn answer() {}

client/src/signal.rs

@@ -1,18 +1,31 @@
+use std::sync::LazyLock;
+
 use chrono::DateTime;
 use leptos::logging::log;
-use protocol::Signal;
+use protocol::{RTCSessionOffer, Signal};
-use serde_json::json;
+use reqwest::Response;
+use serde_json::{Value, json};
 
-pub async fn start_signalling(username: String, signal_address: String) {
+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> {
+    REQUEST_CLIENT
+        .post(SIGNALLING_ADDRESS)
+        .json(json)
+        .send()
+        .await
+}
+
+pub async fn start_signalling(username: String) {
     log!("Start Signalling");
-    log!("{}\n{}", username, signal_address);
+    log!("{}\n{}", username, SIGNALLING_ADDRESS);
-    let request_client = reqwest::Client::new();
     let signal = Signal {
         username,
         time: DateTime::default(),
     };
-    let body = json!(signal);
+    let json = json!(signal);
-    match request_client.post(signal_address).json(&body).send().await {
+    match post_json(&json).await {
         Ok(signal_response) => log!("{:#?}", signal_response),
         Err(err_val) => {
             log!("Error: Signal Post | {}", err_val);
@@ -20,7 +33,42 @@ pub async fn start_signalling(username: String, signal_address: String) {
     }
 }
 
-pub async fn send_offer() {}
+pub async fn send_offer(rtc_session_offer: RTCSessionOffer) {
-pub async fn receive_offer() {}
+    let rtc_session_offer = json!(rtc_session_offer);
-pub async fn send_answer() {}
+    match post_json(&rtc_session_offer).await {
-pub async fn receive_answer() {}
+        Ok(signal_response) => log!("{:#?}", signal_response),
+        Err(err_val) => {
+            log!("Error: Signal Post | {}", err_val);
+        }
+    }
+}
+
+pub async fn receive_offer(username: String) {
+    let json = json!(username);
+    match post_json(&json).await {
+        Ok(signal_response) => log!("{:#?}", signal_response),
+        Err(err_val) => {
+            log!("Error: Signal Post | {}", err_val);
+        }
+    }
+}
+
+pub async fn send_answer(rtc_session_offer: RTCSessionOffer) {
+    let rtc_session_offer = json!(rtc_session_offer);
+    match post_json(&rtc_session_offer).await {
+        Ok(signal_response) => log!("{:#?}", signal_response),
+        Err(err_val) => {
+            log!("Error: Signal Post | {}", err_val);
+        }
+    }
+}
+
+pub async fn receive_answer(username: String) {
+    let json = json!(username);
+    match post_json(&json).await {
+        Ok(signal_response) => log!("{:#?}", signal_response),
+        Err(err_val) => {
+            log!("Error: Signal Post | {}", err_val);
+        }
+    }
+}

protocol/src/lib.rs

@@ -6,3 +6,14 @@ pub struct Signal {
     pub username: String,
     pub time: DateTime<Utc>,
 }
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct RTCSessionOffer {
+    pub username: String,
+    pub rtc_session_offer: String,
+}
+#[derive(Debug, Serialize, Deserialize)]
+pub struct RTCSessionAnswer {
+    pub username: String,
+    pub rtc_session_offer: String,
+}