fix: preserve original station ID when creating Station from StationLinkDetails

src/api/tunein.v1alpha1.rs

···
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct GetStationDetailsResponse {
     #[prost(message, optional, tag = "1")]
-    pub station_link_details:
-        ::core::option::Option<super::super::objects::v1alpha1::StationLinkDetails>,
+    pub station_link_details: ::core::option::Option<
+        super::super::objects::v1alpha1::StationLinkDetails,
+    >,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct SearchRequest {
···
         dead_code,
         missing_docs,
         clippy::wildcard_imports,
-        clippy::let_unit_value
+        clippy::let_unit_value,
     )]
-    use tonic::codegen::http::Uri;
     use tonic::codegen::*;
+    use tonic::codegen::http::Uri;
     #[derive(Debug, Clone)]
     pub struct BrowseServiceClient<T> {
         inner: tonic::client::Grpc<T>,
···
                     <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
                 >,
             >,
-            <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error:
-                Into<StdError> + std::marker::Send + std::marker::Sync,
+            <T as tonic::codegen::Service<
+                http::Request<tonic::body::BoxBody>,
+            >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
         {
             BrowseServiceClient::new(InterceptedService::new(inner, interceptor))
         }
···
         pub async fn get_categories(
             &mut self,
             request: impl tonic::IntoRequest<super::GetCategoriesRequest>,
-        ) -> std::result::Result<tonic::Response<super::GetCategoriesResponse>, tonic::Status>
-        {
-            self.inner.ready().await.map_err(|e| {
-                tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
-            })?;
+        ) -> std::result::Result<
+            tonic::Response<super::GetCategoriesResponse>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::unknown(
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
             let codec = tonic::codec::ProstCodec::default();
             let path = http::uri::PathAndQuery::from_static(
                 "/tunein.v1alpha1.BrowseService/GetCategories",
             );
             let mut req = request.into_request();
-            req.extensions_mut().insert(GrpcMethod::new(
-                "tunein.v1alpha1.BrowseService",
-                "GetCategories",
-            ));
+            req.extensions_mut()
+                .insert(
+                    GrpcMethod::new("tunein.v1alpha1.BrowseService", "GetCategories"),
+                );
             self.inner.unary(req, path, codec).await
         }
         pub async fn browse_category(
             &mut self,
             request: impl tonic::IntoRequest<super::BrowseCategoryRequest>,
-        ) -> std::result::Result<tonic::Response<super::BrowseCategoryResponse>, tonic::Status>
-        {
-            self.inner.ready().await.map_err(|e| {
-                tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
-            })?;
+        ) -> std::result::Result<
+            tonic::Response<super::BrowseCategoryResponse>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::unknown(
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
             let codec = tonic::codec::ProstCodec::default();
             let path = http::uri::PathAndQuery::from_static(
                 "/tunein.v1alpha1.BrowseService/BrowseCategory",
             );
             let mut req = request.into_request();
-            req.extensions_mut().insert(GrpcMethod::new(
-                "tunein.v1alpha1.BrowseService",
-                "BrowseCategory",
-            ));
+            req.extensions_mut()
+                .insert(
+                    GrpcMethod::new("tunein.v1alpha1.BrowseService", "BrowseCategory"),
+                );
             self.inner.unary(req, path, codec).await
         }
         pub async fn get_station_details(
             &mut self,
             request: impl tonic::IntoRequest<super::GetStationDetailsRequest>,
-        ) -> std::result::Result<tonic::Response<super::GetStationDetailsResponse>, tonic::Status>
-        {
-            self.inner.ready().await.map_err(|e| {
-                tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
-            })?;
+        ) -> std::result::Result<
+            tonic::Response<super::GetStationDetailsResponse>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::unknown(
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
             let codec = tonic::codec::ProstCodec::default();
             let path = http::uri::PathAndQuery::from_static(
                 "/tunein.v1alpha1.BrowseService/GetStationDetails",
             );
             let mut req = request.into_request();
-            req.extensions_mut().insert(GrpcMethod::new(
-                "tunein.v1alpha1.BrowseService",
-                "GetStationDetails",
-            ));
+            req.extensions_mut()
+                .insert(
+                    GrpcMethod::new("tunein.v1alpha1.BrowseService", "GetStationDetails"),
+                );
             self.inner.unary(req, path, codec).await
         }
         pub async fn search(
             &mut self,
             request: impl tonic::IntoRequest<super::SearchRequest>,
         ) -> std::result::Result<tonic::Response<super::SearchResponse>, tonic::Status> {
-            self.inner.ready().await.map_err(|e| {
-                tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
-            })?;
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::unknown(
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
             let codec = tonic::codec::ProstCodec::default();
-            let path =
-                http::uri::PathAndQuery::from_static("/tunein.v1alpha1.BrowseService/Search");
+            let path = http::uri::PathAndQuery::from_static(
+                "/tunein.v1alpha1.BrowseService/Search",
+            );
             let mut req = request.into_request();
             req.extensions_mut()
                 .insert(GrpcMethod::new("tunein.v1alpha1.BrowseService", "Search"));
···
         dead_code,
         missing_docs,
         clippy::wildcard_imports,
-        clippy::let_unit_value
+        clippy::let_unit_value,
     )]
     use tonic::codegen::*;
     /// Generated trait containing gRPC methods that should be implemented for use with BrowseServiceServer.
···
         async fn get_categories(
             &self,
             request: tonic::Request<super::GetCategoriesRequest>,
-        ) -> std::result::Result<tonic::Response<super::GetCategoriesResponse>, tonic::Status>;
+        ) -> std::result::Result<
+            tonic::Response<super::GetCategoriesResponse>,
+            tonic::Status,
+        >;
         async fn browse_category(
             &self,
             request: tonic::Request<super::BrowseCategoryRequest>,
-        ) -> std::result::Result<tonic::Response<super::BrowseCategoryResponse>, tonic::Status>;
+        ) -> std::result::Result<
+            tonic::Response<super::BrowseCategoryResponse>,
+            tonic::Status,
+        >;
         async fn get_station_details(
             &self,
             request: tonic::Request<super::GetStationDetailsRequest>,
-        ) -> std::result::Result<tonic::Response<super::GetStationDetailsResponse>, tonic::Status>;
+        ) -> std::result::Result<
+            tonic::Response<super::GetStationDetailsResponse>,
+            tonic::Status,
+        >;
         async fn search(
             &self,
             request: tonic::Request<super::SearchRequest>,
···
                 max_encoding_message_size: None,
             }
         }
