implement `browse` api

proto/objects/v1alpha1/category.proto

···
 
 package objects.v1alpha1;
 
+import "objects/v1alpha1/station.proto";
+
 message Category {
-
+  string id = 1;
+  string name = 2;
+  repeated objects.v1alpha1.Station stations = 3;
 }

proto/objects/v1alpha1/station.proto

···
 package objects.v1alpha1;
 
 message Station {
-  
+  string id = 1;
+  string name = 2;
+  string playing = 3;
+}
+
+message StationLinkDetails {
+  uint32 bitrate = 1;
+  string element = 2;
+  string is_ad_clipped_content_enabled = 3;
+  bool is_direct = 4;
+  string is_hls_advanced = 5;
+  string live_seek_stream = 6;
+  string media_type = 7;
+  uint32 player_height = 8;
+  uint32 player_width = 9;
+  string playlist_type = 10;
+  uint32 position = 11;
+  uint32 reliability = 12;
+  string url = 13;
 }

proto/tunein/v1alpha1/browse.proto

···
 
 package tunein.v1alpha1;
 
+import "objects/v1alpha1/category.proto";
+import "objects/v1alpha1/station.proto";
+
 message GetCategoriesRequest {}
 
-message GetCategoriesResponse {}
+message GetCategoriesResponse {
+  repeated objects.v1alpha1.Category categories = 1;
+}
 
 message BrowseCategoryRequest {
   string category_id = 1;
 }
 
-message BrowseCategoryResponse {}
+message BrowseCategoryResponse {
+  repeated objects.v1alpha1.Category categories = 1;
+}
 
 message GetStationDetailsRequest {
   string id = 1;
 }
 
