refactor: ♻️ media stream

client/src/gui.rs

@@ -25,7 +25,7 @@ pub fn app() -> impl IntoView {
         })
         .children(ToChildren::to_children(move || {
             let audio_stream = audio_stream.read();
-            let audio_stream = audio_stream.as_deref().unwrap().clone();
+            let audio_stream = audio_stream.as_deref().unwrap().as_ref().unwrap().clone();
 
             let webrtc = WebRTC::new(Some(audio_stream), None, None).unwrap();
             let webrtc_state = webrtc.clone();

client/src/media.rs

@@ -1,4 +1,4 @@
-use leptos::logging::log;
+use protocol::Error;
 use wasm_bindgen_futures::JsFuture;
 use web_sys::{
     MediaStream, MediaStreamConstraints, MediaStreamTrack, MediaTrackConstraints,
@@ -6,44 +6,48 @@ use web_sys::{
     window,
 };
 
-pub async fn audio() -> MediaStream {
+pub async fn audio() -> Result<MediaStream, Error> {
-    let media_devices = window().unwrap().navigator().media_devices().unwrap();
+    let media_devices = window()
+        .ok_or(Error::MediaStream("Accessing Window".to_owned()))?
+        .navigator()
+        .media_devices()
+        .map_err(|err_val| Error::MediaStream(format!("{:?}", err_val)))?;
+
     let media_stream_constraints = MediaStreamConstraints::new();
     let media_track_constraints = MediaTrackConstraints::new();
 
     media_stream_constraints.set_audio(&JsValue::TRUE);
-
     media_track_constraints.set_echo_cancellation(&JsValue::FALSE);
     media_track_constraints.set_noise_suppression(&JsValue::FALSE);
     media_track_constraints.set_auto_gain_control(&JsValue::FALSE);
 
     let media_stream_promise = media_devices
         .get_user_media_with_constraints(&media_stream_constraints)
-        .unwrap();
+        .map_err(|err_val| Error::MediaStream(format!("{:?}", err_val)))?;
     let media_stream = JsFuture::from(media_stream_promise)
         .await
-        .unwrap()
+        .map_err(|err_val| Error::MediaStream(format!("{:?}", err_val)))?;
-        .dyn_into::<MediaStream>()
+    let media_stream = media_stream.unchecked_ref::<MediaStream>();
-        .unwrap();
+
     let audio_stream_tracks = media_stream.get_audio_tracks();
     let audio_stream_tracks = audio_stream_tracks
         .iter()
-        .map(|audio_track| audio_track.dyn_into::<MediaStreamTrack>().unwrap())
+        .map(|audio_track| MediaStreamTrack::from(audio_track))
         .collect::<Vec<_>>();
-    log!(
+    let audio_stream_track = audio_stream_tracks
-        "{:#?}\n audio_stream_track_count = {}",
+        .first()
-        audio_stream_tracks,
+        .ok_or(Error::MediaStream("Get First Media Track".to_owned()))?;
-        audio_stream_tracks.len()
+
-    );
-    let audio_stream_track = audio_stream_tracks.first().unwrap();
     let audio_stream_track_apply_constraints_promise = audio_stream_track
         .apply_constraints_with_constraints(&media_track_constraints)
-        .unwrap();
+        .map_err(|err_val| Error::MediaStream(format!("{:?}", err_val)))?;
     JsFuture::from(audio_stream_track_apply_constraints_promise)
         .await
-        .unwrap();
+        .map_err(|err_val| Error::MediaStream(format!("{:?}", err_val)))?;
-    let audio_stream = MediaStream::new().unwrap();
+
-    log!("{:#?}", audio_stream_track.get_constraints());
+    let audio_stream =
+        MediaStream::new().map_err(|err_val| Error::MediaStream(format!("{:?}", err_val)))?;
     audio_stream.add_track(audio_stream_track);
-    audio_stream
+
+    Ok(audio_stream)
 }

protocol/src/lib.rs

@@ -10,6 +10,7 @@ pub struct User {
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub enum Error {
+    MediaStream(String),
     InvalidSignalType(String),
     UnexpectedSignalType(SignalType),
     WebSocketInitialization,
@@ -39,14 +40,13 @@ impl std::error::Error for Error {
 impl Display for Error {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
+            Error::MediaStream(err_val) => write!(f, "Media Stream | {}", err_val),
             Error::InvalidSignalType(invalid_signal_type) => {
                 write!(f, "Invalid Signal Type: {}", invalid_signal_type)
             }
-
             Error::UnexpectedSignalType(signal_type) => {
                 write!(f, "Unexpected Signal Type: {}", signal_type)
             }
-
             Error::WebSocketInitialization => write!(f, "WebSocket Initialization"),
             Error::WebSocketAuth => write!(f, "WebSocket Auth"),
             Error::WebSocketSend(send_error) => write!(f, "WebSocket Send: {}", send_error),