-        pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F>
+        pub fn with_interceptor<F>(
+            inner: T,
+            interceptor: F,
+        ) -> InterceptedService<Self, F>
         where
             F: tonic::service::Interceptor,
         {
···
                 "/tunein.v1alpha1.BrowseService/GetCategories" => {
                     #[allow(non_camel_case_types)]
                     struct GetCategoriesSvc<T: BrowseService>(pub Arc<T>);
-                    impl<T: BrowseService> tonic::server::UnaryService<super::GetCategoriesRequest>
-                        for GetCategoriesSvc<T>
-                    {
+                    impl<
+                        T: BrowseService,
+                    > tonic::server::UnaryService<super::GetCategoriesRequest>
+                    for GetCategoriesSvc<T> {
                         type Response = super::GetCategoriesResponse;
-                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::GetCategoriesRequest>,
···
                 "/tunein.v1alpha1.BrowseService/BrowseCategory" => {
                     #[allow(non_camel_case_types)]
                     struct BrowseCategorySvc<T: BrowseService>(pub Arc<T>);
-                    impl<T: BrowseService> tonic::server::UnaryService<super::BrowseCategoryRequest>
-                        for BrowseCategorySvc<T>
-                    {
+                    impl<
+                        T: BrowseService,
+                    > tonic::server::UnaryService<super::BrowseCategoryRequest>
+                    for BrowseCategorySvc<T> {
                         type Response = super::BrowseCategoryResponse;
-                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::BrowseCategoryRequest>,
···
                 "/tunein.v1alpha1.BrowseService/GetStationDetails" => {
                     #[allow(non_camel_case_types)]
                     struct GetStationDetailsSvc<T: BrowseService>(pub Arc<T>);
-                    impl<T: BrowseService>
-                        tonic::server::UnaryService<super::GetStationDetailsRequest>
-                        for GetStationDetailsSvc<T>
-                    {
+                    impl<
+                        T: BrowseService,
+                    > tonic::server::UnaryService<super::GetStationDetailsRequest>
+                    for GetStationDetailsSvc<T> {
                         type Response = super::GetStationDetailsResponse;
-                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::GetStationDetailsRequest>,
                         ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
                             let fut = async move {
-                                <T as BrowseService>::get_station_details(&inner, request).await
+                                <T as BrowseService>::get_station_details(&inner, request)
+                                    .await
                             };
                             Box::pin(fut)
                         }
···
                 "/tunein.v1alpha1.BrowseService/Search" => {
                     #[allow(non_camel_case_types)]
                     struct SearchSvc<T: BrowseService>(pub Arc<T>);
-                    impl<T: BrowseService> tonic::server::UnaryService<super::SearchRequest> for SearchSvc<T> {
+                    impl<
+                        T: BrowseService,
+                    > tonic::server::UnaryService<super::SearchRequest>
+                    for SearchSvc<T> {
                         type Response = super::SearchResponse;
-                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::SearchRequest>,
                         ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
-                            let fut =
-                                async move { <T as BrowseService>::search(&inner, request).await };
+                            let fut = async move {
+                                <T as BrowseService>::search(&inner, request).await
+                            };
                             Box::pin(fut)
                         }
                     }
···
                     };
                     Box::pin(fut)
                 }
-                _ => Box::pin(async move {
-                    let mut response = http::Response::new(empty_body());
-                    let headers = response.headers_mut();
-                    headers.insert(
-                        tonic::Status::GRPC_STATUS,
-                        (tonic::Code::Unimplemented as i32).into(),
-                    );
-                    headers.insert(
-                        http::header::CONTENT_TYPE,
-                        tonic::metadata::GRPC_CONTENT_TYPE,
-                    );
-                    Ok(response)
-                }),
+                _ => {
+                    Box::pin(async move {
+                        let mut response = http::Response::new(empty_body());
+                        let headers = response.headers_mut();
+                        headers
+                            .insert(
+                                tonic::Status::GRPC_STATUS,
+                                (tonic::Code::Unimplemented as i32).into(),
+                            );
+                        headers
+                            .insert(
+                                http::header::CONTENT_TYPE,
+                                tonic::metadata::GRPC_CONTENT_TYPE,
+                            );
+                        Ok(response)
+                    })
+                }
             }
         }
     }
···
         dead_code,
         missing_docs,
         clippy::wildcard_imports,
-        clippy::let_unit_value
+        clippy::let_unit_value,
     )]
-    use tonic::codegen::http::Uri;
     use tonic::codegen::*;
+    use tonic::codegen::http::Uri;
     #[derive(Debug, Clone)]
     pub struct PlaybackServiceClient<T> {
         inner: tonic::client::Grpc<T>,
···
                     <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
                 >,
             >,
-            <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error:
-                Into<StdError> + std::marker::Send + std::marker::Sync,
+            <T as tonic::codegen::Service<
+                http::Request<tonic::body::BoxBody>,
+            >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
         {
             PlaybackServiceClient::new(InterceptedService::new(inner, interceptor))
         }
···
             &mut self,
             request: impl tonic::IntoRequest<super::PlayRequest>,
         ) -> std::result::Result<tonic::Response<super::PlayResponse>, tonic::Status> {
-            self.inner.ready().await.map_err(|e| {
-                tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
-            })?;
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::unknown(
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
             let codec = tonic::codec::ProstCodec::default();
-            let path =
-                http::uri::PathAndQuery::from_static("/tunein.v1alpha1.PlaybackService/Play");
+            let path = http::uri::PathAndQuery::from_static(
+                "/tunein.v1alpha1.PlaybackService/Play",
+            );
             let mut req = request.into_request();
             req.extensions_mut()
                 .insert(GrpcMethod::new("tunein.v1alpha1.PlaybackService", "Play"));
···
             &mut self,
             request: impl tonic::IntoRequest<super::StopRequest>,
         ) -> std::result::Result<tonic::Response<super::StopResponse>, tonic::Status> {
-            self.inner.ready().await.map_err(|e| {
-                tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
-            })?;
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::unknown(
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
             let codec = tonic::codec::ProstCodec::default();
-            let path =
-                http::uri::PathAndQuery::from_static("/tunein.v1alpha1.PlaybackService/Stop");
+            let path = http::uri::PathAndQuery::from_static(
+                "/tunein.v1alpha1.PlaybackService/Stop",
+            );
             let mut req = request.into_request();
             req.extensions_mut()
                 .insert(GrpcMethod::new("tunein.v1alpha1.PlaybackService", "Stop"));
···
         pub async fn play_or_pause(
             &mut self,
             request: impl tonic::IntoRequest<super::PlayOrPauseRequest>,
-        ) -> std::result::Result<tonic::Response<super::PlayOrPauseResponse>, tonic::Status>
-        {
-            self.inner.ready().await.map_err(|e| {
-                tonic::Status::unknown(format!("Service was not ready: {}", e.into()))
-            })?;
+        ) -> std::result::Result<
+            tonic::Response<super::PlayOrPauseResponse>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::unknown(
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
             let codec = tonic::codec::ProstCodec::default();
             let path = http::uri::PathAndQuery::from_static(
                 "/tunein.v1alpha1.PlaybackService/PlayOrPause",
             );
             let mut req = request.into_request();
-            req.extensions_mut().insert(GrpcMethod::new(
-                "tunein.v1alpha1.PlaybackService",
-                "PlayOrPause",
-            ));
+            req.extensions_mut()
+                .insert(
+                    GrpcMethod::new("tunein.v1alpha1.PlaybackService", "PlayOrPause"),
+                );
             self.inner.unary(req, path, codec).await
         }
     }
···
         dead_code,
         missing_docs,
         clippy::wildcard_imports,
-        clippy::let_unit_value
+        clippy::let_unit_value,
     )]
     use tonic::codegen::*;
     /// Generated trait containing gRPC methods that should be implemented for use with PlaybackServiceServer.
···
         async fn play_or_pause(
             &self,
             request: tonic::Request<super::PlayOrPauseRequest>,
-        ) -> std::result::Result<tonic::Response<super::PlayOrPauseResponse>, tonic::Status>;
+        ) -> std::result::Result<
+            tonic::Response<super::PlayOrPauseResponse>,
+            tonic::Status,
+        >;
     }
     #[derive(Debug)]
     pub struct PlaybackServiceServer<T> {
···
                 max_encoding_message_size: None,
             }
         }
