From 13da595de082cb0841c74dc98644cb51a0ab370d Mon Sep 17 00:00:00 2001 From: James Babcock Date: Tue, 13 Oct 2026 16:17:07 -0700 Subject: [PATCH] Fix a bug where album art and track info could get out of sync if you advance twice quickly --- .../com/faceclaw/app/FaceclawMediaController.kt | 15 ++++++++++++++- CHANGELOG | 1 + app/apps/glanceboard/widgets/music-widget.ts | 9 ++++----- app/apps/music/music-app.ts | 15 ++++++++------- app/native/media-controller.ts | 9 +++++++++ .../callbacks/FaceclawMediaControllerListener.kt | 2 ++ 6 files changed, 38 insertions(+), 13 deletions(-) diff --git a/App_Resources/Android/src/main/java/com/faceclaw/app/FaceclawMediaController.kt b/App_Resources/Android/src/main/java/com/faceclaw/app/FaceclawMediaController.kt index b7f8ca5a..d7311dba 100644 --- a/App_Resources/Android/src/main/java/com/faceclaw/app/FaceclawMediaController.kt +++ b/App_Resources/Android/src/main/java/com/faceclaw/app/FaceclawMediaController.kt @@ -46,6 +46,7 @@ class FaceclawMediaController(context: Context) { override fun onMetadataChanged(metadata: MediaMetadata?) { synchronized(lock) { + artVersion++ emitStateLocked() } } @@ -92,6 +93,15 @@ class FaceclawMediaController(context: Context) { private var sessionsListenerRegistered = false private var ignoredPackages: Set = HashSet() + /** + * Bumped whenever the art getAlbumArtGray would return may have changed: + * every metadata update and every switch of active session. Players + * re-publish the same title/album with a different bitmap (art attached + * after download, or a stale bitmap from the previous track replaced + * after a quick double skip), so the strings can't key an art cache. + */ + private var artVersion = 0 + init { this.listenerComponent = ComponentName(appContext, FaceclawMediaNotificationListenerService::class.java) this.sessionManager = appContext.getSystemService(Context.MEDIA_SESSION_SERVICE) as MediaSessionManager? @@ -404,6 +414,7 @@ class FaceclawMediaController(context: Context) { previous.unregisterCallback(controllerCallback) } activeController = controller + artVersion++ if (controller != null) { controller.registerCallback(controllerCallback, mainHandler) } @@ -503,6 +514,7 @@ class FaceclawMediaController(context: Context) { val finalCanSkipPrevious = canSkipPrevious val finalAccessEnabled = accessEnabled val finalStatus = status + val finalArtVersion = artVersion mainHandler.post { currentListener.onStateChange( @@ -519,7 +531,8 @@ class FaceclawMediaController(context: Context) { finalCanSkipNext, finalCanSkipPrevious, finalAccessEnabled, - finalStatus + finalStatus, + finalArtVersion ) } } diff --git a/CHANGELOG b/CHANGELOG index 8ac7642b..c28fd130 100644 --- a/CHANGELOG +++ b/CHANGELOG @@ -11,6 +11,7 @@ * Phone preview is centered on the phone screen when apps are not maximized * iOS: Add missing EvenHub icons on the phone home screen +* Fix a bug where album art and track display could get out of sync if you advance twice quickly ## 0.8.3 - 2026-10-10 diff --git a/app/apps/glanceboard/widgets/music-widget.ts b/app/apps/glanceboard/widgets/music-widget.ts index f94418e3..7b1b8e76 100644 --- a/app/apps/glanceboard/widgets/music-widget.ts +++ b/app/apps/glanceboard/widgets/music-widget.ts @@ -49,7 +49,8 @@ export class MusicWidget implements GlanceWidget { private unsubscribe: (() => void) | null = null; private progressTimer: ReturnType | null = null; private art: GrayImage | null = null; - private artKey = ""; + /** The artVersion `art` was fetched for; -1 = not fetched yet. */ + private artVersion = -1; start(requestRender: () => void): void { this.unsubscribe = mediaControllerBridge.onStateChange((state) => { @@ -129,10 +130,8 @@ export class MusicWidget implements GlanceWidget { } private drawArt(image: GrayImage, media: MediaControllerState, artY: number): void { - const key = `${media.packageName}|${media.title}|${media.album}`; - // Retry while null: players often publish metadata before the bitmap. - if (key !== this.artKey || this.art === null) { - this.artKey = key; + if (media.artVersion !== this.artVersion) { + this.artVersion = media.artVersion; this.art = mediaControllerBridge.getAlbumArt(ART_SIZE); } if (this.art) { diff --git a/app/apps/music/music-app.ts b/app/apps/music/music-app.ts index 5d7e24ff..ed0160d2 100644 --- a/app/apps/music/music-app.ts +++ b/app/apps/music/music-app.ts @@ -83,7 +83,8 @@ class MusicAppLayer implements Layer { */ private libraryAppsFresh = false; private art: GrayImage | null = null; - private artKey = ""; + /** The artVersion `art` was fetched for; -1 = not fetched yet. */ + private artVersion = -1; isPlaylistFocused(): boolean { return this.focusColumn === "playlist"; @@ -371,12 +372,12 @@ class MusicAppLayer implements Layer { } private drawArt(image: GrayImage, media: MediaControllerState): void { - const key = `${media.packageName}|${media.title}|${media.album}`; - // Retry while null: players (e.g. Spotify) often publish metadata before - // the art bitmap is downloaded, then re-emit the same strings with the - // bitmap attached. The no-art fetch path is a cheap near-no-op. - if (key !== this.artKey || this.art === null) { - this.artKey = key; + // Keyed on artVersion, not the strings: players (e.g. Spotify) publish + // metadata before the art bitmap is downloaded, or with the previous + // track's bitmap after a quick double skip, then re-emit the same + // strings with the right bitmap attached. + if (media.artVersion !== this.artVersion) { + this.artVersion = media.artVersion; this.art = mediaControllerBridge.getAlbumArt(ART_SIZE); } if (this.art) { diff --git a/app/native/media-controller.ts b/app/native/media-controller.ts index e81a98e9..caee371b 100644 --- a/app/native/media-controller.ts +++ b/app/native/media-controller.ts @@ -37,6 +37,12 @@ export type MediaControllerState = { canPlayPause: boolean; canSkipNext: boolean; canSkipPrevious: boolean; + /** + * Changes whenever getAlbumArt's result may have changed (any metadata + * update or session switch). Key cached art on this, not the title: + * players re-publish the same strings with a different bitmap. + */ + artVersion: number; }; const DEFAULT_MEDIA_STATE: MediaControllerState = { @@ -55,6 +61,7 @@ const DEFAULT_MEDIA_STATE: MediaControllerState = { canPlayPause: false, canSkipNext: false, canSkipPrevious: false, + artVersion: 0, }; export class FaceclawMediaControllerBridge { @@ -206,6 +213,7 @@ export class FaceclawMediaControllerBridge { canSkipPrevious: boolean, accessEnabled: boolean, status: string, + artVersion: number, ) => { this.state = { available: Boolean(title || artist || album || packageName) || String(playbackState) !== "idle", @@ -223,6 +231,7 @@ export class FaceclawMediaControllerBridge { canPlayPause: Boolean(canPlayPause), canSkipNext: Boolean(canSkipNext), canSkipPrevious: Boolean(canSkipPrevious), + artVersion: Number(artVersion), }; this.stateUpdatedAtMs = Date.now(); for (const listener of this.stateListeners) { diff --git a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/callbacks/FaceclawMediaControllerListener.kt b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/callbacks/FaceclawMediaControllerListener.kt index 8b887dae..7495606e 100644 --- a/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/callbacks/FaceclawMediaControllerListener.kt +++ b/native/kotlin/shared/src/commonMain/kotlin/com/faceclaw/app/callbacks/FaceclawMediaControllerListener.kt @@ -4,6 +4,7 @@ interface FaceclawMediaControllerListener { /** All observed session owners, before filtering or choosing the active player. */ fun onSessionAppsChanged(appsJson: String?): Unit + /** artVersion changes whenever the current item's album art may have changed. */ fun onStateChange( playbackState: String?, packageName: String?, @@ -19,5 +20,6 @@ interface FaceclawMediaControllerListener { canSkipPrevious: Boolean, accessEnabled: Boolean, status: String?, + artVersion: Int, ): Unit }