From c3696f02d42401591dea1e2f014a416dbb60edf7 Mon Sep 17 00:00:00 2001 From: vicrodh <103399283+vicrodh@users.noreply.github.com> Date: Mon, 16 Feb 2026 20:08:34 -0600 Subject: [PATCH] fix(playback): harden auto-advance for long-track edge cases cx --- src-tauri/src/commands_v2.rs | 11 +++++++++++ src-tauri/src/lib.rs | 11 ++++++++--- src/routes/+page.svelte | 33 ++++++++++++++++++++++++++++++++- 3 files changed, 51 insertions(+), 4 deletions(-) diff --git a/src-tauri/src/commands_v2.rs b/src-tauri/src/commands_v2.rs index d410e7de0..383ee8fd3 100644 --- a/src-tauri/src/commands_v2.rs +++ b/src-tauri/src/commands_v2.rs @@ -4208,6 +4208,17 @@ pub async fn v2_play_next_gapless( let bridge_guard = bridge.get().await; let player = bridge_guard.player(); + let current_track_id = player.state.current_track_id(); + + // Defensive guard: never queue the currently playing track as "next". + // This avoids infinite one-track loops when frontend queue state is stale. + if current_track_id != 0 && current_track_id == track_id { + log::warn!( + "[V2/GAPLESS] Ignoring play_next_gapless for current track {}", + track_id + ); + return Ok(false); + } // Check offline cache (persistent disk cache) { diff --git a/src-tauri/src/lib.rs b/src-tauri/src/lib.rs index 0b01100cc..4d60dce58 100644 --- a/src-tauri/src/lib.rs +++ b/src-tauri/src/lib.rs @@ -471,12 +471,17 @@ pub fn run() { }; tokio::time::sleep(sleep_duration).await; - // Only emit if state changed or position advanced - let should_emit = track_id != 0 && ( + // Emit when: + // 1) normal in-track state changes/position updates, or + // 2) terminal transition to no-track (track_id becomes 0). + // Case (2) is required so frontend can run end-of-track fallback + // auto-advance paths reliably. + let track_cleared = track_id == 0 && last_track_id != 0; + let should_emit = (track_id != 0 && ( is_playing != last_is_playing || track_id != last_track_id || (is_playing && position != last_position) - ); + )) || track_cleared; let should_update_mpris = should_emit || (track_id == 0 && last_track_id != 0); diff --git a/src/routes/+page.svelte b/src/routes/+page.svelte index e0a7998fe..74b0cfa3e 100644 --- a/src/routes/+page.svelte +++ b/src/routes/+page.svelte @@ -2892,8 +2892,27 @@ setIsPlaying(false); return; } + const previousTrackId = currentTrack?.id ?? null; const nextTrackResult = await nextTrack(); if (nextTrackResult) { + // Defensive fallback for issue #80: + // if backend returns same track on auto-advance while repeat-one is off, + // force one additional advance attempt to break one-track loops. + if ( + previousTrackId !== null && + nextTrackResult.id === previousTrackId && + repeatMode !== 'one' + ) { + console.warn( + '[Player] Auto-advance returned same track id, forcing one extra nextTrack()', + previousTrackId + ); + const forcedNext = await nextTrack(); + if (forcedNext && forcedNext.id !== previousTrackId) { + await playQueueTrack(forcedNext); + return; + } + } await playQueueTrack(nextTrackResult); } else { // Queue ended - stop playback and clear player @@ -2971,7 +2990,19 @@ try { const queueState = getQueueState(); if (queueState.queue.length > 0) { - return Number(queueState.queue[0].id); + const firstId = Number(queueState.queue[0].id); + const currentId = currentTrack?.id ?? null; + if (!Number.isNaN(firstId) && firstId > 0 && firstId !== currentId) { + return firstId; + } + + // Defensive fallback: skip stale first slot if it matches current track. + if (queueState.queue.length > 1) { + const secondId = Number(queueState.queue[1].id); + if (!Number.isNaN(secondId) && secondId > 0 && secondId !== currentId) { + return secondId; + } + } } } catch { // Ignore