Windows + Initial WebRTC sys & Safe WebRTC + Initial livekit-core

2022-09-12 12:51:54 +02:00
parent 7b09d6dd51
commit d9fd69b5c0
128 changed files with 4282 additions and 2282 deletions
@@ -0,0 +1,100 @@
+use futures_util::SinkExt;
+use futures_util::StreamExt;
+use log::{error, info};
+use prost::Message as ProtoMessage;
+use std::borrow::Borrow;
+use thiserror::Error;
+use tokio::net::TcpStream;
+use tokio::sync::broadcast;
+use tokio::task::JoinHandle;
+use tokio_tungstenite::tungstenite::Message;
+use tokio_tungstenite::{connect_async, MaybeTlsStream, WebSocketStream};
+
+use crate::{proto, proto::signal_response};
+
+#[derive(Error, Debug)]
+pub enum SignalClientError {
+    #[error("websocket failure")]
+    WebSocket(#[from] tokio_tungstenite::tungstenite::Error),
+    #[error("failed to parse the url")]
+    UrlParse(#[from] url::ParseError),
+    #[error("failed to parse messages from server")]
+    ProtoParse(#[from] prost::DecodeError),
+}
+
+pub struct SignalClient {
+    ws_handle: Option<JoinHandle<Result<(), SignalClientError>>>,
+    response_tx: broadcast::Sender<signal_response::Message>,
+    pub response_rx: broadcast::Receiver<signal_response::Message>,
+}
+
+impl SignalClient {
+    pub fn new() -> Self {
+        let (tx, rx) = broadcast::channel(16);
+
+        Self {
+            response_tx: tx,
+            response_rx: rx,
+            ws_handle: None,
+        }
+    }
+
+    pub async fn connect(&mut self, url: &str, token: &str) -> Result<(), SignalClientError> {
+        let mut lk_url = url::Url::parse(url)?;
+        lk_url.set_path("/rtc");
+        lk_url
+            .query_pairs_mut()
+            .append_pair("access_token", token)
+            .append_pair("protocol", "8");
+
+        info!("Connecting to {}", lk_url);
+        let (ws, _) = connect_async(&lk_url).await?;
+
+        self.ws_handle = Some(tokio::spawn(Self::handle_ws(ws, self.response_tx.clone())));
+        Ok(())
+    }
+
+    pub async fn disconnect() {
+        unimplemented!()
+    }
+
+    async fn handle_ws(
+        mut ws: WebSocketStream<MaybeTlsStream<TcpStream>>,
+        response_tx: broadcast::Sender<signal_response::Message>,
+    ) -> Result<(), SignalClientError> {
+        loop {
+            tokio::select! {
+                next_msg = ws.next() => {
+                    let ws_msg = match next_msg {
+                        Some(msg) => msg?,
+                        None => break,
+                    };
+
+                    let data = match ws_msg {
+                        Message::Binary(data) => data,
+                        Message::Ping(data) => {
+                            ws.send(Message::Pong(data)).await?;
+                            continue
+                        },
+                        Message::Close(_frame) => break,
+                        _ => continue,
+                    };
+
+                    let proto_msg = proto::SignalResponse::decode(data.borrow())?;
+                    let signal_response = proto_msg.message.unwrap();
+
+                    match signal_response {
+                        signal_response::Message::Pong(ts) => {
+
+                        },
+                        _ => {
+                            response_tx.send(signal_response).unwrap();
+                        }
+                    }
+                }
+            }
+        }
+
+        Ok(())
+    }
+}