album cover / song playing desync

[BaylieBuffel]

Describe the bug
it shows the last album cover instead of the current one (also shows a different song playing on other devices)

To Reproduce
Steps to reproduce the behavior:

1. play a song
2. add a song with a different album cover into the queue
3. play the next song
4. see wrong album cover / wrong song playing on other devices

Expected behavior
see the right album cover when playing a song

Desktop (please complete the following information):

• OS: Cachyos
• Terminal Kitty
• Version 0.40.2

[BaylieBuffel]

not sure but it might be related that the spotatui queue is independant of the spotify queue

[BaylieBuffel]

i got opencode to fix the problem and here is the fix that it used idk if its a good fix tho

Bug: Snapshot shows previous track's album art after advancing through the queue (native streaming)

Affected version: v0.40.2
Platform: CachyOS (Arch Linux), Kitty terminal
Build: cargo run (default features)

Description

When using native streaming (librespot), advancing to the next track via the queue causes the playback snapshot's image_url (used by Discord RPC, MPRIS metadata, history sync, and the cover-art image system) to show the previous track's album art instead of the current track's.

Root cause

The bug is a race between two timing-dependent systems:

1. TrackChanged (from librespot) fires immediately when the native player advances. It sets native_track_info with the new track's metadata and dispatches GetCurrentPlayback.

2. get_current_playback() (src/infra/network/playback.rs) polls the Spotify Web API (GET /v1/me/player). Because Spotify's servers lag behind librespot by several seconds, the API response still contains the previous track's item (including its album art URL). The function detects this staleness via stale_api_item_should_preserve_native_context() and deliberately skips updating current_playback_context to avoid overwriting native metadata with stale API data.

3. current_playback_snapshot() (src/infra/media_metadata.rs) builds the snapshot used by the UI, Discord RPC, MPRIS, etc. When native metadata is active, it reads image_url from current_playback_context.item. Since the context was not updated (stale guard), image_url still holds the previous track's album art URL.

4. The cover-art evaluation loop in runner.rs compares the snapshot's image_url against last_cover_art_key. Because the stale URL matches the old key, no new fetch is dispatched — the system thinks art is already loaded.

Net effect: The snapshot (and everything that reads it) shows the previous track's album art until the Spotify API eventually catches up and current_playback_context is updated with the correct track.

Reproduction steps

1. Launch spotatui with native streaming (default features, Spotify account required)
2. Play any track (Track A)
3. Add a track from a different album to the queue (Track B)
4. Press Next to advance to Track B
5. Observe: snapshot still shows Track A's album art, name, or other metadata depending on which system reads it
6. Other Spotify Connect devices also show Track A (separate server-side latency issue)

Fix

The fix adds a dedicated Spotify Web API call (GET /v1/tracks/{track_id}) that fires when the playback API context is stale, fetching the correct album art for the current native track.

Files changed

File	Change
src/core/app.rs	Added image_url: Option<String> field to NativeTrackInfo struct
src/infra/network/mod.rs	Added IoEvent::FetchNativeTrackArt(String) variant and match arm in handle_network_event
src/infra/network/playback.rs	Added FetchNativeTrackArt to PlaybackNetwork trait, added fetch_native_track_art() implementation, and dispatch from get_current_playback() when stale
src/infra/media_metadata.rs	Updated current_playback_snapshot() to prefer native_info.image_url over the stale context item
Various test files	Added image_url: None to all NativeTrackInfo construction sites

Patch

--- a/src/core/app.rs
+++ b/src/core/app.rs
@@ -769,6 +769,10 @@ pub struct NativeTrackInfo {
   #[allow(dead_code)]
   pub album: String, // Reserved for future use (e.g., displaying album in playbar)
   pub duration_ms: u32,
   pub kind: NativeTrackKind,
+  /// Album art URL fetched from the Spotify tracks endpoint, populated when the
+  /// playback API lags behind native librespot and the stale context item holds
+  /// the *previous* track's image.
+  pub image_url: Option<String>,
 }

