tie mpris session to cluster topo

consume cluster topology updates to emit session dis/connect events (+
stopped on disconnect) so spotifyd dis/appears in mpris based on remote
active device presence

Author: ralphptorres

src/main_loop.rs

@@ -13,7 +13,7 @@ use futures::{
     future::{self, Fuse, FusedFuture},
     stream::Peekable,
 };
-use librespot_connect::{ConnectConfig, Spirc};
+use librespot_connect::{ClusterUpdateInfo, ConnectConfig, Spirc};
 use librespot_core::{
     Error, SessionConfig, SpotifyUri, authentication::Credentials, cache::Cache,
     config::DeviceType, session::Session,
@@ -30,6 +30,10 @@ use log::{error, info};
 use std::pin::Pin;
 use std::sync::Arc;
 
+const SPECTATOR_CONNECTION_ID: &str = "spectator-remote";
+const SPECTATOR_USER_NAME: &str = "spectator";
+const SPECTATOR_PLAY_REQUEST_ID: u64 = 0;
+
 #[cfg(not(feature = "dbus_mpris"))]
 type DbusServer = Pending<()>;
 
@@ -222,16 +226,20 @@ impl MainLoop {
             let mut running_event_program = Box::pin(Fuse::terminated());
 
             let mut event_channel = connection.player.get_player_event_channel();
-            let mut state_channel = self
+            let mut cluster_update_channel = self
                 .spectator
-                .then(|| shared_spirc.as_ref().get_state_update_channel());
+                .then(|| shared_spirc.as_ref().get_cluster_update_channel());
 
             let mut last_track_uri: Option<String> = None;
-            let mut last_play_request_id: u64 = 0;
+            #[cfg(feature = "dbus_mpris")]
+            let mut spectator_connected = false;
 
-            let mut emit_spectator_state =
-                |track_uri: String, is_playing: bool, position_ms: u32, play_request_id: u64| {
-                    let track_changed = if let Some(ref last_uri) = last_track_uri {
+            let emit_spectator_state = |last_track_uri: &mut Option<String>,
+                                        track_uri: String,
+                                        is_playing: bool,
+                                        position_ms: u32,
+                                        play_request_id: u64| {
+                    let track_changed = if let Some(ref last_uri) = *last_track_uri {
                         last_uri != &track_uri && !track_uri.is_empty()
                     } else {
                         !track_uri.is_empty()
@@ -274,7 +282,7 @@ impl MainLoop {
                         }
                     }
 
-                    last_track_uri = Some(track_uri);
+                    *last_track_uri = Some(track_uri);
                 };
 
             loop {
@@ -308,30 +316,52 @@ impl MainLoop {
                         result // unused variable
                     }
                     state = async {
-                        match state_channel.as_mut() {
+                        match cluster_update_channel.as_mut() {
                             Some(channel) => channel.recv().await,
                             None => future::pending().await
                         }
                     }, if self.spectator => {
-                        if let Ok(player_state) = state {
-                            let track_uri = player_state.track
-                                .as_ref()
-                                .map(|t| t.uri.clone())
-                                .unwrap_or_default();
+                        if let Ok(ClusterUpdateInfo { active_device_id, track_uri, is_playing, position_ms }) = state {
+                            let has_active_remote = !active_device_id.is_empty();
 
-                            let is_playing = player_state.is_playing;
-                            let position_ms = player_state.position_as_of_timestamp as u32;
+                            #[cfg(feature = "dbus_mpris")]
+                            if let Some(ref tx) = mpris_event_tx {
+                                if has_active_remote && !spectator_connected {
+                                    let _ = tx.send(PlayerEvent::SessionConnected {
+                                        connection_id: SPECTATOR_CONNECTION_ID.to_string(),
+                                        user_name: SPECTATOR_USER_NAME.to_string(),
+                                    });
+                                    spectator_connected = true;
+                                } else if !has_active_remote && spectator_connected {
+                                    if let Some(ref uri) = last_track_uri
+                                        && let Ok(track_id) = SpotifyUri::from_uri(uri)
+                                    {
+                                        let _ = tx.send(PlayerEvent::Stopped {
+                                            play_request_id: SPECTATOR_PLAY_REQUEST_ID,
+                                            track_id,
+                                        });
+                                    }
+                                    let _ = tx.send(PlayerEvent::SessionDisconnected {
+                                        connection_id: SPECTATOR_CONNECTION_ID.to_string(),
+                                        user_name: SPECTATOR_USER_NAME.to_string(),
+                                    });
+                                    spectator_connected = false;
+                                }
+                            }
 
-                            if let Ok(playback_id) = player_state.playback_id.parse::<u64>() {
-                                last_play_request_id = playback_id;
+                            if !has_active_remote {
+                                continue;
                             }
 
-                            emit_spectator_state(
-                                track_uri,
-                                is_playing,
-                                position_ms,
-                                last_play_request_id,
-                            );
+                            if let Some(track_uri) = track_uri {
+                                emit_spectator_state(
+                                    &mut last_track_uri,
+                                    track_uri,
+                                    is_playing.unwrap_or(false),
+                                    position_ms.unwrap_or(0),
+                                    SPECTATOR_PLAY_REQUEST_ID,
+                                );
+                            }
                         }
                     }
                     // a new player event is available and no program is running