1 files changed, 50 insertions, 21 deletions

diff --git a/src/mpris.rs b/src/mpris.rs
index 3fc706d..de19113 100644
--- a/src/mpris.rs
+++ b/src/mpris.rs
@@ -22,7 +22,7 @@ use std::path::PathBuf;
 use std::sync::atomic::AtomicBool;
 use std::sync::{Arc, Mutex, RwLock};
 use std::thread;
-use std::time::Duration;
+use std::time::{Duration, Instant};
 use zbus::blocking::Connection;
 use zbus::interface;
 use zbus::zvariant::{ObjectPath, Value};
@@ -101,14 +101,17 @@ pub struct MprisPlayer {
     loop_status: Arc<Mutex<String>>,
 }
 
+/// `mpris:trackid` advertised for whatever is playing. The spec only requires it to be a stable
+/// object path that changes per track; clients echo it back in `SetPosition`.
+const CURRENT_TRACK_ID: &str = "/org/mpris/MediaPlayer2/TrackList/CurrentTrack";
+
 /// Build the `Metadata` map (a{sv}) required by MPRIS, using only owned values
 /// so no borrowing from locals.
 fn build_metadata(track: &Track) -> HashMap<String, Value<'static>> {
     let mut map: HashMap<String, Value<'static>> = HashMap::new();
 
     // `mpris:trackid` is typed as an object path (`o`) in the spec, not as a string.
-    let trackid = ObjectPath::try_from("/org/mpris/MediaPlayer2/TrackList/CurrentTrack")
-        .expect("static object path");
+    let trackid = ObjectPath::try_from(CURRENT_TRACK_ID).expect("static object path");
     map.insert("mpris:trackid".into(), Value::new(trackid));
 
     let length_us = track
@@ -273,12 +276,23 @@ impl MprisPlayer {
         }
     }
 
-    fn seek(&self, _offset: i64) {
-        // Seeking not implemented yet.
+    fn seek(&self, offset: i64) {
+        let target = (self.audio.position() + offset as f64 / 1_000_000.0).max(0.0);
+        crate::debug_eprintln(format_args!("mpris: seek by {}us", offset));
+        self.audio.seek(target);
     }
 
-    fn set_position(&self, _track_id: zbus::zvariant::ObjectPath<'_>, _position: i64) {
-        // Seeking not implemented yet.
+    fn set_position(&self, track_id: zbus::zvariant::ObjectPath<'_>, position: i64) {
+        // The spec says to ignore the request when the id is not the track we are playing.
+        if track_id.as_str() != CURRENT_TRACK_ID {
+            crate::debug_eprintln(format_args!(
+                "mpris: ignoring SetPosition for foreign track {}",
+                track_id.as_str()
+            ));
+            return;
+        }
+        crate::debug_eprintln(format_args!("mpris: set position to {}us", position));
+        self.audio.seek((position as f64 / 1_000_000.0).max(0.0));
     }
 
     fn open_uri(&self, uri: String) {
@@ -446,7 +460,7 @@ impl MprisPlayer {
 
     #[zbus(property)]
     fn can_seek(&self) -> bool {
-        false
+        true
     }
 
     #[zbus(property)]
@@ -543,6 +557,7 @@ pub fn start_mpris_server(
             let mut last_volume: Option<f64> = None;
             let mut last_shuffle: Option<ShuffleMode> = None;
             let mut last_loop: Option<String> = None;
+            let mut last_position: Option<(Instant, i64)> = None;
 
             while !shutdown_flag.load(std::sync::atomic::Ordering::SeqCst) {
                 let status = playback_status(&poll_audio);
@@ -610,25 +625,39 @@ pub fn start_mpris_server(
                     }
                 }
 
-                // A different track (or none at all) means the playhead jumped, which is what
-                // `Seeked` exists for. Clients use it to reset their progress bar without
-                // having to notice that two consecutive tracks happen to share a length.
-                if track_changed {
-                    let position_us = if track.is_some() {
-                        (poll_audio.position() * 1_000_000.0) as i64
-                    } else {
-                        0
-                    };
-                    if let Err(e) = conn.emit_signal(
+                // A different track, or a position that is nowhere near where the playhead
+                // should be by now, means it jumped — which is what `Seeked` exists for. Clients
+                // use it to reset their progress bar without having to notice that two
+                // consecutive tracks happen to share a length. The steady tick is intentionally
+                // not signalled: the spec tells clients to interpolate while we report `Playing`.
+                let position_us = if track.is_some() {
+                    (poll_audio.position() * 1_000_000.0) as i64
+                } else {
+                    0
+                };
+                let jumped = match last_position {
+                    Some((at, seen)) if !track_changed => {
+                        let expected = if status == "Playing" {
+                            seen + at.elapsed().as_micros() as i64
+                        } else {
+                            seen
+                        };
+                        (position_us - expected).abs() > 1_500_000
+                    }
+                    _ => false,
+                };
+                if (track_changed || jumped)
+                    && let Err(e) = conn.emit_signal(
                         None::<&str>,
                         "/org/mpris/MediaPlayer2",
                         "org.mpris.MediaPlayer2.Player",
                         "Seeked",
                         &(position_us,),
-                    ) {
-                        crate::debug_eprintln(format_args!("mpris: failed to emit Seeked: {}", e));
-                    }
+                    )
+                {
+                    crate::debug_eprintln(format_args!("mpris: failed to emit Seeked: {}", e));
                 }
+                last_position = Some((Instant::now(), position_us));
 
                 last_status = Some(status);
                 last_track = track;