-        pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F>
+        pub fn with_interceptor<F>(
+            inner: T,
+            interceptor: F,
+        ) -> InterceptedService<Self, F>
         where
             F: tonic::service::Interceptor,
         {
···
                 "/tunein.v1alpha1.PlaybackService/Play" => {
                     #[allow(non_camel_case_types)]
                     struct PlaySvc<T: PlaybackService>(pub Arc<T>);
-                    impl<T: PlaybackService> tonic::server::UnaryService<super::PlayRequest> for PlaySvc<T> {
+                    impl<
+                        T: PlaybackService,
+                    > tonic::server::UnaryService<super::PlayRequest> for PlaySvc<T> {
                         type Response = super::PlayResponse;
-                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::PlayRequest>,
                         ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
-                            let fut =
-                                async move { <T as PlaybackService>::play(&inner, request).await };
+                            let fut = async move {
+                                <T as PlaybackService>::play(&inner, request).await
+                            };
                             Box::pin(fut)
                         }
                     }
···
                 "/tunein.v1alpha1.PlaybackService/Stop" => {
                     #[allow(non_camel_case_types)]
                     struct StopSvc<T: PlaybackService>(pub Arc<T>);
-                    impl<T: PlaybackService> tonic::server::UnaryService<super::StopRequest> for StopSvc<T> {
+                    impl<
+                        T: PlaybackService,
+                    > tonic::server::UnaryService<super::StopRequest> for StopSvc<T> {
                         type Response = super::StopResponse;
-                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::StopRequest>,
                         ) -> Self::Future {
                             let inner = Arc::clone(&self.0);
-                            let fut =
-                                async move { <T as PlaybackService>::stop(&inner, request).await };
+                            let fut = async move {
+                                <T as PlaybackService>::stop(&inner, request).await
+                            };
                             Box::pin(fut)
                         }
                     }
···
                 "/tunein.v1alpha1.PlaybackService/PlayOrPause" => {
                     #[allow(non_camel_case_types)]
                     struct PlayOrPauseSvc<T: PlaybackService>(pub Arc<T>);
-                    impl<T: PlaybackService> tonic::server::UnaryService<super::PlayOrPauseRequest>
-                        for PlayOrPauseSvc<T>
-                    {
+                    impl<
+                        T: PlaybackService,
+                    > tonic::server::UnaryService<super::PlayOrPauseRequest>
+                    for PlayOrPauseSvc<T> {
                         type Response = super::PlayOrPauseResponse;
-                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
                         fn call(
                             &mut self,
                             request: tonic::Request<super::PlayOrPauseRequest>,
···
                     };
                     Box::pin(fut)
                 }
-                _ => Box::pin(async move {
-                    let mut response = http::Response::new(empty_body());
-                    let headers = response.headers_mut();
-                    headers.insert(
-                        tonic::Status::GRPC_STATUS,
-                        (tonic::Code::Unimplemented as i32).into(),
-                    );
-                    headers.insert(
-                        http::header::CONTENT_TYPE,
-                        tonic::metadata::GRPC_CONTENT_TYPE,
-                    );
-                    Ok(response)
-                }),
+                _ => {
+                    Box::pin(async move {
+                        let mut response = http::Response::new(empty_body());
+                        let headers = response.headers_mut();
+                        headers
+                            .insert(
+                                tonic::Status::GRPC_STATUS,
+                                (tonic::Code::Unimplemented as i32).into(),
+                            );
+                        headers
+                            .insert(
+                                http::header::CONTENT_TYPE,
+                                tonic::metadata::GRPC_CONTENT_TYPE,
+                            );
+                        Ok(response)
+                    })
+                }
             }
         }
     }

src/app.rs

···
 }
 
 /// Send [`os_media_controls::Command`].
-fn send_os_media_controls_command(
+pub fn send_os_media_controls_command(
     os_media_controls: Option<&mut OsMediaControls>,
     command: os_media_controls::Command<'_>,
 ) {

src/interactive.rs

···
 use ratatui::prelude::*;
 use ratatui::widgets::{Block, Borders, List, ListItem, ListState, Paragraph};
 use tokio::sync::mpsc;
+use tunein_cli::os_media_controls::{self, OsMediaControls};
 
+use crate::app::send_os_media_controls_command;
 use crate::audio::{AudioController, PlaybackEvent, PlaybackState};
 use crate::extract::get_currently_playing;
 use crate::favorites::{FavoriteStation, FavoritesStore};
···
     let (input_tx, mut input_rx) = mpsc::unbounded_channel();
     spawn_input_thread(input_tx.clone());
 
+    let os_media_controls = OsMediaControls::new()
+        .inspect_err(|err| {
+            eprintln!(
+                "error: failed to initialize os media controls due to `{}`",
+                err
+            );
+        })
+        .ok();
+
     let mut app = HubApp::new(
         provider_name.to_string(),
         provider,
         audio,
         favorites,
         metadata_tx,
+        os_media_controls,
     );
 
     let result = loop {
···
     metadata_tx: mpsc::UnboundedSender<HubMessage>,
     now_playing_station_id: Option<String>,
     next_now_playing_poll: Instant,
+    os_media_controls: Option<OsMediaControls>,
 }
 
 impl HubApp {
···
         audio: AudioController,
         favorites: FavoritesStore,
         metadata_tx: mpsc::UnboundedSender<HubMessage>,
+        os_media_controls: Option<OsMediaControls>,
     ) -> Self {
         let mut ui = UiState::default();
         ui.menu_state.select(Some(0));
···
             metadata_tx,
             now_playing_station_id: None,
             next_now_playing_poll: Instant::now(),
+            os_media_controls,
         }
     }
 
···
                 })
             })
             .unwrap_or_else(|| "Unknown".to_string());
