update tunein provider

src/provider/tunein.rs

···
     }
 
     async fn browse(&self, category: String) -> Result<Vec<Station>, Error> {
+        let guide_id = category.clone();
         let category = match category.as_str() {
             "by location" => Some(tunein::types::Category::ByLocation),
             "by language" => Some(tunein::types::Category::ByLanguage),
···
             "music" => Some(tunein::types::Category::Music),
             "local radio" => Some(tunein::types::Category::LocalRadio),
             "podcasts" => Some(tunein::types::Category::Podcasts),
-            _ => return Err(Error::msg("Invalid category")),
+            _ => None,
         };
 
+        if category.is_none() {
+            let category_stations = self
+                .client
+                .browse_by_id(&guide_id)
+                .await
+                .map_err(|e| Error::msg(e.to_string()))?;
+
+            let mut stations = vec![];
+
+            for st in category_stations {
+                if let Some(children) = st.children {
+                    stations = [stations, children].concat();
+                }
+            }
+
+            let stations = stations.into_iter().map(|x| Station::from(x)).collect();
+            return Ok(stations);
+        }
+
         let stations = self
             .client
             .browse(category)
             .await
             .map_err(|e| Error::msg(e.to_string()))?;
 
-        Ok(vec![])
+        let stations = stations.into_iter().map(|x| Station::from(x)).collect();
+        Ok(stations)
     }
 }
 
···
     pub async fn test_browse() {
         let provider = Tunein::new();
         let stations = provider.browse("music".to_string()).await.unwrap();
-        let stations = stations
-            .into_iter()
-            .map(|x| Station::from(x))
-            .collect::<Vec<Station>>();
         println!("Browse: {:#?}", stations);
-        assert!(stations.len() == 0)
+        assert!(stations.len() > 0)
+    }
+
+    #[tokio::test]
+    pub async fn test_browse_by_id() {
+        let provider = Tunein::new();
+        let stations = provider.browse("c57942".to_string()).await.unwrap();
+        println!("Browse by category id: {:#?}", stations);
+        assert!(stations.len() > 0)
     }
 }

src/types.rs

···
                 .unwrap_or("0".to_string())
                 .parse()
                 .unwrap_or_default(),
-            codec: "".to_string(),
-            stream_url: "".to_string(),
+            codec: Default::default(),
+            stream_url: Default::default(),
         }
     }
 }
···
 impl From<StationLinkDetails> for Station {
     fn from(details: StationLinkDetails) -> Station {
         Station {
-            id: "".to_string(),
-            name: "".to_string(),
+            id: Default::default(),
+            name: Default::default(),
             bitrate: details.bitrate,
             stream_url: details.url,
             codec: details.media_type.to_uppercase(),
         }
     }
 }
+
+impl From<tunein::types::Station> for Station {
+    fn from(st: tunein::types::Station) -> Station {
+        Station {
+            id: st.guide_id.unwrap_or_default(),
+            name: st.text,
+            bitrate: st
+                .bitrate
+                .unwrap_or("0".to_string())
+                .parse()
+                .unwrap_or_default(),
+            stream_url: Default::default(),
+            codec: st.formats.unwrap_or_default().to_uppercase(),
+        }
+    }
+}
+
+impl From<Box<tunein::types::Station>> for Station {
+    fn from(st: Box<tunein::types::Station>) -> Station {
+        Station {
+            id: st.guide_id.unwrap_or_default(),
+            name: st.text,
+            bitrate: st
+                .bitrate
+                .unwrap_or("0".to_string())
+                .parse()
+                .unwrap_or_default(),
+            stream_url: Default::default(),
+            codec: st.formats.unwrap_or_default().to_uppercase(),
+        }
+    }
+}
+
+impl From<tunein::types::CategoryDetails> for Station {
+    fn from(ct: tunein::types::CategoryDetails) -> Station {
+        Station {
+            id: ct.guide_id.unwrap_or_default(),
+            name: ct.text,
+            bitrate: 0,
+            stream_url: Default::default(),
+            codec: Default::default(),
+        }
+    }
+}