-message GetStationDetailsResponse {}
+message GetStationDetailsResponse {
+  repeated objects.v1alpha1.StationLinkDetails station_link_details = 1;
+}
 
 service BrowseService {
   rpc GetCategories(GetCategoriesRequest) returns (GetCategoriesResponse) {}

src/api/objects.v1alpha1.rs

···
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
-pub struct Category {}
+pub struct Station {
+    #[prost(string, tag = "1")]
+    pub id: ::prost::alloc::string::String,
+    #[prost(string, tag = "2")]
+    pub name: ::prost::alloc::string::String,
+    #[prost(string, tag = "3")]
+    pub playing: ::prost::alloc::string::String,
+}
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
-pub struct Station {}
+pub struct StationLinkDetails {
+    #[prost(uint32, tag = "1")]
+    pub bitrate: u32,
+    #[prost(string, tag = "2")]
+    pub element: ::prost::alloc::string::String,
+    #[prost(string, tag = "3")]
+    pub is_ad_clipped_content_enabled: ::prost::alloc::string::String,
+    #[prost(bool, tag = "4")]
+    pub is_direct: bool,
+    #[prost(string, tag = "5")]
+    pub is_hls_advanced: ::prost::alloc::string::String,
+    #[prost(string, tag = "6")]
+    pub live_seek_stream: ::prost::alloc::string::String,
+    #[prost(string, tag = "7")]
+    pub media_type: ::prost::alloc::string::String,
+    #[prost(uint32, tag = "8")]
+    pub player_height: u32,
+    #[prost(uint32, tag = "9")]
+    pub player_width: u32,
+    #[prost(string, tag = "10")]
+    pub playlist_type: ::prost::alloc::string::String,
+    #[prost(uint32, tag = "11")]
+    pub position: u32,
+    #[prost(uint32, tag = "12")]
+    pub reliability: u32,
+    #[prost(string, tag = "13")]
+    pub url: ::prost::alloc::string::String,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct Category {
+    #[prost(string, tag = "1")]
+    pub id: ::prost::alloc::string::String,
+    #[prost(string, tag = "2")]
+    pub name: ::prost::alloc::string::String,
+    #[prost(message, repeated, tag = "3")]
+    pub stations: ::prost::alloc::vec::Vec<Station>,
+}

src/api/tunein.v1alpha1.rs

···
 pub struct GetCategoriesRequest {}
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
-pub struct GetCategoriesResponse {}
+pub struct GetCategoriesResponse {
+    #[prost(message, repeated, tag = "1")]
+    pub categories: ::prost::alloc::vec::Vec<super::super::objects::v1alpha1::Category>,
+}
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct BrowseCategoryRequest {
···
 }
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
-pub struct BrowseCategoryResponse {}
+pub struct BrowseCategoryResponse {
+    #[prost(message, repeated, tag = "1")]
+    pub categories: ::prost::alloc::vec::Vec<super::super::objects::v1alpha1::Category>,
+}
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct GetStationDetailsRequest {
···
 }
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
-pub struct GetStationDetailsResponse {}
+pub struct GetStationDetailsResponse {
+    #[prost(message, repeated, tag = "1")]
+    pub station_link_details: ::prost::alloc::vec::Vec<
+        super::super::objects::v1alpha1::StationLinkDetails,
+    >,
+}
 /// Generated client implementations.
 pub mod browse_service_client {
     #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]

src/lib.rs

···
 pub mod api {
     #[path = ""]
     pub mod tunein {
+        use tunein::types::CategoryDetails;
+
+        use super::objects::v1alpha1::{Category, Station, StationLinkDetails};
+
         #[path = "tunein.v1alpha1.rs"]
         pub mod v1alpha1;
+        impl From<CategoryDetails> for Category {
+            fn from(category: CategoryDetails) -> Self {
+                Self {
+                    id: category.guide_id.unwrap_or_default(),
+                    name: category.text,
+                    stations: category
+                        .children
+                        .map(|c| {
+                            c.into_iter()
+                                .map(|x| Station {
+                                    id: x.guide_id.unwrap_or_default(),
+                                    name: x.text,
+                                    playing: x.playing.unwrap_or_default(),
+                                })
+                                .collect()
+                        })
+                        .unwrap_or(vec![]),
+                }
+            }
+        }
+
+        impl From<tunein::types::Station> for Category {
+            fn from(s: tunein::types::Station) -> Self {
+                Self {
+                    id: s.guide_id.unwrap_or_default(),
+                    name: s.text,
+                    stations: s
+                        .children
+                        .map(|c| {
+                            c.into_iter()
+                                .map(|x| Station {
+                                    id: x.guide_id.unwrap_or_default(),
+                                    name: x.text,
+                                    playing: x.playing.unwrap_or_default(),
+                                })
+                                .collect()
+                        })
+                        .unwrap_or(vec![]),
+                }
+            }
+        }
+
+        impl From<tunein::types::StationLinkDetails> for StationLinkDetails {
+            fn from(s: tunein::types::StationLinkDetails) -> Self {
+                Self {
+                    bitrate: s.bitrate,
+                    element: s.element,
+                    is_ad_clipped_content_enabled: s.is_ad_clipped_content_enabled,
+                    is_direct: s.is_direct,
+                    is_hls_advanced: s.is_hls_advanced,
+                    live_seek_stream: s.live_seek_stream,
+                    media_type: s.media_type,
+                    player_height: s.player_height,
+                    player_width: s.player_width,
+                    playlist_type: s.playlist_type.unwrap_or_default(),
+                    position: s.position,
+                    reliability: s.reliability,
+                    url: s.url,
+                }
+            }
+        }
     }
 
     #[path = ""]

src/server/browse.rs

···
 use std::str::FromStr;
 
-use tunein::{types::Category, TuneInClient};
-use tunein_cli::api::tunein::v1alpha1::{
-    browse_service_server::BrowseService, BrowseCategoryRequest, BrowseCategoryResponse,
-    GetCategoriesRequest, GetCategoriesResponse, GetStationDetailsRequest,
-    GetStationDetailsResponse,
+use tunein::{
+    types,
+    TuneInClient,
+};
+use tunein_cli::api::{
+    objects::v1alpha1::{Category, StationLinkDetails},
+    tunein::v1alpha1::{
+        browse_service_server::BrowseService, BrowseCategoryRequest, BrowseCategoryResponse,
+        GetCategoriesRequest, GetCategoriesResponse, GetStationDetailsRequest,
+        GetStationDetailsResponse,
+    },
 };
 
 pub struct Browse {
···
 impl BrowseService for Browse {
     async fn get_categories(
         &self,
-        request: tonic::Request<GetCategoriesRequest>,
+        _request: tonic::Request<GetCategoriesRequest>,
     ) -> Result<tonic::Response<GetCategoriesResponse>, tonic::Status> {
-        self.client
+        let result = self
+            .client
             .browse(None)
             .await
             .map_err(|e| tonic::Status::internal(e.to_string()))?;
-        Ok(tonic::Response::new(GetCategoriesResponse {}))
+
+        Ok(tonic::Response::new(GetCategoriesResponse {
+            categories: result.into_iter().map(Category::from).collect(),
+        }))
     }
 
     async fn browse_category(
···
     ) -> Result<tonic::Response<BrowseCategoryResponse>, tonic::Status> {
         let req = request.into_inner();
         let category_id = req.category_id;
-        let results = match Category::from_str(&category_id) {
-            Ok(category) => self
-                .client
-                .browse(Some(category))
-                .await
-                .map_err(|e| tonic::Status::internal(e.to_string()))?,
-            Err(e) => return Err(tonic::Status::internal(e.to_string())),
+        let categories: Vec<Category> = match types::Category::from_str(&category_id) {
+            Ok(category) => {
+                let results = self
+                    .client
+                    .browse(Some(category))
+                    .await
+                    .map_err(|e| tonic::Status::internal(e.to_string()))?;
+                results.into_iter().map(Category::from).collect()
+            }
+            Err(_) => {
+                let results = self
+                    .client
+                    .browse_by_id(&category_id)
+                    .await
+                    .map_err(|e| tonic::Status::internal(e.to_string()))?;
+                results.into_iter().map(Category::from).collect()
+            }
         };
-        Ok(tonic::Response::new(BrowseCategoryResponse {}))
+        Ok(tonic::Response::new(BrowseCategoryResponse { categories }))
     }
 
     async fn get_station_details(
         &self,
         request: tonic::Request<GetStationDetailsRequest>,
     ) -> Result<tonic::Response<GetStationDetailsResponse>, tonic::Status> {
-        Ok(tonic::Response::new(GetStationDetailsResponse {}))
+        let req = request.into_inner();
+        let station_id = req.id;
+        let station = self
+            .client
+            .get_station(&station_id)
+            .await
+            .map_err(|e| tonic::Status::internal(e.to_string()))?;
+
+        Ok(tonic::Response::new(GetStationDetailsResponse {
+            station_link_details: station.into_iter().map(StationLinkDetails::from).collect(),
+        }))
     }
 }