-        self.render_labeled_line(frame, area, row, "Station ", &station_name);
+        let station_id = self
+            .current_playback
+            .as_ref()
+            .map(|p| p.station.id.as_str())
+            .or_else(|| self.current_station.as_ref().map(|s| s.station.id.as_str()))
+            .unwrap_or("N/A");
+
+        self.render_labeled_line(
+            frame,
+            area,
+            row,
+            "Station ",
+            &format!("{} - {}", station_name, station_id),
+        );
         row += 1;
 
         let now_playing = self
···
                 self.current_playback = Some(state.clone());
                 if let Some(station) = self.current_station.as_mut() {
                     station.station.playing = Some(state.now_playing.clone());
+                    station.station.id = state.station.id.clone();
                 }
                 self.set_status(&format!("Now playing {}", state.stream_name));
                 self.prepare_now_playing_poll();
···
                     station.station.playing = Some(now_playing.clone());
                 }
                 self.set_status(&format!("Now Playing {}", now_playing));
+
+                let name = self
+                    .current_station
+                    .as_ref()
+                    .map(|s| s.station.name.clone())
+                    .unwrap_or_default();
+
+                send_os_media_controls_command(
+                    self.os_media_controls.as_mut(),
+                    os_media_controls::Command::SetMetadata(souvlaki::MediaMetadata {
+                        title: (!now_playing.is_empty()).then_some(now_playing.as_str()),
+                        album: (!name.is_empty()).then_some(name.as_str()),
+                        artist: None,
+                        cover_url: None,
+                        duration: None,
+                    }),
+                );
             }
         }
     }

src/provider/tunein.rs

···
                     None => Ok(None),
                 }
             }
-            _ => Ok(Some(Station::from(stations[0].clone()))),
+            _ => {
+                let mut station = Station::from(stations[0].clone());
+                // Preserve the original station ID since StationLinkDetails doesn't contain it
+                station.id = id;
+                Ok(Some(station))
+            }
         }
     }