rs-terminal: handle json ser-de errors gracefully

senders/terminal/src/fcastsession.rs

@@ -7,10 +7,7 @@ use std::{
 };
 
 use crate::{
-    models::{
+    models::{v2, v3, PlaybackErrorMessage, VersionMessage, VolumeUpdateMessage},
-        v2,
-        v3, PlaybackErrorMessage, VersionMessage, VolumeUpdateMessage,
-    },
     transport::Transport,
 };
 use serde::Serialize;
@@ -205,7 +202,8 @@ impl<'a> FCastSession<'a> {
             return Err(format!(
                 "Cannot subscribe to events in the current state ({:?})",
                 self.state
-            ).into());
+            )
+            .into());
         }
 
         let obj = match event {

senders/terminal/src/models/v3.rs

@@ -1,6 +1,6 @@
 use std::collections::HashMap;
 
-use serde::{de, Deserialize, Serialize};
+use serde::{de, ser, Deserialize, Serialize};
 use serde_json::{json, Value};
 use serde_repr::{Deserialize_repr, Serialize_repr};
 
@@ -69,13 +69,32 @@ impl<'de> Deserialize<'de> for MetadataObject {
         let rest = Value::Object(map);
 
         match type_ {
-            0 => Ok(Self::Generic {
+            0 => {
-                title: rest.get("title").map(|v| v.as_str().unwrap().to_owned()),
+                let title = match rest.get("title") {
-                thumbnail_url: rest
+                    Some(t) => Some(
-                    .get("thumbnailUrl")
+                        t.as_str()
-                    .map(|v| v.as_str().unwrap().to_owned()),
+                            .ok_or(de::Error::custom("`title` is not a string"))?
-                custom: rest.get("custom").unwrap().clone(),
+                            .to_owned(),
-            }),
+                    ),
+                    None => None,
+                };
+                let thumbnail_url = match rest.get("thumbnailUrl") {
+                    Some(t) => Some(
+                        t.as_str()
+                            .ok_or(de::Error::custom("`thumbnailUrl` is not a string"))?
+                            .to_owned(),
+                    ),
+                    None => None,
+                };
+                Ok(Self::Generic {
+                    title,
+                    thumbnail_url,
+                    custom: rest
+                        .get("custom")
+                        .ok_or(de::Error::missing_field("custom"))?
+                        .clone(),
+                })
+            }
             _ => Err(de::Error::custom(format!("Unknown metadata type {type_}"))),
         }
     }
@@ -352,7 +371,10 @@ impl Serialize for EventObject {
         match self {
             EventObject::MediaItem { variant, item } => {
                 map.insert("type".to_owned(), json!(*variant as u8));
-                map.insert("item".to_owned(), serde_json::to_value(item).unwrap());
+                map.insert(
+                    "item".to_owned(),
+                    serde_json::to_value(item).map_err(ser::Error::custom)?,
+                );
             }
             EventObject::Key {
                 variant,
@@ -361,9 +383,18 @@ impl Serialize for EventObject {
                 handled,
             } => {
                 map.insert("type".to_owned(), json!(*variant as u8));
-                map.insert("key".to_owned(), serde_json::to_value(key).unwrap());
+                map.insert(
-                map.insert("repeat".to_owned(), serde_json::to_value(repeat).unwrap());
+                    "key".to_owned(),
-                map.insert("handled".to_owned(), serde_json::to_value(handled).unwrap());
+                    serde_json::to_value(key).map_err(ser::Error::custom)?,
+                );
+                map.insert(
+                    "repeat".to_owned(),
+                    serde_json::to_value(repeat).map_err(ser::Error::custom)?,
+                );
+                map.insert(
+                    "handled".to_owned(),
+                    serde_json::to_value(handled).map_err(ser::Error::custom)?,
+                );
             }
         }
 
@@ -395,7 +426,7 @@ impl<'de> Deserialize<'de> for EventObject {
                 let item = get_from_map!(rest, "item")?;
                 Ok(Self::MediaItem {
                     variant,
-                    item: MediaItem::deserialize(item).unwrap(),
+                    item: MediaItem::deserialize(item).map_err(de::Error::custom)?,
                 })
             }
             3 | 4 => {
@@ -406,9 +437,16 @@ impl<'de> Deserialize<'de> for EventObject {
                 };
                 Ok(Self::Key {
                     variant,
-                    key: get_from_map!(rest, "key")?.as_str().unwrap().to_owned(),
+                    key: get_from_map!(rest, "key")?
-                    repeat: get_from_map!(rest, "repeat")?.as_bool().unwrap(),
+                        .as_str()
-                    handled: get_from_map!(rest, "handled")?.as_bool().unwrap(),
+                        .ok_or(de::Error::custom("`key` is not a string"))?
+                        .to_owned(),
+                    repeat: get_from_map!(rest, "repeat")?
+                        .as_bool()
+                        .ok_or(de::Error::custom("`repeat` is not a bool"))?,
+                    handled: get_from_map!(rest, "handled")?
+                        .as_bool()
+                        .ok_or(de::Error::custom("`handled` is not a bool"))?,
                 })
             }
             _ => Err(de::Error::custom(format!("Unknown event type {type_}"))),