rust_webrtc/client/src/signal.rs

use std::sync::LazyLock;

use leptos::logging::log;
use protocol::{Signal, SignalType};
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 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, 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
}

pub async fn start_signalling(username: String) {
    log!("Start Signalling");
    log!("{}\n{}", username, SIGNALLING_ADDRESS);
    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),
        Err(err_val) => {
            log!("Error: Signal Post | {}", err_val);
        }
    }
}

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);
    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 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);
    post_json(username, &rtc_session_answer_signal)
        .await
        .map(|_| Ok(()))?
}

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()))?
    }
}