Add MPRIS support

CHANGELOG.md

@@ -11,6 +11,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - [connect] Add method `add_to_queue` to `Spirc` to add tracks, episodes, albums and playlists to the queue
 - [playback] Add `SetQueue` player event, emitting when the queue changes (context loaded, track added to queue, or queue set via Spotify Connect). Gated behind `ConnectConfig::emit_set_queue_events`
+- [dbus/mpris] Add dbus/mpris support to allow controlling player (breaking)
 
 ### Changed
 

Cargo.toml

@@ -36,7 +36,7 @@ repository = "https://github.com/librespot-org/librespot"
 edition = "2024"
 
 [features]
-default = ["native-tls", "rodio-backend", "with-libmdns"]
+default = ["native-tls", "rodio-backend", "with-libmdns", "with-mpris"]
 
 # TLS backends (mutually exclusive - compile-time checks in oauth/src/lib.rs)
 # Note: Feature validation is in oauth crate since it's compiled first in the dependency tree.
@@ -132,6 +132,10 @@ with-dns-sd = ["librespot-discovery/with-dns-sd"]
 # data.
 passthrough-decoder = ["librespot-playback/passthrough-decoder"]
 
+# MPRIS: Allow external tool to have access to playback
+# status, metadata and to control the player.
+with-mpris = ["dep:zbus", "dep:zvariant", "dep:time"]
+
 [lib]
 name = "librespot"
 path = "src/lib.rs"
@@ -180,7 +184,10 @@ tokio = { version = "1", features = [
     "sync",
     "process",
 ] }
+time = { version = "0.3", features = ["formatting"], optional = true }
 url = "2.2"
+zbus = { version = "5", default-features = false, features = ["tokio"], optional = true }
+zvariant = { version = "5", default-features = false, optional = true }
 
 [package.metadata.deb]
 maintainer = "Librespot Organization <noreply@github.com>"

connect/src/spirc.rs

