implement tunein provider

Cargo.lock

···
 
 [[package]]
 name = "tunein"
-version = "0.1.2"
+version = "0.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fbb48ce12eca4db1649e7d311e782e9b8a341c844cec57b5b8d1e332381e323f"
+checksum = "9d33b9d790869737661ff1f34a95da32a1288373c5b78c66d098cff2df045055"
 dependencies = [
  "anyhow",
  "m3u",

Cargo.toml

···
 tokio = {version = "1.24.2", features = ["tokio-macros", "macros", "rt", "rt-multi-thread"]}
 tonic = "0.8.3"
 tonic-web = "0.4.0"
-tunein = "0.1.2"
+tunein = "0.1.3"
 url = "2.3.1"
 
 [build-dependencies]

src/main.rs

···
 mod provider;
 mod search;
 mod server;
+mod tags;
 mod tui;
 mod types;
 mod visualization;

src/provider/mod.rs

···
 #[async_trait]
 pub trait Provider {
     async fn search(&self, name: String) -> Result<Vec<Station>, Error>;
-    async fn get_station(&self, id: String) -> Result<(), Error>;
+    async fn get_station(&self, id: String) -> Result<Option<Station>, Error>;
     async fn browse(&self, category: String) -> Result<Vec<Station>, Error>;
 }

src/provider/radiobrowser.rs

···
         Ok(stations)
     }
 
-    async fn get_station(&self, name: String) -> Result<(), Error> {
-        let station = self
+    async fn get_station(&self, name: String) -> Result<Option<Station>, Error> {
+        let stations = self
             .client
             .get_stations()
             .name(&name)
···
             .send()
             .await
             .map_err(|e| anyhow::anyhow!(format!("{}", e)))?;
-        println!("Station: {:#?}", station);
-        Ok(())
+        match stations.len() {
+            0 => Ok(None),
+            _ => Ok(Some(Station::from(stations[0].clone()))),
+        }
     }
 
     async fn browse(&self, category: String) -> Result<Vec<Station>, Error> {
···
             .client
             .get_stations()
             .tag(&category)
-            .limit("20")
+            .limit("100")
             .send()
             .await
             .map_err(|e| anyhow::anyhow!(format!("{}", e)))?;
···
     #[tokio::test]
     pub async fn test_get_station() {
         let provider = Radiobrowser::new().await;
-        let name = "alternariveradio.us".to_string();
-        provider.get_station(name).await.unwrap();
+        let name = "AlternativeRadio.us".to_string();
+        let station = provider.get_station(name).await.unwrap();
+        assert!(station.is_some())
     }
 
     #[tokio::test]
···
             .into_iter()
             .map(|x| Station::from(x))
             .collect::<Vec<Station>>();
-        assert!(stations.len() == 20)
+        assert!(stations.len() == 100)
     }
 }

src/provider/tunein.rs

···
 use super::Provider;
 use anyhow::Error;
 use async_trait::async_trait;
+use tunein::TuneInClient;
 
-pub struct Tunein {}
+pub struct Tunein {
+    client: TuneInClient,
+}
+
+impl Tunein {
+    pub fn new() -> Self {
+        Self {
+            client: TuneInClient::new(),
+        }
+    }
+}
 
 #[async_trait]
 impl Provider for Tunein {
     async fn search(&self, name: String) -> Result<Vec<Station>, Error> {
-        Ok(vec![])
+        let results = self
+            .client
+            .search(&name)
+            .await
+            .map_err(|e| Error::msg(e.to_string()))?;
+        let stations = results.into_iter().map(|x| Station::from(x)).collect();
+        Ok(stations)
     }
 
-    async fn get_station(&self, id: String) -> Result<(), Error> {
-        Ok(())
+    async fn get_station(&self, id: String) -> Result<Option<Station>, Error> {
+        let stations = self
+            .client
+            .get_station(&id)
+            .await
+            .map_err(|e| Error::msg(e.to_string()))?;
+        match stations.len() {
+            0 => Ok(None),
+            _ => Ok(Some(Station::from(stations[0].clone()))),
+        }
     }
 
     async fn browse(&self, category: String) -> Result<Vec<Station>, Error> {
+        let category = match category.as_str() {
+            "by location" => Some(tunein::types::Category::ByLocation),
+            "by language" => Some(tunein::types::Category::ByLanguage),
+            "sports" => Some(tunein::types::Category::Sports),
+            "talk" => Some(tunein::types::Category::Talk),
+            "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")),
+        };
+
+        let stations = self
+            .client
+            .browse(category)
+            .await
+            .map_err(|e| Error::msg(e.to_string()))?;
+
         Ok(vec![])
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[tokio::test]
+    pub async fn test_search() {
+        let provider = Tunein::new();
+        let name = "alternativeradio";
+        let stations = provider.search(name.to_string()).await.unwrap();
+        println!("Search: {:#?}", stations);
+        assert!(stations.len() > 0)
+    }
+
+    #[tokio::test]
+    pub async fn test_get_station() {
+        let provider = Tunein::new();
+        let name = "s288303".to_string();
+        let station = provider.get_station(name).await.unwrap();
+        println!("Station: {:#?}", station);
+        assert!(station.is_some())
+    }
+
+    #[tokio::test]
+    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)
+    }
+}

src/tags.rs

···
+pub const TAGS: &[&str] = &[
+    "pop",
+    "music",
+    "news",
+    "rock",
+    "classical",
+    "talk",
+    "hits",
+    "radio",
+    "entretenimiento",
+    "dance",
+    "oldies",
+    "estación",
+    "80s",
+    "méxico",
+    "fm",
+    "christian",
+    "public radio",
+    "jazz",
+    "música",
+    "top 40",
+    "classic hits",
+    "90s",
+    "community radio",
+    "norteamérica",
+    "electronic",
+    "pop music",
+    "adult contemporary",
+    "moi merino",
+    "classic rock",
+    "latinoamérica",
+    "español",
+    "country",
+    "local news",
+    "alternative",
+];

src/types.rs

···
 use radiobrowser::ApiStation;
+use tunein::types::{SearchResult, StationLinkDetails};
 
 #[derive(Debug, Clone)]
 pub struct Station {
···
         }
     }
 }
+
+impl From<SearchResult> for Station {
+    fn from(result: SearchResult) -> Station {
+        Station {
+            id: result.guide_id.unwrap_or_default(),
+            name: result.text,
+            bitrate: result
+                .bitrate
+                .unwrap_or("0".to_string())
+                .parse()
+                .unwrap_or_default(),
+            codec: "".to_string(),
+            stream_url: "".to_string(),
+        }
+    }
+}
+
+impl From<StationLinkDetails> for Station {
+    fn from(details: StationLinkDetails) -> Station {
+        Station {
+            id: "".to_string(),
+            name: "".to_string(),
+            bitrate: details.bitrate,
+            stream_url: details.url,
+            codec: details.media_type.to_uppercase(),
+        }
+    }
+}