--- a/src/infra/network/mod.rs
+++ b/src/infra/network/mod.rs
@@ -44,6 +44,11 @@ use self::utils::UtilsNetwork;
 pub enum IoEvent {
   GetCurrentPlayback,
+  /// Fetch album art for a native-streaming track whose Spotify playback API
+  /// context still holds the previous track's item (stale lag).  The payload
+  /// is the track id string (bare base62 or `spotify:track:` URI).
+  #[allow(dead_code)]
+  FetchNativeTrackArt(String),
   /// After a track transition (e.g., EndOfTrack), ensure we don't end up paused on the next item.
   /// The payload is the previous track identifier (either base62 id or a `spotify:track:` URI).
   #[allow(dead_code)]
@@ -440,6 +445,9 @@ impl Network {
       IoEvent::GetCurrentPlayback => {
         self.get_current_playback().await;
       }
+      IoEvent::FetchNativeTrackArt(track_id) => {
+        self.fetch_native_track_art(track_id).await;
+      }
       IoEvent::GetSearchResults(search_term, country) => {

--- a/src/infra/network/playback.rs
+++ b/src/infra/network/playback.rs
@@ -71,6 +71,10 @@ pub trait PlaybackNetwork {
   #[cfg(feature = "cover-art")]
   async fn fetch_cover_art(&mut self, request: crate::tui::cover_art::CoverArtRequest);
+  /// Fetch album art for a native-streaming track whose Spotify playback API
+  /// context still holds the previous track's item (stale lag).  Stores the
+  /// image URL in `app.native_track_info.image_url`.
+  #[allow(dead_code)]
+  async fn fetch_native_track_art(&mut self, track_id: String);
 }

@@ -913,6 +917,15 @@ impl PlaybackNetwork for Network {
           app.current_playback_context = Some(c);
         }

+        // When the API context is stale, the context item still holds the
+        // *previous* track's album art.  Fetch the correct art for the current
+        // native track via the dedicated tracks endpoint so the cover-art
+        // system can display the right image.
+        #[cfg(feature = "streaming")]
+        if stale_api_item_for_native {
+          if let Some(ref track_id) = app.last_track_id {
+            let tid = track_id.clone();
+            app.dispatch(IoEvent::FetchNativeTrackArt(tid));
+          }
+        }

@@ -1100,6 +1113,41 @@ impl PlaybackNetwork for Network {
     }
   }

+  /// Fetch the album art URL for a track via the Spotify tracks endpoint and
+  /// store it in `app.native_track_info.image_url`.  Called when the playback
+  /// API context is stale (still holds the previous track's item) so the
+  /// cover-art system can display the correct image for the current native track.
+  #[allow(dead_code)]
+  async fn fetch_native_track_art(&mut self, track_id: String) {
+    use super::ids;
+    use rspotify::model::track::FullTrack;
+
+    let track_id_owned = match ids::track_id(&track_id) {
+      Some(id) => id,
+      None => return,
+    };
+
+    let result = self
+      .spotify_get_typed::<FullTrack>(&format!("tracks/{}", track_id_owned.id()), &[])
+      .await;
+
+    match result {
+      Ok(track) => {
+        let image_url = track
+          .album
+          .images
+          .into_iter()
+          .max_by_key(|img| img.width.unwrap_or(0))
+          .map(|img| img.url);
+
+        let mut app = self.app.lock().await;
+        if let Some(ref mut native_info) = app.native_track_info {
+          native_info.image_url = image_url;
+        }
+      }
+      Err(e) => {
+        log::warn!("fetch_native_track_art failed for {track_id}: {e}");
+      }
+    }
+  }

--- a/src/infra/media_metadata.rs
+++ b/src/infra/media_metadata.rs
@@ -91,17 +91,28 @@ pub fn current_playback_snapshot(app: &App) -> Option<PlaybackSnapshot> {
       .map(|id| playback_uri_for_item_kind(item_kind, id));
-    // Only trust the context item's image URL when the item actually belongs to
-    // the current native track.  After a track change, native_track_info updates
-    // immediately but the Spotify API lags — current_playback_context still holds
-    // the *previous* track's item.  Using that stale image URL causes cover art
-    // to show the wrong album: the key matches the old art, so no new fetch is
-    // dispatched.  Falling back to None lets the cover-art system clear the stale
-    // image and show a placeholder until the API catches up.
+    // Only trust the context item's image URL when the item actually belongs to
+    // the current native track.  After a track change, native_track_info updates
+    // immediately but the Spotify API lags — current_playback_context still holds
+    // the *previous* track's item.  Using that stale image URL causes cover art
+    // to show the wrong album: the key matches the old art, so no new fetch is
+    // dispatched.
+    //
+    // Priority:
+    // 1. native_info.image_url — fetched by FetchNativeTrackArt when the context
+    //    item is stale; holds the correct art for the current native track.
+    // 2. Context item image — valid when context_has_stale_item is false (API
+    //    item matches the current track, or context is empty).
+    // 3. None — stale context with no native art yet; lets the cover-art system
+    //    show a placeholder until the async fetch completes.
     let context_item = context.and_then(|ctx| ctx.item.as_ref());
     let context_has_stale_item = context_item
       .and_then(|item| match item {
@@ -111,8 +122,12 @@ pub fn current_playback_snapshot(app: &App) -> Option<PlaybackSnapshot> {
       })
       .is_some_and(|ctx_id| Some(ctx_id.as_str()) != item_id.as_deref());
-    let image_url = if context_has_stale_item {
-      None
-    } else {
-      image_url_from_context_item(context_item)
+    let image_url = native_info.image_url.clone().or_else(|| {
+      if context_has_stale_item {
+        None
+      } else {
+        image_url_from_context_item(context_item)
+      }
+    });

How it works

1. TrackChanged → sets native_track_info (with image_url: None) → dispatches GetCurrentPlayback
2. get_current_playback() → API is stale → dispatches FetchNativeTrackArt(track_id) → does not update context
3. fetch_native_track_art() → calls GET /v1/tracks/{id} → extracts album art URL → stores in native_track_info.image_url
4. Next tick → current_playback_snapshot() uses native_info.image_url (correct URL) instead of stale context item

The native_track_info is preserved (not cleared) when stale, so FetchNativeTrackArt can safely store the URL. When the API eventually catches up, native_track_info is cleared and the snapshot falls back to the now-correct context item.

Note on other devices

Other Spotify Connect devices showing the wrong song/album after advancing is a separate server-side latency issue — Spotify's GET /v1/me/player endpoint lags behind librespot's actual playback state by several seconds. This is inherent to Spotify's architecture and cannot be fully resolved client-side. The fix above only addresses the local snapshot/UI state.

[BaylieBuffel]

test tui::ui::plugin_screen::tests::cover_art_image_slot_restores_the_theme_background ... FAILED when compiling the new build

[BaylieBuffel]

on the aur spotatui-git release