@@ -131,6 +131,7 @@ enum SpircCommand {
     RepeatTrack(bool),
     Disconnect { pause: bool },
     SetPosition(u32),
+    SeekOffset(i32),
     SetVolume(u16),
     Activate,
     Transfer(Option<TransferRequest>),
@@ -146,6 +147,7 @@ const VOLUME_UPDATE_DELAY: Duration = Duration::from_millis(500);
 const UPDATE_STATE_DELAY: Duration = Duration::from_millis(200);
 
 /// The spotify connect handle
+#[derive(Clone)]
 pub struct Spirc {
     commands: mpsc::UnboundedSender<SpircCommand>,
 }
@@ -395,6 +397,13 @@ impl Spirc {
         Ok(self.commands.send(SpircCommand::Load(command))?)
     }
 
+    /// Seek to given offset.
+    ///
+    /// Does nothing if we are not the active device.
+    pub fn seek_offset(&self, offset_ms: i32) -> Result<(), Error> {
+        Ok(self.commands.send(SpircCommand::SeekOffset(offset_ms))?)
+    }
+
     /// Adds a track, episode, album or playlist to the queue.
     ///
     /// Does nothing if we are not the active device.
@@ -744,6 +753,7 @@ impl SpircTask {
             SpircCommand::Repeat(repeat) => self.handle_repeat_context(repeat)?,
             SpircCommand::RepeatTrack(repeat) => self.handle_repeat_track(repeat),
             SpircCommand::SetPosition(position) => self.handle_seek(position),
+            SpircCommand::SeekOffset(offset) => self.handle_seek_offset(offset),
             SpircCommand::SetVolume(volume) => self.set_volume(volume),
             SpircCommand::Load(command) => self.handle_load(command, None, None).await?,
             SpircCommand::AddToQueue(uri) => self.handle_add_to_queue(uri).await,
@@ -1604,6 +1614,25 @@ impl SpircTask {
         };
     }
 
+    fn handle_seek_offset(&mut self, offset_ms: i32) {
+        let position_ms = match self.play_status {
+            SpircPlayStatus::Stopped => return,
+            SpircPlayStatus::LoadingPause { position_ms }
+            | SpircPlayStatus::LoadingPlay { position_ms }
+            | SpircPlayStatus::Paused { position_ms, .. } => position_ms,
+            SpircPlayStatus::Playing {
+                nominal_start_time, ..
+            } => {
+                let now = self.now_ms();
+                (now - nominal_start_time) as u32
+            }
+        };
+
+        let position_ms = ((position_ms as i32) + offset_ms).max(0) as u32;
+
+        self.handle_seek(position_ms);
+    }
+
     fn handle_shuffle(&mut self, shuffle: bool) -> Result<(), Error> {
         self.player.emit_shuffle_changed_event(shuffle);
         self.connect_state.handle_shuffle(shuffle)

metadata/src/audio/item.rs

@@ -45,6 +45,7 @@ pub enum UniqueFields {
     Track {
         artists: ArtistsWithRole,
         album: String,
+        album_date: Date,
         album_artists: Vec<String>,
         popularity: u8,
         number: u32,
@@ -90,6 +91,8 @@ impl AudioItem {
                 let uri_string = uri.to_uri();
                 let album = track.album.name;
 
+                let album_date = track.album.date;
+
                 let album_artists = track
                     .album
                     .artists
@@ -123,6 +126,7 @@ impl AudioItem {
                 let unique_fields = UniqueFields::Track {
                     artists: track.artists_with_role,
                     album,
+                    album_date,
                     album_artists,
                     popularity,
                     number,

playback/src/player.rs

@@ -161,8 +161,8 @@ pub enum PlayerEvent {
     },
     // Fired when the player is stopped (e.g. by issuing a "stop" command to the player).
     Stopped {
-        play_request_id: u64,
-        track_id: SpotifyUri,
+        play_request_id: Option<u64>,
+        track_id: Option<SpotifyUri>,
     },
     // The player is delayed by loading a track.
     Loading {
@@ -293,7 +293,8 @@ impl PlayerEvent {
                 play_request_id, ..
             }
             | Stopped {
-                play_request_id, ..
+                play_request_id: Some(play_request_id),
+                ..
             }
             | PositionCorrection {
                 play_request_id, ..
@@ -728,6 +729,7 @@ enum PlayerState {
         play_request_id: u64,
         start_playback: bool,
         loader: Pin<Box<dyn FusedFuture<Output = Result<PlayerLoadedTrackData, ()>> + Send>>,
+        position_ms: u32,
     },
     Paused {
         track_id: SpotifyUri,
@@ -1381,6 +1383,7 @@ impl Future for PlayerInternal {
                 ref track_id,
                 start_playback,
                 play_request_id,
+                ..
             } = self.state
             {
                 // The loader may be terminated if we are trying to load the same track
@@ -1696,8 +1699,8 @@ impl PlayerInternal {
 
                 self.ensure_sink_stopped(false);
                 self.send_event(PlayerEvent::Stopped {
-                    track_id,
-                    play_request_id,
+                    track_id: Some(track_id),
+                    play_request_id: Some(play_request_id),
                 });
                 self.state = PlayerState::Stopped;
             }
@@ -2175,6 +2178,7 @@ impl PlayerInternal {
             play_request_id,
             start_playback: play,
             loader,
+            position_ms,
         };
 
         Ok(())
@@ -2318,7 +2322,57 @@ impl PlayerInternal {
 
             PlayerCommand::SetSession(session) => self.session = session,
 
-            PlayerCommand::AddEventSender(sender) => self.event_senders.push(sender),
+            PlayerCommand::AddEventSender(sender) => {
+                // Send current player state to new event listener
+                match self.state {
+                    PlayerState::Loading {
+                        ref track_id,
+                        play_request_id,
+                        position_ms,
+                        ..
+                    } => {
+                        let _ = sender.send(PlayerEvent::Loading {
+                            play_request_id,
+                            track_id: track_id.clone(),
+                            position_ms,
+                        });
+                    }
+                    PlayerState::Paused {
+                        ref track_id,
+                        play_request_id,
+                        stream_position_ms,
+                        ..
+                    } => {
+                        let _ = sender.send(PlayerEvent::Paused {
+                            play_request_id,
+                            track_id: track_id.clone(),
+                            position_ms: stream_position_ms,
+                        });
+                    }
+                    PlayerState::Playing { ref audio_item, .. } => {
+                        let audio_item = Box::new(audio_item.clone());
+                        let _ = sender.send(PlayerEvent::TrackChanged { audio_item });
+                    }
+                    PlayerState::EndOfTrack {
+                        play_request_id,
+                        ref track_id,
+                        ..
+                    } => {
+                        let _ = sender.send(PlayerEvent::EndOfTrack {
+                            play_request_id,
+                            track_id: track_id.clone(),
+                        });
+                    }
+                    PlayerState::Invalid | PlayerState::Stopped => {
+                        let _ = sender.send(PlayerEvent::Stopped {
+                            play_request_id: None,
+                            track_id: None,
+                        });
+                    }
+                }
+
+                self.event_senders.push(sender);
+            }
 
             PlayerCommand::SetSinkEventCallback(callback) => self.sink_event_callback = callback,