diff --git a/crates/qconnect-app/src/renderer.rs b/crates/qconnect-app/src/renderer.rs index b78e35187..f4f7ecbe3 100644 --- a/crates/qconnect-app/src/renderer.rs +++ b/crates/qconnect-app/src/renderer.rs @@ -7,7 +7,33 @@ //! audio-quality report helpers move here alongside their orchestration / //! report consumers in the later slice-6 steps. +use std::collections::HashMap; +use std::sync::Arc; +use std::time::{Duration, Instant}; + use qbz_models::{QueueTrack, RepeatMode, Track}; +use qbz_player::PlaybackState; +use tokio::sync::Mutex; + +use crate::queue_resolution::{ + dedupe_track_ids, resolve_core_shuffle_order, resolve_remote_start_index, +}; +use crate::renderer_engine::QconnectRendererEngine; +use crate::session::quality_from_max_audio_quality; +use crate::{QConnectQueueState, QConnectRendererState, QconnectRemoteSyncState, RendererCommand}; + +/// QConnect protocol `playing_state` wire values. Single source of truth for the +/// renderer orchestration; the Tauri adapter re-exports these from here. +pub const PLAYING_STATE_UNKNOWN: i32 = 0; +pub const PLAYING_STATE_STOPPED: i32 = 1; +pub const PLAYING_STATE_PLAYING: i32 = 2; +pub const PLAYING_STATE_PAUSED: i32 = 3; + +/// Dedup window: an echoed SetState for a track whose load was registered within +/// this window does not re-trigger the load. The audio thread updates +/// `playback_state.track_id` only after the engine appends the source, so a bare +/// `track_id` comparison would re-fire during that buffer/decode gap. +const LOAD_ATTEMPT_DEDUP_WINDOW: Duration = Duration::from_secs(5); /// Source tag stamped on remote queue tracks materialized from a QConnect cloud /// queue. Matches the Tauri adapter's prior `QCONNECT_REMOTE_QUEUE_SOURCE`. @@ -72,3 +98,629 @@ pub fn model_track_to_core_queue_track(track: &Track) -> QueueTrack { source_item_id_hint: album_id, } } + +// ===================== Renderer orchestration (slice 6, step 6) ===================== +// +// Engine-agnostic: written ONLY against `QconnectRendererEngine` + the shared +// `QconnectRemoteSyncState`. The Tauri/Slint adapters obtain a concrete engine +// (`&CoreBridge` / `&SlintEngine`) — including any "not initialized yet" guard — +// and dispatch here, so the hard-won echo/cursor/materialize/shuffle logic is +// never re-derived per frontend. Ported byte-for-byte from the prior Tauri +// `corebridge.rs` / `track_loading.rs`; only `bridge` -> `engine` and the +// guard-unwrap (which stays adapter-side) changed. + +pub fn queue_state_needs_materialization( + previous: Option<&QConnectQueueState>, + next: &QConnectQueueState, +) -> bool { + let Some(previous) = previous else { + return true; + }; + + previous.version != next.version + || previous.queue_items != next.queue_items + || previous.shuffle_mode != next.shuffle_mode + || previous.shuffle_order != next.shuffle_order + || previous.autoplay_mode != next.autoplay_mode + || previous.autoplay_loading != next.autoplay_loading + || previous.autoplay_items != next.autoplay_items +} + +pub fn should_reload_remote_track(playback_state: &PlaybackState, track_id: u64) -> bool { + // Only reload when the track ID actually changed. The previous + // !has_loaded_audio gate fired during the buffering window of an + // initial load (qbz already started fetching but the audio engine + // hasn't reported the track as loaded yet) — when the cloud echo + // SetState arrived for the same track, this caused a redundant + // load that interrupted the in-progress one. That was the residual + // first-track hiccup. + playback_state.track_id != track_id +} + +/// Returns true if a load attempt for `track_id` was registered within the +/// dedup window (see `LOAD_ATTEMPT_DEDUP_WINDOW`). +fn is_recent_load_attempt(state: &QconnectRemoteSyncState, track_id: u64) -> bool { + match state.last_load_attempt { + Some((tid, ts)) => tid == track_id && ts.elapsed() < LOAD_ATTEMPT_DEDUP_WINDOW, + None => false, + } +} + +/// Load a remote track into the engine, deduped against echoed SetState frames. +/// Records the attempt BEFORE dispatching the load (the audio thread updates +/// `playback_state.track_id` only after the engine appends the source, so the +/// recording must precede the load to close the echo window). +pub async fn ensure_remote_track_loaded( + engine: &impl QconnectRendererEngine, + sync_state: &Arc>, + track_id: u64, + max_audio_quality: Option, +) -> Result<(), String> { + { + let state = sync_state.lock().await; + if is_recent_load_attempt(&state, track_id) { + return Ok(()); + } + } + let playback_state = engine.get_playback_state(); + if !should_reload_remote_track(&playback_state, track_id) { + return Ok(()); + } + + { + let mut state = sync_state.lock().await; + state.last_load_attempt = Some((track_id, Instant::now())); + } + + let quality = quality_from_max_audio_quality(max_audio_quality); + let duration_secs = engine + .get_track(track_id) + .await + .map(|track| u64::from(track.duration)) + .unwrap_or(0); + // QConnect tracks always start from 0; resume is local-only. The protected + // bit-perfect seams + the HTTP feeder live behind `start_track_stream`. + engine + .start_track_stream(track_id, quality, duration_secs, 0) + .await +} + +pub async fn apply_remote_loop_mode( + engine: &impl QconnectRendererEngine, + loop_mode: i32, +) -> Result<(), String> { + let repeat_mode = qconnect_repeat_mode_from_loop_mode(loop_mode) + .ok_or_else(|| format!("unsupported qconnect loop mode: {loop_mode}"))?; + engine.set_repeat_mode(repeat_mode).await; + Ok(()) +} + +pub async fn apply_renderer_command( + engine: &impl QconnectRendererEngine, + sync_state: &Arc>, + command: &RendererCommand, + renderer_state: &QConnectRendererState, +) -> Result<(), String> { + match command { + RendererCommand::SetState { + playing_state, + current_position_ms, + current_track, + next_track, + .. + } => { + let resolved_playing_state = renderer_state.playing_state.or(*playing_state); + let mut projection_renderer_state = renderer_state.clone(); + if projection_renderer_state.current_track.is_none() { + projection_renderer_state.current_track = current_track.clone(); + } + if projection_renderer_state.next_track.is_none() { + projection_renderer_state.next_track = next_track.clone(); + } + let resolved_current_track = projection_renderer_state.current_track.as_ref(); + if let Some(projected_track) = resolved_current_track { + let queue_state = { + let state = sync_state.lock().await; + state.last_remote_queue_state.clone() + }; + let projection_applied = if let Some(queue_state) = queue_state.as_ref() { + sync_remote_shuffle_projection( + engine, + sync_state, + queue_state, + &projection_renderer_state, + ) + .await? + } else { + false + }; + + // Track-manipulation operations (cursor align, force-restart, + // ensure_remote_track_loaded) only run when the COMMAND + // explicitly specifies a current_track. The projection's + // resolved_current_track can be stale: when the cloud sends + // a state-only update (pause/resume) with command.current_track=null, + // the projection falls back to renderer_state.current_track, + // which is the cloud's last-known view of qbz's playback — + // potentially behind qbz's actual local advance. Using that + // stale value to align/load causes spurious track switches + // (e.g., pause from iOS made qbz jump back to a previous + // track). The outer renderer_state-based projection is still + // used for shuffle sync above and downstream playing_state / + // seek operations, which remain safe because they don't + // change the queue cursor or load tracks. + let _ = projected_track; // retained for shuffle projection above + if let Some(command_track) = current_track.as_ref() { + if !projection_applied { + if let Err(err) = + align_queue_cursor(engine, command_track.track_id).await + { + log::warn!( + "[QConnect] Failed to align CoreBridge queue cursor: {err}" + ); + } + } + + if matches!( + resolved_playing_state, + Some(PLAYING_STATE_PLAYING | PLAYING_STATE_PAUSED) + ) { + // Force-restart removed: the cloud routinely re-emits + // SetState with current_position_ms=0 for the same + // track when only secondary fields change (e.g., + // next_track corrections, queue_item_id refreshes). + // Reloading the stream on every echo caused first- + // track hiccup on album change and "needs several + // taps" on prev/next. Track-change cases are handled + // by align_queue_cursor + ensure_remote_track_loaded + // below; legitimate seek-to-start from a peer + // controller can use the seek path with target>1s. + if let Err(err) = ensure_remote_track_loaded( + engine, + sync_state, + command_track.track_id, + projection_renderer_state.max_audio_quality, + ) + .await + { + log::warn!( + "[QConnect] Failed to load remote track {}: {err}", + command_track.track_id + ); + } + } + } + } + + if let Some(value) = resolved_playing_state { + match value { + PLAYING_STATE_PLAYING => { + engine.resume()?; + } + PLAYING_STATE_PAUSED => { + engine.pause()?; + } + PLAYING_STATE_STOPPED => { + engine.stop()?; + } + PLAYING_STATE_UNKNOWN => {} + _ => { + log::debug!("[QConnect] Unknown playing state received: {value}"); + } + } + } + + if let Some(position_ms) = + renderer_state.current_position_ms.or(*current_position_ms) + { + let playback_state = engine.get_playback_state(); + let current_pos_secs = playback_state.position; + let target_secs = position_ms / 1000; + // Reject echo seeks: when the command targets the same track + // qbz is already playing AND target<=1s while local is well + // ahead, this is the cloud re-emitting a stale SetState + // (frequently fires on next_track corrections and queue_ + // item_id refreshes). A real peer "go to start" intent + // would target the same track as the local one but the + // round-trip to qbz is already a few seconds, making this + // case indistinguishable from echo — favor stability. + let is_echo_reset = current_track + .as_ref() + .map(|cmd_track| cmd_track.track_id == playback_state.track_id) + .unwrap_or(false) + && target_secs <= 1 + && current_pos_secs > 2; + // Issue #387: honor seeks regardless of which device is the + // active renderer. The previous gate (`peer_renderer_active`) + // skipped seeks entirely when local was the active renderer, + // breaking the case where a peer controller (e.g. official + // Qobuz mobile app) sends a real seek to qbz acting as the + // renderer — the audio thread never moved while the cloud + // state advanced, so the controller's progress bar locked. + // The is_echo_reset + abs_diff > 2 gates already filter the + // cloud-echo case the peer_renderer_active check was added + // to defend against in commit 147bcbd7. If hiccups return, + // revert this change and reintroduce a more targeted echo + // detector (UUID-based) instead of the all-or-nothing gate. + if !is_echo_reset && current_pos_secs.abs_diff(target_secs) > 2 { + log::info!( + "[QConnect] SetState seek: current={}s target={}s", + current_pos_secs, + target_secs + ); + engine.seek(target_secs)?; + } + } + } + RendererCommand::SetVolume { volume, .. } => { + if let Some(resolved) = renderer_state.volume.or(*volume) { + engine.set_volume(normalize_volume_to_fraction(resolved))?; + } + } + RendererCommand::MuteVolume { value } => { + if *value { + engine.set_volume(0.0)?; + } else if let Some(resolved) = renderer_state.volume { + engine.set_volume(normalize_volume_to_fraction(resolved))?; + } + } + RendererCommand::SetLoopMode { loop_mode } => { + let resolved_loop_mode = renderer_state.loop_mode.unwrap_or(*loop_mode); + let repeat_mode = qconnect_repeat_mode_from_loop_mode(resolved_loop_mode) + .ok_or_else(|| format!("unsupported qconnect loop mode: {resolved_loop_mode}"))?; + engine.set_repeat_mode(repeat_mode).await; + } + RendererCommand::SetActive { active } => { + if *active { + // Becoming the active renderer: preload the current track so + // playback can start immediately on the next SetState. + if let Some(current) = renderer_state.current_track.as_ref() { + if let Err(err) = ensure_remote_track_loaded( + engine, + sync_state, + current.track_id, + renderer_state.max_audio_quality, + ) + .await + { + log::warn!("[QConnect] SetActive(true) preload failed: {err}"); + } + } + } else { + engine.stop()?; + } + } + RendererCommand::SetMaxAudioQuality { max_audio_quality } => { + // Applied on the next load via renderer_state.max_audio_quality + // (recorded by the core reducer). No immediate re-fetch. + log::info!("[QConnect] SetMaxAudioQuality => {max_audio_quality}"); + } + RendererCommand::SetShuffleMode { shuffle_mode } => { + let enabled = renderer_state.shuffle_mode.unwrap_or(*shuffle_mode); + engine.set_shuffle(enabled).await; + } + } + + Ok(()) +} + +async fn sync_remote_shuffle_projection( + engine: &impl QconnectRendererEngine, + sync_state: &Arc>, + queue_state: &QConnectQueueState, + renderer_state: &QConnectRendererState, +) -> Result { + if !queue_state.shuffle_mode || queue_state.queue_items.is_empty() { + return Ok(false); + } + + let start_index = resolve_remote_start_index( + queue_state, + renderer_state + .current_track + .as_ref() + .map(|item| item.queue_item_id), + renderer_state + .current_track + .as_ref() + .map(|item| item.track_id), + ); + let Some(start_index) = start_index else { + return Ok(false); + }; + + let core_shuffle_order = resolve_core_shuffle_order( + queue_state, + renderer_state + .current_track + .as_ref() + .map(|item| item.queue_item_id), + renderer_state + .current_track + .as_ref() + .map(|item| item.track_id), + renderer_state + .next_track + .as_ref() + .map(|item| item.queue_item_id), + renderer_state.next_track.as_ref().map(|item| item.track_id), + ); + + // Same deferral rule as materialize_remote_queue: do not invent an + // identity shuffle when the cloud hasn't yet sent the authoritative + // shuffle_order. Wait for the second QueueUpdated. + if core_shuffle_order.is_none() { + return Ok(false); + } + + let should_apply = { + let state = sync_state.lock().await; + state.last_materialized_start_index != Some(start_index) + || state.last_materialized_core_shuffle_order != core_shuffle_order + }; + if !should_apply { + return Ok(false); + } + + let (tracks, _) = engine.get_all_queue_tracks().await; + if tracks.len() != queue_state.queue_items.len() || tracks.is_empty() { + return Ok(false); + } + + engine + .set_queue_with_order( + tracks, + Some(start_index), + queue_state.shuffle_mode, + core_shuffle_order.clone(), + ) + .await; + + let mut state = sync_state.lock().await; + state.last_materialized_start_index = Some(start_index); + state.last_materialized_core_shuffle_order = core_shuffle_order; + Ok(true) +} + +pub async fn materialize_remote_queue( + engine: &impl QconnectRendererEngine, + sync_state: &Arc>, + queue_state: &QConnectQueueState, +) -> Result<(), String> { + let ( + renderer_queue_item_id, + renderer_track_id, + renderer_next_queue_item_id, + renderer_next_track_id, + renderer_playing_state, + should_skip, + ) = { + let mut state = sync_state.lock().await; + if !queue_state_needs_materialization(state.last_applied_queue_state.as_ref(), queue_state) + { + ( + state.last_renderer_queue_item_id, + state.last_renderer_track_id, + state.last_renderer_next_queue_item_id, + state.last_renderer_next_track_id, + state.last_renderer_playing_state, + true, + ) + } else { + state.last_applied_queue_state = Some(queue_state.clone()); + ( + state.last_renderer_queue_item_id, + state.last_renderer_track_id, + state.last_renderer_next_queue_item_id, + state.last_renderer_next_track_id, + state.last_renderer_playing_state, + false, + ) + } + }; + + if should_skip { + log::debug!( + "[QConnect] materialize_remote_queue: skipped (identical snapshot {}.{})", + queue_state.version.major, + queue_state.version.minor + ); + return Ok(()); + } + + log::info!( + "[QConnect] materialize_remote_queue: version={}.{} items={} renderer_qid={:?} renderer_tid={:?} renderer_next_qid={:?} renderer_next_tid={:?} playing_state={:?}", + queue_state.version.major, + queue_state.version.minor, + queue_state.queue_items.len(), + renderer_queue_item_id, + renderer_track_id, + renderer_next_queue_item_id, + renderer_next_track_id, + renderer_playing_state + ); + + if queue_state.queue_items.is_empty() { + // Preserve legacy behavior: keep current track on qconnect sync clears. + engine.clear_queue(true).await; + engine.set_shuffle(false).await; + let mut state = sync_state.lock().await; + state.last_materialized_start_index = None; + state.last_materialized_core_shuffle_order = None; + return Ok(()); + } + + let unique_track_ids = dedupe_track_ids(queue_state); + let fetched_tracks = engine + .get_tracks_batch(&unique_track_ids) + .await + .map_err(|err| format!("fetch tracks batch for remote queue: {err}"))?; + + let mut tracks_by_id = HashMap::with_capacity(fetched_tracks.len()); + for track in fetched_tracks { + tracks_by_id.insert(track.id, model_track_to_core_queue_track(&track)); + } + + let mut queue_tracks = Vec::with_capacity(queue_state.queue_items.len()); + for item in &queue_state.queue_items { + if let Some(queue_track) = tracks_by_id.get(&item.track_id) { + queue_tracks.push(queue_track.clone()); + continue; + } + + match engine.get_track(item.track_id).await { + Ok(track) => { + let mapped = model_track_to_core_queue_track(&track); + tracks_by_id.insert(item.track_id, mapped.clone()); + queue_tracks.push(mapped); + } + Err(err) => { + log::warn!( + "[QConnect] Unable to hydrate remote queue track {}: {}", + item.track_id, + err + ); + } + } + } + + if queue_tracks.is_empty() { + return Err("remote queue materialization produced zero playable tracks".to_string()); + } + + // Resolve start index from remote state first, then from the local playback + // cursor only if that track is still part of the remote queue. + let current_playback_track_id = match engine.get_playback_state().track_id { + 0 => None, + track_id => Some(track_id), + }; + let mut start_index = + resolve_remote_start_index(queue_state, renderer_queue_item_id, renderer_track_id); + if start_index.is_none() { + start_index = resolve_remote_start_index( + queue_state, + renderer_next_queue_item_id, + renderer_next_track_id, + ) + .map(|index| index.saturating_sub(1)); + } + if start_index.is_none() { + start_index = current_playback_track_id.and_then(|track_id| { + queue_state + .queue_items + .iter() + .position(|item| item.track_id == track_id) + }); + } + if start_index.is_none() && !queue_tracks.is_empty() { + start_index = Some(0); + } + let core_shuffle_order = resolve_core_shuffle_order( + queue_state, + renderer_queue_item_id, + renderer_track_id, + renderer_next_queue_item_id, + renderer_next_track_id, + ); + // The cloud sends two QueueUpdated events during a shuffle toggle: + // first with shuffle_mode=true and shuffle_order=null (the flag + // broadcasts immediately), then ~400ms later with the computed + // shuffle_order. If we mark shuffle_enabled=true on the first event + // with an absent order, set_queue_with_order falls into its identity + // path (0,1,2,...) — that is qbz inventing a sequence that diverges + // from the order the cloud is about to authorize. Defer the engine + // shuffle activation until the authoritative order is present. + let effective_shuffle_enabled = queue_state.shuffle_mode && core_shuffle_order.is_some(); + log::info!( + "[QConnect] materialize_remote_queue: setting queue with {} tracks, start_index={:?}, local_track_id={:?}, remote_shuffle_mode={}, shuffle_order_present={}, engine_shuffle_enabled={}", + queue_tracks.len(), + start_index, + current_playback_track_id, + queue_state.shuffle_mode, + core_shuffle_order.is_some(), + effective_shuffle_enabled, + ); + engine + .set_queue_with_order( + queue_tracks, + start_index, + effective_shuffle_enabled, + core_shuffle_order.clone(), + ) + .await; + + { + let mut state = sync_state.lock().await; + state.last_materialized_start_index = start_index; + state.last_materialized_core_shuffle_order = core_shuffle_order; + } + + let local_track_missing_from_remote = current_playback_track_id + .map(|track_id| { + !queue_state + .queue_items + .iter() + .any(|item| item.track_id == track_id) + }) + .unwrap_or(true); + + if let Some(index) = start_index { + if local_track_missing_from_remote { + log::info!( + "[QConnect] materialize_remote_queue: aligning queue cursor to remote index {}", + index + ); + let _ = engine.play_index(index).await; + } + } + + if current_playback_track_id.is_some() + && current_playback_track_id != renderer_track_id + && local_track_missing_from_remote + && matches!( + renderer_playing_state, + Some(PLAYING_STATE_STOPPED | PLAYING_STATE_UNKNOWN) + ) + { + log::info!( + "[QConnect] materialize_remote_queue: stopping stale local playback track {:?} after remote queue replacement", + current_playback_track_id + ); + let _ = engine.stop(); + } + + Ok(()) +} + +pub async fn align_queue_cursor( + engine: &impl QconnectRendererEngine, + track_id: u64, +) -> Result<(), String> { + let (tracks, current_index) = engine.get_all_queue_tracks().await; + log::info!( + "[QConnect] align_queue_cursor: track_id={track_id} queue_len={} current_index={:?}", + tracks.len(), + current_index + ); + if let Some(target_index) = tracks.iter().position(|track| track.id == track_id) { + if current_index != Some(target_index) { + log::info!( + "[QConnect] align_queue_cursor: moving cursor from {:?} to {target_index}", + current_index + ); + let _ = engine.play_index(target_index).await; + } + return Ok(()); + } + + log::info!( + "[QConnect] align_queue_cursor: track {track_id} not in queue, fetching and creating single-track queue" + ); + let track = engine + .get_track(track_id) + .await + .map_err(|err| format!("fetch current remote track {track_id}: {err}"))?; + let queue_track = model_track_to_core_queue_track(&track); + engine.set_queue(vec![queue_track], Some(0)).await; + Ok(()) +} diff --git a/src-tauri/src/qconnect/corebridge.rs b/src-tauri/src/qconnect/corebridge.rs index d78a6c45f..8116d5519 100644 --- a/src-tauri/src/qconnect/corebridge.rs +++ b/src-tauri/src/qconnect/corebridge.rs @@ -1,10 +1,20 @@ -//! Bridge between cloud-emitted QConnect events and the local CoreBridge -//! audio engine. Owns the application of renderer commands (play/pause/ -//! seek), queue materialization (replicating the cloud's queue locally), -//! shuffle projection (without inventing a local order), and cursor -//! alignment. +//! Thin Tauri glue between cloud-emitted QConnect events and the local +//! `CoreBridge` audio engine. +//! +//! The renderer orchestration (apply renderer commands, queue materialize, +//! shuffle projection, cursor align, loop mode, load dedup) was hoisted into the +//! frontend-agnostic `qconnect_app::renderer` module (slice 6, step 6) so the +//! Slint adapter reuses it. What stays here is ONLY the adapter-specific work the +//! `&impl QconnectRendererEngine` boundary cannot express: unwrapping the +//! `Arc>>` "not initialized yet" guard before dispatch. +//! `CoreBridge` implements the trait (see `track_loading.rs`), so each wrapper +//! unwraps the guard and forwards `&CoreBridge`. +//! +//! Note: in operation `core_bridge` is populated at startup (before any QConnect +//! session can open), so the `else { return Err }` arms are unreachable; the +//! guard stays as a defensive invariant. This keeps behavior byte-identical to +//! the prior inline implementation. -use std::collections::HashMap; use std::sync::Arc; use qconnect_app::{QConnectQueueState, QConnectRendererState, RendererCommand}; @@ -12,47 +22,22 @@ use tokio::sync::{Mutex, RwLock}; use crate::core_bridge::CoreBridge; -use super::queue_resolution::{ - dedupe_track_ids, resolve_core_shuffle_order, resolve_remote_start_index, -}; -use super::track_loading::ensure_remote_track_loaded; -use super::{ - model_track_to_core_queue_track, normalize_volume_to_fraction, - qconnect_repeat_mode_from_loop_mode, QconnectRemoteSyncState, PLAYING_STATE_PAUSED, - PLAYING_STATE_PLAYING, PLAYING_STATE_STOPPED, PLAYING_STATE_UNKNOWN, -}; +use super::QconnectRemoteSyncState; -pub(super) fn queue_state_needs_materialization( - previous: Option<&QConnectQueueState>, - next: &QConnectQueueState, -) -> bool { - let Some(previous) = previous else { - return true; - }; - - previous.version != next.version - || previous.queue_items != next.queue_items - || previous.shuffle_mode != next.shuffle_mode - || previous.shuffle_order != next.shuffle_order - || previous.autoplay_mode != next.autoplay_mode - || previous.autoplay_loading != next.autoplay_loading - || previous.autoplay_items != next.autoplay_items -} +/// Re-exported for `tests.rs` (`super::corebridge::queue_state_needs_materialization`); +/// the non-test orchestration that consumed it moved to `qconnect_app::renderer`. +#[cfg(test)] +pub(super) use qconnect_app::renderer::queue_state_needs_materialization; pub(super) async fn apply_remote_loop_mode_to_corebridge( core_bridge: &Arc>>, loop_mode: i32, ) -> Result<(), String> { - let repeat_mode = qconnect_repeat_mode_from_loop_mode(loop_mode) - .ok_or_else(|| format!("unsupported qconnect loop mode: {loop_mode}"))?; - let bridge_guard = core_bridge.read().await; let Some(bridge) = bridge_guard.as_ref() else { return Err("core bridge is not initialized yet".to_string()); }; - - bridge.set_repeat_mode(repeat_mode).await; - Ok(()) + qconnect_app::renderer::apply_remote_loop_mode(bridge, loop_mode).await } pub(super) async fn apply_renderer_command_to_corebridge( @@ -65,287 +50,7 @@ pub(super) async fn apply_renderer_command_to_corebridge( let Some(bridge) = bridge_guard.as_ref() else { return Err("core bridge is not initialized yet".to_string()); }; - - match command { - RendererCommand::SetState { - playing_state, - current_position_ms, - current_track, - next_track, - .. - } => { - let resolved_playing_state = renderer_state.playing_state.or(*playing_state); - let mut projection_renderer_state = renderer_state.clone(); - if projection_renderer_state.current_track.is_none() { - projection_renderer_state.current_track = current_track.clone(); - } - if projection_renderer_state.next_track.is_none() { - projection_renderer_state.next_track = next_track.clone(); - } - let resolved_current_track = projection_renderer_state.current_track.as_ref(); - if let Some(projected_track) = resolved_current_track { - let queue_state = { - let state = sync_state.lock().await; - state.last_remote_queue_state.clone() - }; - let projection_applied = if let Some(queue_state) = queue_state.as_ref() { - sync_corebridge_remote_shuffle_projection( - bridge, - sync_state, - queue_state, - &projection_renderer_state, - ) - .await? - } else { - false - }; - - // Track-manipulation operations (cursor align, force-restart, - // ensure_remote_track_loaded) only run when the COMMAND - // explicitly specifies a current_track. The projection's - // resolved_current_track can be stale: when the cloud sends - // a state-only update (pause/resume) with command.current_track=null, - // the projection falls back to renderer_state.current_track, - // which is the cloud's last-known view of qbz's playback — - // potentially behind qbz's actual local advance. Using that - // stale value to align/load causes spurious track switches - // (e.g., pause from iOS made qbz jump back to a previous - // track). The outer renderer_state-based projection is still - // used for shuffle sync above and downstream playing_state / - // seek operations, which remain safe because they don't - // change the queue cursor or load tracks. - let _ = projected_track; // retained for shuffle projection above - if let Some(command_track) = current_track.as_ref() { - if !projection_applied { - if let Err(err) = - align_corebridge_queue_cursor(bridge, command_track.track_id).await - { - log::warn!( - "[QConnect] Failed to align CoreBridge queue cursor: {err}" - ); - } - } - - if matches!( - resolved_playing_state, - Some(PLAYING_STATE_PLAYING | PLAYING_STATE_PAUSED) - ) { - // Force-restart removed: the cloud routinely re-emits - // SetState with current_position_ms=0 for the same - // track when only secondary fields change (e.g., - // next_track corrections, queue_item_id refreshes). - // Reloading the stream on every echo caused first- - // track hiccup on album change and "needs several - // taps" on prev/next. Track-change cases are handled - // by align_corebridge_queue_cursor + ensure_remote_ - // track_loaded below; legitimate seek-to-start from - // a peer controller can use the seek path with - // target>1s if needed. - if let Err(err) = ensure_remote_track_loaded( - bridge, - sync_state, - command_track.track_id, - projection_renderer_state.max_audio_quality, - ) - .await - { - log::warn!( - "[QConnect] Failed to load remote track {}: {err}", - command_track.track_id - ); - } - } - } - } - - if let Some(value) = resolved_playing_state { - match value { - PLAYING_STATE_PLAYING => { - bridge.resume()?; - } - PLAYING_STATE_PAUSED => { - bridge.pause()?; - } - PLAYING_STATE_STOPPED => { - bridge.stop()?; - } - PLAYING_STATE_UNKNOWN => {} - _ => { - log::debug!("[QConnect] Unknown playing state received: {value}"); - } - } - } - - if let Some(position_ms) = - renderer_state.current_position_ms.or(*current_position_ms) - { - let playback_state = bridge.get_playback_state(); - let current_pos_secs = playback_state.position; - let target_secs = position_ms / 1000; - // Reject echo seeks: when the command targets the same track - // qbz is already playing AND target<=1s while local is well - // ahead, this is the cloud re-emitting a stale SetState - // (frequently fires on next_track corrections and queue_ - // item_id refreshes). A real peer "go to start" intent - // would target the same track as the local one but the - // round-trip to qbz is already a few seconds, making this - // case indistinguishable from echo — favor stability. - let is_echo_reset = current_track - .as_ref() - .map(|cmd_track| cmd_track.track_id == playback_state.track_id) - .unwrap_or(false) - && target_secs <= 1 - && current_pos_secs > 2; - // Issue #387: honor seeks regardless of which device is the - // active renderer. The previous gate (`peer_renderer_active`) - // skipped seeks entirely when local was the active renderer, - // breaking the case where a peer controller (e.g. official - // Qobuz mobile app) sends a real seek to qbz acting as the - // renderer — the audio thread never moved while the cloud - // state advanced, so the controller's progress bar locked. - // The is_echo_reset + abs_diff > 2 gates already filter the - // cloud-echo case the peer_renderer_active check was added - // to defend against in commit 147bcbd7. If hiccups return, - // revert this change and reintroduce a more targeted echo - // detector (UUID-based) instead of the all-or-nothing gate. - if !is_echo_reset && current_pos_secs.abs_diff(target_secs) > 2 { - log::info!( - "[QConnect] SetState seek: current={}s target={}s", - current_pos_secs, - target_secs - ); - bridge.seek(target_secs)?; - } - } - } - RendererCommand::SetVolume { volume, .. } => { - if let Some(resolved) = renderer_state.volume.or(*volume) { - bridge.set_volume(normalize_volume_to_fraction(resolved))?; - } - } - RendererCommand::MuteVolume { value } => { - if *value { - bridge.set_volume(0.0)?; - } else if let Some(resolved) = renderer_state.volume { - bridge.set_volume(normalize_volume_to_fraction(resolved))?; - } - } - RendererCommand::SetLoopMode { loop_mode } => { - let resolved_loop_mode = renderer_state.loop_mode.unwrap_or(*loop_mode); - let repeat_mode = qconnect_repeat_mode_from_loop_mode(resolved_loop_mode) - .ok_or_else(|| format!("unsupported qconnect loop mode: {resolved_loop_mode}"))?; - bridge.set_repeat_mode(repeat_mode).await; - } - RendererCommand::SetActive { active } => { - if *active { - // Becoming the active renderer: preload the current track so - // playback can start immediately on the next SetState. - if let Some(current) = renderer_state.current_track.as_ref() { - if let Err(err) = ensure_remote_track_loaded( - bridge, - sync_state, - current.track_id, - renderer_state.max_audio_quality, - ) - .await - { - log::warn!("[QConnect] SetActive(true) preload failed: {err}"); - } - } - } else { - bridge.stop()?; - } - } - RendererCommand::SetMaxAudioQuality { max_audio_quality } => { - // Applied on the next load via renderer_state.max_audio_quality - // (recorded by the core reducer). No immediate re-fetch. - log::info!("[QConnect] SetMaxAudioQuality => {max_audio_quality}"); - } - RendererCommand::SetShuffleMode { shuffle_mode } => { - let enabled = renderer_state.shuffle_mode.unwrap_or(*shuffle_mode); - bridge.set_shuffle(enabled).await; - } - } - - Ok(()) -} - -async fn sync_corebridge_remote_shuffle_projection( - bridge: &CoreBridge, - sync_state: &Arc>, - queue_state: &QConnectQueueState, - renderer_state: &QConnectRendererState, -) -> Result { - if !queue_state.shuffle_mode || queue_state.queue_items.is_empty() { - return Ok(false); - } - - let start_index = resolve_remote_start_index( - queue_state, - renderer_state - .current_track - .as_ref() - .map(|item| item.queue_item_id), - renderer_state - .current_track - .as_ref() - .map(|item| item.track_id), - ); - let Some(start_index) = start_index else { - return Ok(false); - }; - - let core_shuffle_order = resolve_core_shuffle_order( - queue_state, - renderer_state - .current_track - .as_ref() - .map(|item| item.queue_item_id), - renderer_state - .current_track - .as_ref() - .map(|item| item.track_id), - renderer_state - .next_track - .as_ref() - .map(|item| item.queue_item_id), - renderer_state.next_track.as_ref().map(|item| item.track_id), - ); - - // Same deferral rule as materialize_remote_queue_to_corebridge: do - // not invent an identity shuffle when the cloud hasn't yet sent the - // authoritative shuffle_order. Wait for the second QueueUpdated. - if core_shuffle_order.is_none() { - return Ok(false); - } - - let should_apply = { - let state = sync_state.lock().await; - state.last_materialized_start_index != Some(start_index) - || state.last_materialized_core_shuffle_order != core_shuffle_order - }; - if !should_apply { - return Ok(false); - } - - let (tracks, _) = bridge.get_all_queue_tracks().await; - if tracks.len() != queue_state.queue_items.len() || tracks.is_empty() { - return Ok(false); - } - - bridge - .set_queue_with_order( - tracks, - Some(start_index), - queue_state.shuffle_mode, - core_shuffle_order.clone(), - ) - .await; - - let mut state = sync_state.lock().await; - state.last_materialized_start_index = Some(start_index); - state.last_materialized_core_shuffle_order = core_shuffle_order; - Ok(true) + qconnect_app::renderer::apply_renderer_command(bridge, sync_state, command, renderer_state).await } pub(super) async fn materialize_remote_queue_to_corebridge( @@ -353,245 +58,16 @@ pub(super) async fn materialize_remote_queue_to_corebridge( sync_state: &Arc>, queue_state: &QConnectQueueState, ) -> Result<(), String> { - let ( - renderer_queue_item_id, - renderer_track_id, - renderer_next_queue_item_id, - renderer_next_track_id, - renderer_playing_state, - should_skip, - ) = { - let mut state = sync_state.lock().await; - if !queue_state_needs_materialization(state.last_applied_queue_state.as_ref(), queue_state) - { - ( - state.last_renderer_queue_item_id, - state.last_renderer_track_id, - state.last_renderer_next_queue_item_id, - state.last_renderer_next_track_id, - state.last_renderer_playing_state, - true, - ) - } else { - state.last_applied_queue_state = Some(queue_state.clone()); - ( - state.last_renderer_queue_item_id, - state.last_renderer_track_id, - state.last_renderer_next_queue_item_id, - state.last_renderer_next_track_id, - state.last_renderer_playing_state, - false, - ) - } - }; - - if should_skip { - log::debug!( - "[QConnect] materialize_remote_queue: skipped (identical snapshot {}.{})", - queue_state.version.major, - queue_state.version.minor - ); - return Ok(()); - } - - log::info!( - "[QConnect] materialize_remote_queue: version={}.{} items={} renderer_qid={:?} renderer_tid={:?} renderer_next_qid={:?} renderer_next_tid={:?} playing_state={:?}", - queue_state.version.major, - queue_state.version.minor, - queue_state.queue_items.len(), - renderer_queue_item_id, - renderer_track_id, - renderer_next_queue_item_id, - renderer_next_track_id, - renderer_playing_state - ); - let bridge_guard = core_bridge.read().await; let Some(bridge) = bridge_guard.as_ref() else { return Err("core bridge is not initialized yet".to_string()); }; - - if queue_state.queue_items.is_empty() { - // Preserve legacy behavior: keep current track on qconnect sync clears. - bridge.clear_queue(true).await; - bridge.set_shuffle(false).await; - let mut state = sync_state.lock().await; - state.last_materialized_start_index = None; - state.last_materialized_core_shuffle_order = None; - return Ok(()); - } - - let unique_track_ids = dedupe_track_ids(queue_state); - let fetched_tracks = bridge - .get_tracks_batch(&unique_track_ids) - .await - .map_err(|err| format!("fetch tracks batch for remote queue: {err}"))?; - - let mut tracks_by_id = HashMap::with_capacity(fetched_tracks.len()); - for track in fetched_tracks { - tracks_by_id.insert(track.id, model_track_to_core_queue_track(&track)); - } - - let mut queue_tracks = Vec::with_capacity(queue_state.queue_items.len()); - for item in &queue_state.queue_items { - if let Some(queue_track) = tracks_by_id.get(&item.track_id) { - queue_tracks.push(queue_track.clone()); - continue; - } - - match bridge.get_track(item.track_id).await { - Ok(track) => { - let mapped = model_track_to_core_queue_track(&track); - tracks_by_id.insert(item.track_id, mapped.clone()); - queue_tracks.push(mapped); - } - Err(err) => { - log::warn!( - "[QConnect] Unable to hydrate remote queue track {}: {}", - item.track_id, - err - ); - } - } - } - - if queue_tracks.is_empty() { - return Err("remote queue materialization produced zero playable tracks".to_string()); - } - - // Resolve start index from remote state first, then from the local playback - // cursor only if that track is still part of the remote queue. - let current_playback_track_id = match bridge.get_playback_state().track_id { - 0 => None, - track_id => Some(track_id), - }; - let mut start_index = - resolve_remote_start_index(queue_state, renderer_queue_item_id, renderer_track_id); - if start_index.is_none() { - start_index = resolve_remote_start_index( - queue_state, - renderer_next_queue_item_id, - renderer_next_track_id, - ) - .map(|index| index.saturating_sub(1)); - } - if start_index.is_none() { - start_index = current_playback_track_id.and_then(|track_id| { - queue_state - .queue_items - .iter() - .position(|item| item.track_id == track_id) - }); - } - if start_index.is_none() && !queue_tracks.is_empty() { - start_index = Some(0); - } - let core_shuffle_order = resolve_core_shuffle_order( - queue_state, - renderer_queue_item_id, - renderer_track_id, - renderer_next_queue_item_id, - renderer_next_track_id, - ); - // The cloud sends two QueueUpdated events during a shuffle toggle: - // first with shuffle_mode=true and shuffle_order=null (the flag - // broadcasts immediately), then ~400ms later with the computed - // shuffle_order. If we mark shuffle_enabled=true on the first event - // with an absent order, set_queue_with_order falls into its identity - // path (0,1,2,...) — that is qbz inventing a sequence that diverges - // from the order the cloud is about to authorize. Defer the engine - // shuffle activation until the authoritative order is present. - let effective_shuffle_enabled = queue_state.shuffle_mode && core_shuffle_order.is_some(); - log::info!( - "[QConnect] materialize_remote_queue: setting queue with {} tracks, start_index={:?}, local_track_id={:?}, remote_shuffle_mode={}, shuffle_order_present={}, engine_shuffle_enabled={}", - queue_tracks.len(), - start_index, - current_playback_track_id, - queue_state.shuffle_mode, - core_shuffle_order.is_some(), - effective_shuffle_enabled, - ); - bridge - .set_queue_with_order( - queue_tracks, - start_index, - effective_shuffle_enabled, - core_shuffle_order.clone(), - ) - .await; - - { - let mut state = sync_state.lock().await; - state.last_materialized_start_index = start_index; - state.last_materialized_core_shuffle_order = core_shuffle_order; - } - - let local_track_missing_from_remote = current_playback_track_id - .map(|track_id| { - !queue_state - .queue_items - .iter() - .any(|item| item.track_id == track_id) - }) - .unwrap_or(true); - - if let Some(index) = start_index { - if local_track_missing_from_remote { - log::info!( - "[QConnect] materialize_remote_queue: aligning queue cursor to remote index {}", - index - ); - let _ = bridge.play_index(index).await; - } - } - - if current_playback_track_id.is_some() - && current_playback_track_id != renderer_track_id - && local_track_missing_from_remote - && matches!( - renderer_playing_state, - Some(PLAYING_STATE_STOPPED | PLAYING_STATE_UNKNOWN) - ) - { - log::info!( - "[QConnect] materialize_remote_queue: stopping stale local playback track {:?} after remote queue replacement", - current_playback_track_id - ); - let _ = bridge.stop(); - } - - Ok(()) + qconnect_app::renderer::materialize_remote_queue(bridge, sync_state, queue_state).await } pub(super) async fn align_corebridge_queue_cursor( bridge: &CoreBridge, track_id: u64, ) -> Result<(), String> { - let (tracks, current_index) = bridge.get_all_queue_tracks().await; - log::info!( - "[QConnect] align_corebridge_queue_cursor: track_id={track_id} queue_len={} current_index={:?}", - tracks.len(), - current_index - ); - if let Some(target_index) = tracks.iter().position(|track| track.id == track_id) { - if current_index != Some(target_index) { - log::info!( - "[QConnect] align_corebridge_queue_cursor: moving cursor from {:?} to {target_index}", - current_index - ); - let _ = bridge.play_index(target_index).await; - } - return Ok(()); - } - - log::info!( - "[QConnect] align_corebridge_queue_cursor: track {track_id} not in queue, fetching and creating single-track queue" - ); - let track = bridge - .get_track(track_id) - .await - .map_err(|err| format!("fetch current remote track {track_id}: {err}"))?; - let queue_track = model_track_to_core_queue_track(&track); - bridge.set_queue(vec![queue_track], Some(0)).await; - Ok(()) + qconnect_app::renderer::align_queue_cursor(bridge, track_id).await } diff --git a/src-tauri/src/qconnect/mod.rs b/src-tauri/src/qconnect/mod.rs index 8cbf270b9..0e1384d30 100644 --- a/src-tauri/src/qconnect/mod.rs +++ b/src-tauri/src/qconnect/mod.rs @@ -33,14 +33,17 @@ pub use types::*; /// `qconnect_app::renderer` module (slice 6). Re-exported here so existing /// `super::…` references inside this module compile unchanged. pub(super) use qconnect_app::renderer::{ - model_track_to_core_queue_track, normalize_volume_to_fraction, - qconnect_repeat_mode_from_loop_mode, + PLAYING_STATE_PAUSED, PLAYING_STATE_PLAYING, PLAYING_STATE_STOPPED, +}; + +// Consumed only by the test module now (their non-test callers moved into +// `qconnect_app::renderer` in slice 6); gate to avoid unused-import warnings in +// lib builds. +#[cfg(test)] +pub(super) use qconnect_app::renderer::{ + normalize_volume_to_fraction, qconnect_repeat_mode_from_loop_mode, }; -pub(super) const PLAYING_STATE_UNKNOWN: i32 = 0; -pub(super) const PLAYING_STATE_STOPPED: i32 = 1; -pub(super) const PLAYING_STATE_PLAYING: i32 = 2; -pub(super) const PLAYING_STATE_PAUSED: i32 = 3; pub(super) const BUFFER_STATE_OK: i32 = 2; // AudioQuality enum: 0=unknown, 1=mp3, 2=cd, 3=hires_l1, 4=hires_l2(192k), 5=hires_l3(384k) diff --git a/src-tauri/src/qconnect/track_loading.rs b/src-tauri/src/qconnect/track_loading.rs index 21b0e8860..8b83ca2b4 100644 --- a/src-tauri/src/qconnect/track_loading.rs +++ b/src-tauri/src/qconnect/track_loading.rs @@ -1,112 +1,26 @@ -//! Remote track loading for QConnect: stream URL resolution, FLAC probe, -//! progressive HTTP streaming into the player engine, full-download -//! fallback, and the dedup window that prevents echo SetState frames -//! from re-triggering an in-progress load. +//! Remote track loading for QConnect: the protected `CoreBridge` renderer-engine +//! impl plus its private HTTP streaming feeder (stream URL probe, progressive +//! streaming into the player, full-download fallback). +//! +//! The dedup window, `should_reload`, and `ensure_remote_track_loaded` +//! orchestration moved to `qconnect_app::renderer` (slice 6, step 6); what stays +//! here is the engine-/reqwest-bound code that cannot cross the qconnect-app +//! boundary: the protected bit-perfect seams (`play_streaming_dynamic` / +//! `play_data`) and the detached HTTP feeder that owns the `BufferWriter`. -use std::sync::Arc; use std::time::Duration; -use tokio::sync::Mutex; - use crate::core_bridge::CoreBridge; -/// `quality_from_max_audio_quality` now lives in the frontend-agnostic -/// `qconnect_app::session` module. Re-exported here so the existing call sites in -/// this module compile unchanged. -use qconnect_app::quality_from_max_audio_quality; - use async_trait::async_trait; use qbz_models::{Quality, QueueTrack, RepeatMode, Track}; use qbz_player::PlaybackState; use qconnect_app::QconnectRendererEngine; -use super::QconnectRemoteSyncState; - -const LOAD_ATTEMPT_DEDUP_WINDOW: Duration = Duration::from_secs(5); - -pub(super) fn should_reload_remote_track( - playback_state: &qbz_player::PlaybackState, - track_id: u64, -) -> bool { - // Only reload when the track ID actually changed. The previous - // !has_loaded_audio gate fired during the buffering window of an - // initial load (qbz already started fetching but the audio engine - // hasn't reported the track as loaded yet) — when the cloud echo - // SetState arrived for the same track, this caused a redundant - // load_remote_track_into_player that interrupted the in-progress - // load. That was the residual first-track hiccup. - playback_state.track_id != track_id -} - -async fn load_remote_track_into_player( - bridge: &CoreBridge, - track_id: u64, - max_audio_quality: Option, -) -> Result<(), String> { - let quality = quality_from_max_audio_quality(max_audio_quality); - let stream_url = bridge - .get_stream_url(track_id, quality) - .await - .map_err(|err| format!("resolve stream url for remote track {track_id}: {err}"))?; - let duration_secs = bridge - .get_track(track_id) - .await - .map(|track| u64::from(track.duration)) - .unwrap_or(0); - - match stream_remote_track_into_player(bridge, track_id, duration_secs, 0, &stream_url.url).await { - Ok(()) => Ok(()), - Err(stream_err) => { - log::warn!( - "[QConnect] Streaming handoff unavailable for track {}: {}. Falling back to full download.", - track_id, - stream_err - ); - let audio_data = download_remote_audio(&stream_url.url).await?; - bridge - .player() - .play_data(audio_data, track_id) - .map_err(|err| format!("play remote track {track_id}: {err}"))?; - Ok(()) - } - } -} - -/// Returns true if a load attempt for `track_id` was registered within the -/// dedup window. The audio thread updates `playback_state.track_id` only -/// after `engine.append(source)` succeeds — the buffer/decode window -/// before that creates a gap during which an echoed SetState would -/// otherwise re-trigger the same load and interrupt the in-progress one. -fn is_recent_load_attempt(state: &QconnectRemoteSyncState, track_id: u64) -> bool { - match state.last_load_attempt { - Some((tid, ts)) => tid == track_id && ts.elapsed() < LOAD_ATTEMPT_DEDUP_WINDOW, - None => false, - } -} - -pub(super) async fn ensure_remote_track_loaded( - bridge: &CoreBridge, - sync_state: &Arc>, - track_id: u64, - max_audio_quality: Option, -) -> Result<(), String> { - { - let state = sync_state.lock().await; - if is_recent_load_attempt(&state, track_id) { - return Ok(()); - } - } - let playback_state = bridge.get_playback_state(); - if !should_reload_remote_track(&playback_state, track_id) { - return Ok(()); - } - - { - let mut state = sync_state.lock().await; - state.last_load_attempt = Some((track_id, std::time::Instant::now())); - } - load_remote_track_into_player(bridge, track_id, max_audio_quality).await -} +/// Re-exported for `tests.rs` (`super::track_loading::should_reload_remote_track`); +/// the non-test orchestration that consumed it moved to `qconnect_app::renderer`. +#[cfg(test)] +pub(super) use qconnect_app::renderer::should_reload_remote_track; struct QconnectRemoteStreamInfo { content_length: u64,