use std::{ sync::Arc, time::{Duration, SystemTime, UNIX_EPOCH}, }; use qconnect_core::{ apply_event, apply_renderer_command, telemetry, PendingCorrelation, PendingQueueAction, QConnectQueueState, QConnectRendererState, QueueEvent, QueueItem, QueueVersion, RendererCommand, }; use qconnect_protocol::{ build_qconnect_outbound_envelope, build_qconnect_renderer_outbound_envelope, decode_playback_error, parse_inbound_event, InboundEnvelope, QueueCommand, QueueCommandType, QueueEventType, QueueServerEvent, RendererCommandType, RendererReport, RendererReportType, RendererServerCommand, }; use qconnect_transport_ws::{TransportEvent, WsTransport, WsTransportConfig}; use serde_json::Value; use tokio::sync::Mutex; use uuid::Uuid; use async_trait::async_trait; use crate::session::{ compute_connection_state, deferred_join_reason, is_local_renderer_active, is_peer_renderer_active, normalize_active_renderer_id, refresh_local_renderer_id, should_arm_renderer_watchdog, should_reask_queue_state, LocalIdentity, QconnectFileAudioQualitySnapshot, QconnectLifecycleState, QconnectRendererInfo, RendererStatus, ServerActiveState, PLAYING_STATE_PLAYING, PLAYING_STATE_UNKNOWN, QCONNECT_RENDERER_LOST_TIMEOUT_MS, }; use crate::{ ensure_session_renderer_state, sync_session_renderer_active_flags, QconnectAppError, QconnectAppEvent, QconnectEventSink, QconnectRemoteSyncState, QconnectRuntimeState, }; pub struct QconnectApp where TTransport: WsTransport, TSink: QconnectEventSink, { transport: Arc, sink: Arc, state: Arc>, /// Cross-frontend remote-sync accumulator (session topology, renderer-state /// cache, materialization cache, load-attempt dedup, watchdog epoch). Held /// behind its OWN Mutex, disjoint from `state`: the two are never co-locked, /// so the renderer-report hot path never serializes against session/watchdog /// work and there is no deadlock edge against `clear_pending_if_matches` /// (which locks `state`). The session loop (slice 5) and the renderer engine /// (slice 6) both lock THIS one, exactly as they share it today via the Tauri /// adapter. See `MASTER-qconnect-to-slint-plan.md` §0 (one Mutex, not two). sync: Arc>, } impl Clone for QconnectApp where TTransport: WsTransport, TSink: QconnectEventSink, { fn clone(&self) -> Self { Self { transport: Arc::clone(&self.transport), sink: Arc::clone(&self.sink), state: Arc::clone(&self.state), sync: Arc::clone(&self.sync), } } } impl QconnectApp where TTransport: WsTransport + 'static, TSink: QconnectEventSink + 'static, { const PENDING_ACTION_TIMEOUT_MS: u64 = 10_000; /// Construct the app. `sync` is the shared remote-sync accumulator handle: /// the Tauri adapter builds it, hands a clone to its event sink / service /// loop, and passes the SAME `Arc` here so there is exactly one lock backing /// the session/liveness/renderer paths. The Slint adapter will do the same. pub fn new( transport: Arc, sink: Arc, sync: Arc>, ) -> Self { Self { transport, sink, state: Arc::new(Mutex::new(QconnectRuntimeState::default())), sync, } } pub fn state_handle(&self) -> Arc> { Arc::clone(&self.state) } /// Shared handle to the remote-sync accumulator. The adapter uses this so its /// event sink, service loop, and CoreBridge helpers lock the very same Mutex /// the app's own session/watchdog methods lock. pub fn sync_handle(&self) -> Arc> { Arc::clone(&self.sync) } pub fn subscribe_transport_events(&self) -> tokio::sync::broadcast::Receiver { self.transport.subscribe() } pub async fn connect(&self, config: WsTransportConfig) -> Result<(), QconnectAppError> { self.transport.connect(config).await?; { let mut state = self.state.lock().await; state.transport_connected = true; } self.sink .on_event(QconnectAppEvent::TransportConnected) .await; Ok(()) } pub async fn disconnect(&self) -> Result<(), QconnectAppError> { self.transport.disconnect().await?; { let mut state = self.state.lock().await; state.transport_connected = false; state.pending.clear(); } self.sink .on_event(QconnectAppEvent::TransportDisconnected) .await; Ok(()) } pub async fn queue_state_snapshot(&self) -> QConnectQueueState { self.state.lock().await.queue.clone() } pub async fn renderer_state_snapshot(&self) -> QConnectRendererState { self.state.lock().await.renderer.clone() } pub async fn build_queue_command( &self, command_type: QueueCommandType, payload: Value, ) -> QueueCommand { let version_ref = self.state.lock().await.queue.version; QueueCommand::new(command_type, self.next_action_uuid(), version_ref, payload) } pub async fn send_queue_command( &self, command: QueueCommand, ) -> Result { let action_uuid = command.action_uuid.clone(); let is_set_active_renderer_action = matches!( command.command_type, QueueCommandType::CtrlSrvrSetActiveRenderer ); let pending = PendingQueueAction { uuid: action_uuid.clone(), queue_version_ref: command.queue_version_ref, emit_result_event: true, is_ask_for_state_action: matches!( command.command_type, QueueCommandType::CtrlSrvrAskForQueueState ), is_transport_control_action: matches!( command.command_type, QueueCommandType::CtrlSrvrSetPlayerState ), is_set_loop_mode_action: matches!( command.command_type, QueueCommandType::CtrlSrvrSetLoopMode ), is_set_volume_action: matches!( command.command_type, QueueCommandType::CtrlSrvrSetVolume ), is_set_active_renderer_action, expected_active_renderer_id: if is_set_active_renderer_action { pending_active_renderer_id_from_payload(&command.payload) } else { None }, concurrency_error: false, sent_at_ms: now_ms(), }; { let mut state = self.state.lock().await; state.pending.start(pending)?; } let envelope = build_qconnect_outbound_envelope(command)?; if let Err(err) = self.transport.send(envelope).await { let mut state = self.state.lock().await; state.pending.clear(); return Err(err.into()); } self.sink .on_event(QconnectAppEvent::PendingActionStarted { uuid: action_uuid.clone(), }) .await; self.spawn_pending_timeout_watch(action_uuid.clone()); Ok(action_uuid) } pub async fn send_renderer_report_command( &self, report: RendererReport, ) -> Result<(), QconnectAppError> { self.send_renderer_report(report).await } /// Emit a RndrSrvrFileAudioQualityChanged report describing the decoded file /// format, deduped against the last reported value. Returns Ok(true) when a /// report was sent. Frontend-agnostic (slice 6, step 7): both the Tauri and /// Slint report loops feed this; the snapshot is produced from the engine's /// `current_output_format()`. pub async fn report_file_audio_quality_if_changed( &self, queue_version: QueueVersion, audio_quality: QconnectFileAudioQualitySnapshot, ) -> Result { let sync_state = self.sync_handle(); { let state = sync_state.lock().await; if state.last_reported_file_audio_quality == Some(audio_quality) { return Ok(false); } } let report = RendererReport::new( RendererReportType::RndrSrvrFileAudioQualityChanged, Uuid::new_v4().to_string(), queue_version, serde_json::json!({ "sampling_rate": audio_quality.sampling_rate, "bit_depth": audio_quality.bit_depth, "nb_channels": audio_quality.nb_channels, "audio_quality": audio_quality.audio_quality }), ); self.send_renderer_report_command(report) .await .map_err(|err| format!("send file audio quality report failed: {err}"))?; let mut state = sync_state.lock().await; state.last_reported_file_audio_quality = Some(audio_quality); Ok(true) } /// Emit a RndrSrvrDeviceAudioQualityChanged(27) report describing the actual /// DAC output format (sampling_rate / bit_depth / nb_channels), deduped against /// the last reported value. Returns Ok(true) when a report was sent. pub async fn report_device_audio_quality_if_changed( &self, queue_version: QueueVersion, sampling_rate: i32, bit_depth: i32, nb_channels: i32, ) -> Result { let sync_state = self.sync_handle(); let key = (sampling_rate, bit_depth, nb_channels); { let state = sync_state.lock().await; if state.last_reported_device_audio_quality == Some(key) { return Ok(false); } } let report = RendererReport::new( RendererReportType::RndrSrvrDeviceAudioQualityChanged, Uuid::new_v4().to_string(), queue_version, serde_json::json!({ "sampling_rate": sampling_rate, "bit_depth": bit_depth, "nb_channels": nb_channels }), ); self.send_renderer_report_command(report) .await .map_err(|err| format!("send device audio quality report failed: {err}"))?; let mut state = sync_state.lock().await; state.last_reported_device_audio_quality = Some(key); Ok(true) } /// Update the renderer state's position from the frontend's playback position. /// This keeps the internal state in sync with the actual audio playback, so that /// renderer reports triggered by server commands (pause/resume) include the real position. pub async fn update_renderer_position(&self, position_ms: u64) { let mut state = self.state.lock().await; state.renderer.current_position_ms = Some(position_ms); } pub async fn handle_transport_event( &self, event: TransportEvent, ) -> Result<(), QconnectAppError> { match event { TransportEvent::Connected => { { let mut state = self.state.lock().await; state.transport_connected = true; } self.sink .on_event(QconnectAppEvent::TransportConnected) .await; } TransportEvent::Disconnected => { { let mut state = self.state.lock().await; state.transport_connected = false; state.pending.clear(); } self.sink .on_event(QconnectAppEvent::TransportDisconnected) .await; } TransportEvent::InboundReceived(inbound) => { self.handle_inbound_envelope(inbound).await?; } TransportEvent::InboundQueueServerEvent(event) => { self.apply_server_event(event).await?; } TransportEvent::InboundRendererServerCommand(command) => { self.apply_renderer_server_command(command).await?; } TransportEvent::InboundPayloadBytes { payload, .. } => { // The batch carries renderer per-track failures as a tag-3 // playback_error on a messages[] entry. The queue/renderer // decoders ignore it, so decode it here off the raw batch bytes. if let Some(error) = decode_playback_error(&payload) { self.sink .on_event(QconnectAppEvent::PlaybackError { queue_item_id: error.queue_item_id, error_type: error.error_type, queue_version: error.queue_version, }) .await; } } TransportEvent::Authenticated | TransportEvent::Subscribed | TransportEvent::SessionEstablished | TransportEvent::MaxReconnectAttemptsExceeded { .. } | TransportEvent::ReconnectScheduled { .. } | TransportEvent::KeepalivePingSent | TransportEvent::KeepalivePongReceived | TransportEvent::TransportError { .. } | TransportEvent::CloudError { .. } | TransportEvent::InboundFrameDecoded { .. } | TransportEvent::OutboundSent { .. } => {} } Ok(()) } pub async fn handle_inbound_envelope( &self, inbound: InboundEnvelope, ) -> Result<(), QconnectAppError> { let event = parse_inbound_event(inbound)?; self.apply_server_event(event).await } async fn apply_server_event(&self, event: QueueServerEvent) -> Result<(), QconnectAppError> { // Session management events bypass the queue reducer entirely. // They provide session topology info (renderers, active renderer, etc.) if event.event_type.is_session_management() { let completed_uuid = { let mut state = self.state.lock().await; let matched_by_uuid = matches!( state.pending.correlate(event.action_uuid.as_deref()), PendingCorrelation::Matched ); let matched_by_session_effect = state .pending .current() .map(|pending| { session_management_event_completes_pending_action( pending, &event.event_type, &event.payload, ) }) .unwrap_or(false); if matched_by_uuid || matched_by_session_effect { state.pending.clear().map(|pending| pending.uuid) } else { None } }; if let Some(uuid) = completed_uuid { self.sink .on_event(QconnectAppEvent::PendingActionCompleted { uuid }) .await; } self.sink .on_event(QconnectAppEvent::SessionManagementEvent { message_type: event.message_type().to_string(), payload: event.payload.clone(), }) .await; return Ok(()); } let mut completed_uuid: Option = None; let mut canceled_uuid: Option = None; let mut ignored_queue_error_uuid: Option = None; let mut should_trigger_resync = false; let mut should_emit_queue_update = false; let remote_action_uuid = event.action_uuid.clone().unwrap_or_default(); let snapshot: QConnectQueueState; { let mut state = self.state.lock().await; match state.pending.correlate(event.action_uuid.as_deref()) { PendingCorrelation::Matched => { completed_uuid = state.pending.clear().map(|pending| pending.uuid); } PendingCorrelation::Concurrent => { state.pending.mark_concurrency_error(); canceled_uuid = state.pending.clear().map(|pending| pending.uuid); state.concurrency_canceled_action_uuid = canceled_uuid.clone(); should_trigger_resync = canceled_uuid.is_some(); } PendingCorrelation::NoPending | PendingCorrelation::EventWithoutActionUuid => {} } let ignore_queue_error = matches!(event.event_type, QueueEventType::SrvrCtrlQueueErrorMessage) && event.action_uuid.is_some() && state.concurrency_canceled_action_uuid.as_deref() == event.action_uuid.as_deref(); if ignore_queue_error { ignored_queue_error_uuid = event.action_uuid.clone(); state.concurrency_canceled_action_uuid = None; } else { let queue_event = map_server_event(&event, &state.queue); let reducer_outcome = apply_event(&mut state.queue, &queue_event, now_ms()); let _metric_name = telemetry::queue_reducer_event_name(reducer_outcome.event_name); should_emit_queue_update = true; if matches!( event.event_type, QueueEventType::SrvrCtrlShuffleModeSet | QueueEventType::SrvrCtrlQueueTracksReordered | QueueEventType::SrvrCtrlQueueTracksRemoved | QueueEventType::SrvrCtrlQueueTracksAddedFromAutoplay ) { should_trigger_resync = true; } // queue_hash divergence seam. Inert today (local hash algorithm // is a BLOCKING unknown -> compute_local_queue_hash returns None), // so this never fires spurious resyncs. When the algorithm lands, // a mismatch will pull the authoritative QueueState. if queue_hashes_diverge(&state.queue) { should_trigger_resync = true; } } snapshot = state.queue.clone(); } if let Some(uuid) = completed_uuid { self.sink .on_event(QconnectAppEvent::PendingActionCompleted { uuid }) .await; } if let Some(pending_uuid) = canceled_uuid { self.sink .on_event( QconnectAppEvent::PendingActionCanceledByConcurrentRemoteEvent { pending_uuid, remote_action_uuid, }, ) .await; } if let Some(action_uuid) = ignored_queue_error_uuid { self.sink .on_event(QconnectAppEvent::QueueErrorIgnoredByConcurrency { action_uuid }) .await; } if should_emit_queue_update { self.sink .on_event(QconnectAppEvent::QueueUpdated(snapshot)) .await; } if should_trigger_resync { self.trigger_queue_state_resync().await; } Ok(()) } async fn apply_renderer_server_command( &self, command: RendererServerCommand, ) -> Result<(), QconnectAppError> { let Some(renderer_command) = map_renderer_server_command(&command) else { return Ok(()); }; // Detect echo SET_STATE commands: the server echoes every state report // as a SET_STATE with only next_track (playing_state=None, // current_track=None, current_position_ms=None). These echoes must // NOT trigger CoreBridge actions (align cursor, load track, // resume/pause) or state reports, otherwise they destroy the local // queue and cause feedback loops. // // Issue #387: a peer controller (e.g. official Qobuz mobile app) // sends a SEEK as SET_STATE with only current_position_ms set // (playing_state=None, current_track=None). The previous filter // matched that shape and silently swallowed the command, so qbz // never moved its audio thread when an external controller seeked. // Treat current_position_ms.is_some() as the signal that the // command carries real intent and must be propagated. let is_echo = matches!( &renderer_command, RendererCommand::SetState { playing_state, current_track, current_position_ms, .. } if playing_state.is_none() && current_track.is_none() && current_position_ms.is_none() ); let (snapshot, queue_version) = { let mut state = self.state.lock().await; apply_renderer_command(&mut state.renderer, &renderer_command, now_ms()); (state.renderer.clone(), state.queue.version) }; // Always update renderer state (for tracking next_track etc.) self.sink .on_event(QconnectAppEvent::RendererUpdated(snapshot.clone())) .await; if is_echo { log::debug!("[QConnect] Skipping echo SET_STATE (no playing_state or current_track)"); return Ok(()); } self.sink .on_event(QconnectAppEvent::RendererCommandApplied { command: renderer_command.clone(), state: snapshot.clone(), }) .await; self.send_renderer_reports(&renderer_command, &snapshot, queue_version) .await?; Ok(()) } fn spawn_pending_timeout_watch(&self, action_uuid: String) { let app = self.clone(); tokio::spawn(async move { app.watch_pending_action_timeout(action_uuid).await; }); } async fn watch_pending_action_timeout(&self, action_uuid: String) { tokio::time::sleep(Duration::from_millis(Self::PENDING_ACTION_TIMEOUT_MS)).await; let (timed_out, timed_out_ask_for_state) = { let mut state = self.state.lock().await; let (is_same_pending, is_ask_for_state_action) = state .pending .current() .map(|pending| { ( pending.uuid.as_str() == action_uuid, pending.is_ask_for_state_action, ) }) .unwrap_or((false, false)); if is_same_pending { state.pending.clear(); (true, is_ask_for_state_action) } else { (false, false) } }; if !timed_out { return; } self.sink .on_event(QconnectAppEvent::PendingActionTimedOut { uuid: action_uuid, timeout_ms: Self::PENDING_ACTION_TIMEOUT_MS, }) .await; if !timed_out_ask_for_state { self.trigger_queue_state_resync().await; } } async fn trigger_queue_state_resync(&self) { let queue_version_ref = { let state = self.state.lock().await; if state.pending.current().is_some() { return; } state.queue.version }; let command = QueueCommand::new( QueueCommandType::CtrlSrvrAskForQueueState, self.next_action_uuid(), queue_version_ref, Value::Object(Default::default()), ); if self.send_queue_command(command).await.is_ok() { self.sink .on_event(QconnectAppEvent::QueueResyncTriggered) .await; } } fn next_action_uuid(&self) -> String { Uuid::new_v4().to_string() } async fn send_renderer_reports( &self, command: &RendererCommand, renderer: &QConnectRendererState, queue_version_ref: qconnect_core::QueueVersion, ) -> Result<(), QconnectAppError> { match command { RendererCommand::SetState { playing_state, current_track, .. } => { // Only send a state report when the SET_STATE carries a meaningful // change (playing_state or current_track). The server echoes every // state report as a SET_STATE with only next_track updated, which // would create an infinite feedback loop if we replied to it. let is_substantive = playing_state.is_some() || current_track.is_some(); if is_substantive { log::info!( "[QConnect/Report] SetState report: playing={:?} pos={:?} track={:?} next={:?} qv={}.{}", renderer.playing_state, renderer.current_position_ms, renderer.current_track.as_ref().map(|t| (t.track_id, t.queue_item_id)), renderer.next_track.as_ref().map(|t| (t.track_id, t.queue_item_id)), queue_version_ref.major, queue_version_ref.minor ); let report = RendererReport::new( RendererReportType::RndrSrvrStateUpdated, self.next_action_uuid(), queue_version_ref, serde_json::json!({ "playing_state": renderer.playing_state, "buffer_state": infer_buffer_state(renderer.playing_state), "current_position": renderer.current_position_ms, "duration": Option::::None, "queue_version": { "major": queue_version_ref.major, "minor": queue_version_ref.minor }, "current_queue_item_id": Option::::None, "next_queue_item_id": Option::::None }), ); self.send_renderer_report(report).await?; } else { log::debug!( "[QConnect/Report] Skipping echo SET_STATE report (no playing_state or current_track change)" ); } } RendererCommand::SetVolume { volume, .. } => { let resolved_volume = renderer.volume.or(*volume); if let Some(resolved_volume) = resolved_volume { let report = RendererReport::new( RendererReportType::RndrSrvrVolumeChanged, self.next_action_uuid(), queue_version_ref, serde_json::json!({ "volume": resolved_volume }), ); self.send_renderer_report(report).await?; } } RendererCommand::MuteVolume { value } => { let report = RendererReport::new( RendererReportType::RndrSrvrVolumeMuted, self.next_action_uuid(), queue_version_ref, serde_json::json!({ "value": value }), ); self.send_renderer_report(report).await?; } RendererCommand::SetMaxAudioQuality { max_audio_quality } => { let report = RendererReport::new( RendererReportType::RndrSrvrMaxAudioQualityChanged, self.next_action_uuid(), queue_version_ref, serde_json::json!({ "max_audio_quality": max_audio_quality }), ); self.send_renderer_report(report).await?; } RendererCommand::SetActive { .. } | RendererCommand::SetLoopMode { .. } | RendererCommand::SetShuffleMode { .. } => {} } Ok(()) } async fn send_renderer_report(&self, report: RendererReport) -> Result<(), QconnectAppError> { let envelope = build_qconnect_renderer_outbound_envelope(report)?; self.transport.send(envelope).await?; Ok(()) } } fn infer_buffer_state(playing_state: Option) -> Option { match playing_state { Some(2) | Some(3) => Some(2), Some(1) => Some(1), Some(value) => Some(value), None => None, } } /// BLOCKING OPEN QUESTION: the Qobuz `queue_hash` (field #100) algorithm is /// undocumented. Until it is verified, this returns `None`, which keeps /// `queue_hashes_diverge` inert so it can NOT fire spurious resyncs. Flipping /// this to a real implementation is the single switch that turns on divergence /// detection. fn compute_local_queue_hash(_queue: &QConnectQueueState) -> Option> { None } /// Algorithm-agnostic divergence seam. Only reports divergence when BOTH a /// locally computed hash and a server-reported hash exist and differ. Because /// `compute_local_queue_hash` returns `None` today, this is always `false`. fn queue_hashes_diverge(queue: &QConnectQueueState) -> bool { match ( compute_local_queue_hash(queue), queue.last_server_queue_hash.as_ref(), ) { (Some(local), Some(server)) => &local != server, _ => false, } } fn map_server_event(event: &QueueServerEvent, current: &QConnectQueueState) -> QueueEvent { let version = event .queue_version .unwrap_or_else(|| current.version.next_minor()); match event.event_type { QueueEventType::SrvrCtrlQueueState => { let mut next = current.clone(); next.version = version; next.queue_items = parse_queue_items(&event.payload, "tracks"); next.shuffle_mode = parse_bool(&event.payload, "shuffle_mode", current.shuffle_mode); next.autoplay_mode = parse_bool(&event.payload, "autoplay_mode", current.autoplay_mode); next.autoplay_loading = parse_bool(&event.payload, "autoplay_loading", current.autoplay_loading); next.autoplay_items = parse_queue_items(&event.payload, "autoplay_tracks"); if next.shuffle_mode { let parsed_shuffle = parse_usize_list(&event.payload, "shuffled_track_indexes"); next.shuffle_order = if !parsed_shuffle.is_empty() { Some(parsed_shuffle) } else { current.shuffle_order.clone() }; } else { next.shuffle_order = None; } // Surface the server queue_hash (field #100). Only overwrite when the // payload actually carries it, so an omitted hash leaves prior state. if let Some(server_hash) = parse_bytes(&event.payload, "server_queue_hash") { next.last_server_queue_hash = Some(server_hash); } QueueEvent::QueueStateReplaced { action_uuid: event.action_uuid.clone(), state: next, } } QueueEventType::SrvrCtrlQueueTracksAdded => QueueEvent::TracksAdded { action_uuid: event.action_uuid.clone(), version, tracks: parse_queue_items(&event.payload, "tracks"), shuffle_seed: parse_u64(&event.payload, "shuffle_seed"), autoplay_reset: parse_bool(&event.payload, "autoplay_reset", false), autoplay_loading: parse_bool(&event.payload, "autoplay_loading", false), }, QueueEventType::SrvrCtrlQueueTracksLoaded => QueueEvent::TracksLoaded { action_uuid: event.action_uuid.clone(), version, tracks: parse_queue_items(&event.payload, "tracks"), queue_position: parse_u64(&event.payload, "queue_position"), shuffle_mode: parse_optional_bool(&event.payload, "shuffle_mode"), shuffle_seed: parse_u64(&event.payload, "shuffle_seed"), shuffle_pivot_queue_item_id: parse_u64(&event.payload, "shuffle_pivot_queue_item_id"), autoplay_reset: parse_bool(&event.payload, "autoplay_reset", false), autoplay_loading: parse_bool(&event.payload, "autoplay_loading", false), }, QueueEventType::SrvrCtrlQueueTracksInserted => QueueEvent::TracksInserted { action_uuid: event.action_uuid.clone(), version, tracks: parse_queue_items(&event.payload, "tracks"), insert_after: parse_u64(&event.payload, "insert_after"), shuffle_seed: parse_u64(&event.payload, "shuffle_seed"), autoplay_reset: parse_bool(&event.payload, "autoplay_reset", false), autoplay_loading: parse_bool(&event.payload, "autoplay_loading", false), }, QueueEventType::SrvrCtrlQueueTracksRemoved => QueueEvent::TracksRemoved { action_uuid: event.action_uuid.clone(), version, queue_item_ids: parse_queue_item_ids(&event.payload), autoplay_reset: parse_bool(&event.payload, "autoplay_reset", false), autoplay_loading: parse_bool(&event.payload, "autoplay_loading", false), }, QueueEventType::SrvrCtrlQueueTracksReordered => QueueEvent::TracksReordered { action_uuid: event.action_uuid.clone(), version, queue_item_ids: parse_queue_item_ids(&event.payload), insert_after: parse_u64(&event.payload, "insert_after"), autoplay_reset: parse_bool(&event.payload, "autoplay_reset", false), autoplay_loading: parse_bool(&event.payload, "autoplay_loading", false), }, QueueEventType::SrvrCtrlQueueCleared => QueueEvent::QueueCleared { action_uuid: event.action_uuid.clone(), version, }, QueueEventType::SrvrCtrlShuffleModeSet => QueueEvent::ShuffleModeSet { action_uuid: event.action_uuid.clone(), version, shuffle_mode: parse_bool(&event.payload, "shuffle_mode", false), shuffle_seed: parse_u64(&event.payload, "shuffle_seed"), shuffle_pivot_queue_item_id: parse_u64(&event.payload, "shuffle_pivot_queue_item_id"), autoplay_reset: parse_bool(&event.payload, "autoplay_reset", false), autoplay_loading: parse_bool(&event.payload, "autoplay_loading", false), }, QueueEventType::SrvrCtrlAutoplayModeSet => QueueEvent::AutoplayModeSet { action_uuid: event.action_uuid.clone(), version, autoplay_mode: parse_bool(&event.payload, "autoplay_mode", false), autoplay_reset: parse_bool(&event.payload, "autoplay_reset", false), autoplay_loading: parse_bool(&event.payload, "autoplay_loading", false), }, QueueEventType::SrvrCtrlAutoplayTracksLoaded => QueueEvent::AutoplayTracksLoaded { action_uuid: event.action_uuid.clone(), version, tracks: parse_queue_items(&event.payload, "tracks"), }, QueueEventType::SrvrCtrlAutoplayTracksRemoved => QueueEvent::AutoplayTracksRemoved { action_uuid: event.action_uuid.clone(), version, queue_item_ids: parse_queue_item_ids(&event.payload), }, QueueEventType::SrvrCtrlQueueTracksAddedFromAutoplay => QueueEvent::TracksAdded { action_uuid: event.action_uuid.clone(), version, tracks: Vec::new(), shuffle_seed: None, autoplay_reset: false, autoplay_loading: false, }, QueueEventType::SrvrCtrlQueueErrorMessage => QueueEvent::QueueError { action_uuid: event.action_uuid.clone(), version: Some(version), code: event .payload .get("error_code") .map(value_to_string) .unwrap_or_else(|| "remote_error".to_string()), message: event .payload .get("error_message") .map(value_to_string) .unwrap_or_else(|| "queue_error_message".to_string()), }, // Session management events are intercepted in apply_server_event() // and should never reach map_server_event(). Treat as no-op if they do. _ => QueueEvent::QueueCleared { action_uuid: None, version: current.version, }, } } fn map_renderer_server_command(command: &RendererServerCommand) -> Option { match command.command_type { RendererCommandType::SrvrRndrSetState => Some(RendererCommand::SetState { playing_state: parse_i32(&command.payload, "playing_state"), current_position_ms: parse_u64(&command.payload, "current_position"), current_track: parse_renderer_track(&command.payload, "current_track"), next_track: parse_renderer_track(&command.payload, "next_track"), }), RendererCommandType::SrvrRndrSetVolume => Some(RendererCommand::SetVolume { volume: parse_i32(&command.payload, "volume"), volume_delta: parse_i32(&command.payload, "volume_delta"), }), RendererCommandType::SrvrRndrSetActive => Some(RendererCommand::SetActive { active: parse_bool(&command.payload, "active", false), }), RendererCommandType::SrvrRndrSetMaxAudioQuality => { parse_i32(&command.payload, "max_audio_quality") .map(|max_audio_quality| RendererCommand::SetMaxAudioQuality { max_audio_quality }) } RendererCommandType::SrvrRndrSetLoopMode => parse_i32(&command.payload, "loop_mode") .map(|loop_mode| RendererCommand::SetLoopMode { loop_mode }), RendererCommandType::SrvrRndrSetShuffleMode => Some(RendererCommand::SetShuffleMode { shuffle_mode: parse_bool(&command.payload, "shuffle_mode", false), }), RendererCommandType::SrvrRndrMuteVolume => Some(RendererCommand::MuteVolume { value: parse_bool(&command.payload, "value", false), }), } } fn parse_renderer_track(payload: &Value, field: &str) -> Option { payload.get(field).and_then(parse_queue_item) } fn parse_queue_items(payload: &Value, field: &str) -> Vec { payload .get(field) .and_then(Value::as_array) .map(|items| items.iter().filter_map(parse_queue_item).collect()) .unwrap_or_default() } fn parse_queue_item(value: &Value) -> Option { let track_context_uuid = value .get("track_context_uuid") .or_else(|| value.get("context_uuid")) .and_then(Value::as_str) .unwrap_or_default() .to_string(); let track_id = value .get("track_id") .or_else(|| value.get("trackId")) .and_then(value_as_u64)?; let queue_item_id = value .get("queue_item_id") .or_else(|| value.get("queueItemId")) .and_then(value_as_u64) .unwrap_or(track_id); Some(QueueItem { track_context_uuid, track_id, queue_item_id, }) } fn parse_queue_item_ids(payload: &Value) -> Vec { payload .get("queue_item_ids") .or_else(|| payload.get("queueItemsIds")) .and_then(Value::as_array) .map(|items| items.iter().filter_map(value_as_u64).collect()) .unwrap_or_default() } fn parse_u64(payload: &Value, field: &str) -> Option { payload.get(field).and_then(value_as_u64) } /// Parse a JSON byte array (e.g. the server `queue_hash` field #100) into bytes. /// Returns `None` when absent/null so an omitted hash does not clobber state. fn parse_bytes(payload: &Value, field: &str) -> Option> { payload .get(field) .and_then(Value::as_array) .map(|entries| { entries .iter() .filter_map(value_as_u64) .filter_map(|value| u8::try_from(value).ok()) .collect() }) } fn parse_bool(payload: &Value, field: &str, default: bool) -> bool { payload .get(field) .and_then(Value::as_bool) .unwrap_or(default) } fn parse_optional_bool(payload: &Value, field: &str) -> Option { payload.get(field).and_then(Value::as_bool) } fn parse_i32(payload: &Value, field: &str) -> Option { payload.get(field).and_then(value_as_i32) } fn parse_usize_list(payload: &Value, field: &str) -> Vec { payload .get(field) .and_then(Value::as_array) .map(|entries| { entries .iter() .filter_map(value_as_u64) .filter_map(|value| usize::try_from(value).ok()) .collect() }) .unwrap_or_default() } fn value_as_u64(value: &Value) -> Option { value .as_u64() .or_else(|| value.as_i64().and_then(|entry| u64::try_from(entry).ok())) } fn value_as_i32(value: &Value) -> Option { value .as_i64() .and_then(|entry| i32::try_from(entry).ok()) .or_else(|| value.as_u64().and_then(|entry| i32::try_from(entry).ok())) } fn value_to_string(value: &Value) -> String { value .as_str() .map(ToString::to_string) .unwrap_or_else(|| value.to_string()) } fn now_ms() -> u64 { SystemTime::now() .duration_since(UNIX_EPOCH) .unwrap_or_default() .as_millis() as u64 } fn pending_active_renderer_id_from_payload(payload: &Value) -> Option { payload .get("renderer_id") .or_else(|| payload.get("active_renderer_id")) .and_then(Value::as_i64) .and_then(|value| i32::try_from(value).ok()) } fn session_management_event_completes_pending_action( pending: &PendingQueueAction, event_type: &QueueEventType, payload: &Value, ) -> bool { if pending.is_transport_control_action && matches!(event_type, QueueEventType::SrvrCtrlRendererStateUpdated) { // Transport control SET_PLAYER_STATE commands do not get a dedicated // action_uuid ack. The first renderer state update is the practical // completion signal; otherwise rapid next/previous presses stay // blocked behind a stale pending slot. return true; } if pending.is_set_loop_mode_action && matches!(event_type, QueueEventType::SrvrCtrlLoopModeSet) { // Loop mode changes come back as session-management events without a // stable action_uuid ack. Treat the first loop-mode-set echo as the // completion signal so repeat toggles are not blocked behind the // generic 10s pending timeout. return true; } if pending.is_set_volume_action && matches!(event_type, QueueEventType::SrvrCtrlVolumeChanged) { // Volume changes come back as session-management events without a // stable action_uuid ack. Treat the first volume-changed echo as the // completion signal so a rapid volume drag is not blocked behind the // generic 10s pending timeout. return true; } if !pending.is_set_active_renderer_action { return false; } let Some(expected_renderer_id) = pending.expected_active_renderer_id else { return false; }; match event_type { QueueEventType::SrvrCtrlActiveRendererChanged | QueueEventType::SrvrCtrlSessionState => { payload .get("active_renderer_id") .and_then(Value::as_i64) .and_then(|value| i32::try_from(value).ok()) == Some(expected_renderer_id) } _ => false, } } /// Post-lock work returned by [`QconnectApp::apply_session_management_event`]. /// The adapter runs the CoreBridge side-effects (remote loop mode, /// local-playback handoff, projection alignment) from these flags in order, /// then drives the freeze + watchdog via /// [`QconnectApp::freeze_active_renderer_projection`] / /// [`QconnectApp::arm_renderer_watchdog`] — preserving the exact post-lock /// ordering of the prior inline Tauri implementation. #[derive(Debug, Default, Clone)] pub struct SessionApplyOutcome { /// Active renderer whose remote projection should be re-aligned into CoreBridge. pub remote_projection_renderer_id: Option, /// Stop local playback because an active peer renderer now owns playback. pub sync_local_playback: bool, /// Apply this remote loop mode to CoreBridge. pub apply_loop_mode: Option, /// Active peer renderer left gracefully (ACTIVE_DISCONNECTED) — freeze it. pub disconnected_renderer_id: Option, /// Arm the 12s liveness watchdog for (renderer_id, generation). pub watchdog_arm: Option<(i32, u64)>, } /// Bump the watchdog epoch, invalidating any in-flight 12s liveness task. /// Returns the new generation (captured when arming so the spawned task knows /// which epoch it belongs to). Relocated from the Tauri sink (slice 2+4). fn bump_watchdog_generation(state: &mut QconnectRemoteSyncState) -> u64 { state.watchdog_generation = state.watchdog_generation.wrapping_add(1); state.watchdog_generation } impl QconnectApp where TTransport: WsTransport + 'static, TSink: QconnectEventSink + 'static, { /// Apply a server session-management event (types 81-87, 97-101) to the /// shared remote-sync accumulator under ONE lock, returning the post-lock /// work the adapter must drive. /// /// Relocated from the Tauri event sink (slice 2+4): the locked critical /// section is byte-identical. The only differences are (a) the lock handle /// is `self.sync`, (b) local identity is injected as `identity` so the crate /// stays frontend-agnostic (`refresh_local_renderer_id` takes it instead of /// resolving device-info itself), and (c) the post-lock dispatch is RETURNED /// via [`SessionApplyOutcome`] rather than run inline — the CoreBridge /// materialization stays adapter-side because it is the renderer-engine seam /// (slice 6). The early `return`s (missing required fields) yield a default /// outcome so the adapter's post-lock block does nothing, exactly as the /// prior `return;` skipped it. pub async fn apply_session_management_event( &self, message_type: &str, payload: &Value, identity: &LocalIdentity, ) -> SessionApplyOutcome { let mut remote_projection_renderer_id: Option = None; let mut sync_local_playback = false; let mut apply_loop_mode: Option = None; let mut disconnected_renderer_id: Option = None; let mut watchdog_arm: Option<(i32, u64)> = None; let mut state = self.sync.lock().await; match message_type { "MESSAGE_TYPE_SRVR_CTRL_SESSION_STATE" => { if let Some(uuid) = payload.get("session_uuid").and_then(Value::as_str) { state.session.session_uuid = Some(uuid.to_string()); } state.session.active_renderer_id = normalize_active_renderer_id( payload.get("active_renderer_id").and_then(Value::as_i64), ); if let Some(loop_mode) = payload .get("loop_mode") .and_then(Value::as_i64) .and_then(|value| i32::try_from(value).ok()) { state.session_loop_mode = Some(loop_mode); apply_loop_mode = Some(loop_mode); } if let (Some(active_renderer_id), Some(loop_mode)) = (state.session.active_renderer_id, state.session_loop_mode) { let renderer_state = ensure_session_renderer_state(&mut state, active_renderer_id); renderer_state.loop_mode = Some(loop_mode); renderer_state.updated_at_ms = now_ms(); } sync_session_renderer_active_flags(&mut state); sync_local_playback = true; } "MESSAGE_TYPE_SRVR_CTRL_ADD_RENDERER" => { if let Some(renderer_id) = payload.get("renderer_id").and_then(Value::as_i64) { let renderer_id = renderer_id as i32; // Don't add duplicates if !state .session .renderers .iter() .any(|r| r.renderer_id == renderer_id) { let device_info = payload.get("device_info"); state.session.renderers.push(QconnectRendererInfo { renderer_id, device_uuid: device_info .and_then(|d| d.get("device_uuid")) .and_then(Value::as_str) .map(String::from), friendly_name: device_info .and_then(|d| d.get("friendly_name")) .and_then(Value::as_str) .map(String::from), brand: device_info .and_then(|d| d.get("brand")) .and_then(Value::as_str) .map(String::from), model: device_info .and_then(|d| d.get("model")) .and_then(Value::as_str) .map(String::from), device_type: device_info .and_then(|d| d.get("device_type")) .and_then(Value::as_i64) .map(|v| v as i32), volume_remote_control: device_info .and_then(|d| d.get("capabilities")) .and_then(|c| c.get("volume_remote_control")) .and_then(Value::as_i64) .map(|v| v as i32), }); refresh_local_renderer_id(&mut state.session, identity); } let _ = ensure_session_renderer_state(&mut state, renderer_id); sync_session_renderer_active_flags(&mut state); } } "MESSAGE_TYPE_SRVR_CTRL_UPDATE_RENDERER" => { if let Some(renderer_id) = payload.get("renderer_id").and_then(Value::as_i64) { let renderer_id = renderer_id as i32; if let Some(existing) = state .session .renderers .iter_mut() .find(|r| r.renderer_id == renderer_id) { let device_info = payload.get("device_info"); if let Some(device_uuid) = device_info .and_then(|d| d.get("device_uuid")) .and_then(Value::as_str) { existing.device_uuid = Some(device_uuid.to_string()); } if let Some(name) = device_info .and_then(|d| d.get("friendly_name")) .and_then(Value::as_str) { existing.friendly_name = Some(name.to_string()); } if let Some(brand) = device_info .and_then(|d| d.get("brand")) .and_then(Value::as_str) { existing.brand = Some(brand.to_string()); } if let Some(model) = device_info .and_then(|d| d.get("model")) .and_then(Value::as_str) { existing.model = Some(model.to_string()); } if let Some(device_type) = device_info .and_then(|d| d.get("device_type")) .and_then(Value::as_i64) { existing.device_type = Some(device_type as i32); } if let Some(vrc) = device_info .and_then(|d| d.get("capabilities")) .and_then(|c| c.get("volume_remote_control")) .and_then(Value::as_i64) { existing.volume_remote_control = Some(vrc as i32); } refresh_local_renderer_id(&mut state.session, identity); } let _ = ensure_session_renderer_state(&mut state, renderer_id); sync_session_renderer_active_flags(&mut state); } } "MESSAGE_TYPE_SRVR_CTRL_REMOVE_RENDERER" => { if let Some(renderer_id) = payload.get("renderer_id").and_then(Value::as_i64) { let renderer_id = renderer_id as i32; state .session .renderers .retain(|r| r.renderer_id != renderer_id); state.session_renderer_states.remove(&renderer_id); refresh_local_renderer_id(&mut state.session, identity); sync_session_renderer_active_flags(&mut state); } } "MESSAGE_TYPE_SRVR_CTRL_ACTIVE_RENDERER_CHANGED" => { state.session.active_renderer_id = normalize_active_renderer_id( payload.get("active_renderer_id").and_then(Value::as_i64), ); if let (Some(active_renderer_id), Some(loop_mode)) = (state.session.active_renderer_id, state.session_loop_mode) { let renderer_state = ensure_session_renderer_state(&mut state, active_renderer_id); renderer_state.loop_mode = Some(loop_mode); renderer_state.updated_at_ms = now_ms(); } apply_loop_mode = state.session_loop_mode; sync_session_renderer_active_flags(&mut state); remote_projection_renderer_id = state.session.active_renderer_id; sync_local_playback = true; // P0-1: active-renderer change disarms any pending liveness task. bump_watchdog_generation(&mut state); } "MESSAGE_TYPE_SRVR_CTRL_RENDERER_STATE_UPDATED" => { let Some(renderer_id) = payload.get("renderer_id").and_then(Value::as_i64) else { return SessionApplyOutcome::default(); }; let player_state = payload.get("player_state"); let renderer_state = ensure_session_renderer_state(&mut state, renderer_id as i32); if let Some(playing_state) = player_state .and_then(|value| value.get("playing_state")) .and_then(Value::as_i64) .and_then(|value| i32::try_from(value).ok()) { renderer_state.playing_state = Some(playing_state); } if let Some(current_position_ms) = player_state .and_then(|value| value.get("current_position")) .and_then(Value::as_i64) .and_then(|value| u64::try_from(value).ok()) { renderer_state.current_position_ms = Some(current_position_ms); } if let Some(current_queue_item_id) = player_state .and_then(|value| value.get("current_queue_item_id")) .and_then(Value::as_i64) { renderer_state.current_queue_item_id = u64::try_from(current_queue_item_id).ok(); } renderer_state.updated_at_ms = now_ms(); // Snapshot the just-written playing_state for the watchdog decision // (the &mut borrow ends here so we can re-read state.session below). let this_playing_state = renderer_state.playing_state; remote_projection_renderer_id = Some(renderer_id as i32); sync_local_playback = true; let is_active_peer = state.session.active_renderer_id == Some(renderer_id as i32) && is_peer_renderer_active(&state.session) && renderer_id != -1; // P0-2: graceful disconnect. status==ACTIVE_DISCONNECTED(2) for // the active remote renderer (id != -1) means the renderer left // cleanly — freeze the projection so the UI stops lying. let status = RendererStatus::from_wire(payload.get("status").and_then(Value::as_i64)); if status == RendererStatus::ActiveDisconnected && is_active_peer { disconnected_renderer_id = Some(renderer_id as i32); } // P0-1 liveness watchdog. Any RENDERER_STATE_UPDATED for the // active peer resets the timer (bump generation); arm a fresh 12s // task only while PLAYING. A non-playing update disarms (bump // only, no spawn). let new_generation = bump_watchdog_generation(&mut state); if should_arm_renderer_watchdog(this_playing_state, is_active_peer) { watchdog_arm = Some((renderer_id as i32, new_generation)); } } "MESSAGE_TYPE_SRVR_CTRL_VOLUME_CHANGED" => { let Some(renderer_id) = payload.get("renderer_id").and_then(Value::as_i64) else { return SessionApplyOutcome::default(); }; let Some(volume) = payload .get("volume") .and_then(Value::as_i64) .and_then(|value| i32::try_from(value).ok()) else { return SessionApplyOutcome::default(); }; let renderer_state = ensure_session_renderer_state(&mut state, renderer_id as i32); renderer_state.volume = Some(volume); renderer_state.updated_at_ms = now_ms(); } "MESSAGE_TYPE_SRVR_CTRL_VOLUME_MUTED" => { let Some(renderer_id) = payload.get("renderer_id").and_then(Value::as_i64) else { return SessionApplyOutcome::default(); }; let Some(muted) = payload.get("value").and_then(Value::as_bool) else { return SessionApplyOutcome::default(); }; let renderer_state = ensure_session_renderer_state(&mut state, renderer_id as i32); renderer_state.muted = Some(muted); renderer_state.updated_at_ms = now_ms(); } "MESSAGE_TYPE_SRVR_CTRL_MAX_AUDIO_QUALITY_CHANGED" => { let Some(renderer_id) = payload.get("renderer_id").and_then(Value::as_i64) else { return SessionApplyOutcome::default(); }; let Some(max_audio_quality) = payload .get("max_audio_quality") .and_then(Value::as_i64) .and_then(|value| i32::try_from(value).ok()) else { return SessionApplyOutcome::default(); }; let renderer_state = ensure_session_renderer_state(&mut state, renderer_id as i32); renderer_state.max_audio_quality = Some(max_audio_quality); renderer_state.updated_at_ms = now_ms(); } "MESSAGE_TYPE_SRVR_CTRL_LOOP_MODE_SET" => { let Some(loop_mode) = payload .get("loop_mode") .and_then(Value::as_i64) .and_then(|value| i32::try_from(value).ok()) else { return SessionApplyOutcome::default(); }; state.session_loop_mode = Some(loop_mode); apply_loop_mode = Some(loop_mode); if let Some(active_renderer_id) = state.session.active_renderer_id { let renderer_state = ensure_session_renderer_state(&mut state, active_renderer_id); renderer_state.loop_mode = Some(loop_mode); renderer_state.updated_at_ms = now_ms(); } } _ => {} } SessionApplyOutcome { remote_projection_renderer_id, sync_local_playback, apply_loop_mode, disconnected_renderer_id, watchdog_arm, } } /// Arm the generation-guarded 12s renderer-liveness watchdog (P0-1). Spawns /// a task holding a cheap clone of self. On wake it re-locks the sync /// accumulator and no-ops unless its captured epoch is still current AND the /// renderer is still the active peer AND still nominally PLAYING; only then /// does it freeze the projection and emit `RendererUnreachable`. Modeled on /// `watch_pending_action_timeout`; relocated from the Tauri sink (slice 2+4). pub fn arm_renderer_watchdog(&self, renderer_id: i32, generation: u64) { let app = self.clone(); tokio::spawn(async move { app.run_renderer_watchdog(renderer_id, generation).await; }); } async fn run_renderer_watchdog(&self, renderer_id: i32, generation: u64) { tokio::time::sleep(Duration::from_millis(QCONNECT_RENDERER_LOST_TIMEOUT_MS)).await; let fire = { let state = self.sync.lock().await; state.watchdog_generation == generation && state.session.active_renderer_id == Some(renderer_id) && is_peer_renderer_active(&state.session) && state .session_renderer_states .get(&renderer_id) .and_then(|r| r.playing_state) == Some(PLAYING_STATE_PLAYING) }; if fire { log::warn!( "[QConnect] Renderer {renderer_id} silent for {}ms — marking unreachable", QCONNECT_RENDERER_LOST_TIMEOUT_MS ); self.freeze_active_renderer_projection( renderer_id, QconnectAppEvent::RendererUnreachable { renderer_id }, ) .await; } } /// Force the active renderer's cached projection to UNKNOWN/stopped and emit /// the freeze event through the sink. Shared by ACTIVE_DISCONNECTED (P0-2) /// and the silence watchdog (P0-1). Relocated from the Tauri sink (slice /// 2+4): the state mutation + `self.sink.on_event(freeze_event)` is /// byte-identical. The sink's mapper arm for `RendererUnreachable` / /// `RendererDisconnected` ONLY emits the dedicated channel (+ the blanket /// event); it does NOT route back into apply or call this helper again, so it /// cannot re-arm the watchdog or recurse. pub async fn freeze_active_renderer_projection( &self, renderer_id: i32, freeze_event: QconnectAppEvent, ) { { let mut state = self.sync.lock().await; let renderer_state = ensure_session_renderer_state(&mut state, renderer_id); renderer_state.playing_state = Some(PLAYING_STATE_UNKNOWN); renderer_state.updated_at_ms = now_ms(); } self.sink.on_event(freeze_event).await; } } /// Prior-state snapshot captured from the sync accumulator BEFORE a SESSION_STATE /// frame is applied, plus the server's classified active state derived from the /// incoming payload. Drives P1-3 takeover arbitration after the apply. Relocated /// from the Tauri adapter (slice 5) so the shared session loop owns it. #[derive(Debug, Clone, Copy)] pub struct SessionStateTakeoverInput { pub was_active: bool, pub was_playing: bool, pub server: ServerActiveState, } /// Preview the first 8 `track_id`s under `payload[key]` for diagnostic emits. /// Pure; relocated from the Tauri adapter (slice 5). pub fn queue_payload_track_preview(payload: &Value, key: &str) -> Vec { payload .get(key) .and_then(Value::as_array) .map(|tracks| { tracks .iter() .filter_map(|track| track.get("track_id").and_then(Value::as_i64)) .take(8) .collect::>() }) .unwrap_or_default() } impl QconnectApp where TTransport: WsTransport + 'static, TSink: QconnectEventSink + 'static, { /// Capture `was_active`/`was_playing` from the current (pre-apply) sync state /// and classify the server's active-renderer state from the incoming /// SESSION_STATE payload, relative to our local renderer id. Pure-ish read; /// takes no decision. Relocated from the Tauri adapter (slice 5); locks /// `self.sync` (the same accumulator the apply path mutates). pub async fn capture_session_state_takeover_input( &self, payload: &Value, ) -> SessionStateTakeoverInput { let st = self.sync.lock().await; let local_id = st.session.local_renderer_id; let was_active = is_local_renderer_active(&st.session); let was_playing = st.last_renderer_playing_state == Some(PLAYING_STATE_PLAYING); // Normalize identically to the apply path (`normalize_active_renderer_id`): // the cloud encodes "no active renderer" as `active_renderer_id: -1`, so a // raw parse would classify -1 as `Some(-1)` and fall into the `Some(_)` // peer-active arm — suppressing the idle auto-take. Filtering `>= 0` maps // -1 (and any negative sentinel) to None, the genuine "session idle" state. let incoming_active = normalize_active_renderer_id( payload.get("active_renderer_id").and_then(Value::as_i64), ); let server = match incoming_active { None => ServerActiveState::None, Some(id) if Some(id) == local_id => ServerActiveState::Me, Some(_) => { // Another renderer owns the slot. Classify playing vs paused from // the last observed peer playing_state; default OtherPaused when unknown. if st.last_renderer_playing_state == Some(PLAYING_STATE_PLAYING) { ServerActiveState::OtherPlaying } else { ServerActiveState::OtherPaused } } }; SessionStateTakeoverInput { was_active, was_playing, server, } } /// Clear the pending action slot iff it still matches `action_uuid`. Used for /// replies that are not reducer-correlated (set-active, ask-for-state). Locks /// `self.state` (NEVER co-locked with `self.sync`). Relocated from the Tauri /// adapter (slice 5). pub async fn clear_pending_if_matches(&self, action_uuid: &str) { let mut state = self.state.lock().await; let pending_matches = state .pending .current() .map(|pending| pending.uuid == action_uuid) .unwrap_or(false); if pending_matches { state.pending.clear(); } } /// Guarded `CtrlSrvrSetActiveRenderer` sender. No-ops when the target equals /// the current active renderer or the id is invalid. Never resets reconnect /// counters (#358 latch untouched). Relocated from the Tauri adapter's /// `send_set_active_renderer_via_app` (slice 5); the request payload /// `{ "renderer_id": }` is byte-identical to the prior /// `QconnectSetActiveRendererRequest` serialization. pub async fn send_set_active_renderer(&self, target_renderer_id: i32) -> Result { if target_renderer_id < 0 { return Ok(false); } { let st = self.sync.lock().await; if st.session.active_renderer_id == Some(target_renderer_id) { return Ok(false); } } let payload = serde_json::json!({ "renderer_id": target_renderer_id }); let command = self .build_queue_command(QueueCommandType::CtrlSrvrSetActiveRenderer, payload) .await; let uuid = self .send_queue_command(command) .await .map_err(|err| format!("send set_active_renderer failed: {err}"))?; self.clear_pending_if_matches(&uuid).await; Ok(true) } /// Ask the currently-active renderer for its full state (P1-8). No-op when no /// active renderer is known. The reply is not reducer-correlated, so its /// pending slot is cleared immediately. Relocated from the Tauri adapter /// (slice 5); payload byte-identical to the prior /// `QconnectAskForRendererStateRequest` serialization. pub async fn ask_for_active_renderer_state(&self) -> Result { let active_id = { let st = self.sync.lock().await; st.session.active_renderer_id }; let Some(active_id) = active_id else { return Ok(false); }; let payload = serde_json::json!({ "renderer_id": active_id }); let cmd = self .build_queue_command(QueueCommandType::CtrlSrvrAskForRendererState, payload) .await; let uuid = self .send_queue_command(cmd) .await .map_err(|err| format!("send ask_for_renderer_state failed: {err}"))?; self.clear_pending_if_matches(&uuid).await; Ok(true) } /// Ask the server for the current queue state (P1-8 Lagged-recovery / generic /// re-sync). The reply is not reducer-correlated, so its pending slot is /// cleared. Relocated from the Tauri adapter (slice 5). pub async fn ask_for_queue_state(&self) -> Result<(), String> { let cmd = self .build_queue_command( QueueCommandType::CtrlSrvrAskForQueueState, serde_json::json!({}), ) .await; let uuid = self .send_queue_command(cmd) .await .map_err(|err| format!("send ask_for_queue_state failed: {err}"))?; self.clear_pending_if_matches(&uuid).await; Ok(()) } } /// Attempt budget for the Lagged-recovery re-AskForQueueState loop (P1-8). const QCONNECT_REASK_QUEUE_STATE_MAX_ATTEMPTS: u32 = 5; /// Adapter-provided seams for the shared session loop. `run_session_loop` is /// frontend-agnostic; it calls these for the bits that must stay adapter-side: /// the lifecycle gating (depends on the adapter's runtime ownership), the /// reconnect-exhausted teardown (R3), controller bootstrap, the renderer-join /// reports (which read the engine's track duration — R2), and the raw error /// surface. Both the Tauri adapter and a future Slint adapter implement this. #[async_trait] pub trait SessionLoopHost: Send + Sync { /// Surface a lifecycle transition. The Tauri adapter gates + dedups this /// (emits `qconnect:status_changed` via the sink only while a runtime is /// still alive); a Slint adapter does its own. async fn update_lifecycle(&self, state: QconnectLifecycleState); /// Re-bootstrap controller presence after a reconnect (JoinSession + ask /// queue state). Logs its own errors. async fn bootstrap_after_reconnect(&self); /// Renderer JoinSession + initial reports for `session_uuid` (R2: reads the /// current track duration from the adapter's engine). Idempotent per uuid. async fn deferred_renderer_join(&self, session_uuid: String, reason: i32); /// Handle MaxReconnectAttemptsExceeded (R3): set Exhausted + last_error, drop /// the runtime unless idle-retry is active, surface the terminal status. /// Returns true if the loop should break (terminate), false to keep idling. async fn on_reconnect_exhausted( &self, attempts: u32, last_reason: String, idle_retry_active: bool, ) -> bool; /// Surface a transport-handling error (the raw `qconnect:error` channel on Tauri). async fn on_loop_error(&self, message: String); } /// Hex preview of up to `max_bytes` bytes for diagnostic logging. Mirrors the /// Tauri adapter's `hex_preview` (relocated with the loop, slice 5). fn hex_preview(data: &[u8], max_bytes: usize) -> String { let take = data.len().min(max_bytes); let hex: String = data[..take] .iter() .map(|b| format!("{b:02x}")) .collect::>() .join(""); if data.len() > max_bytes { format!("{hex}...({}B total)", data.len()) } else { hex } } impl QconnectApp where TTransport: WsTransport + 'static, TSink: QconnectEventSink + 'static, { /// The shared transport event loop. Relocated from the Tauri adapter (slice /// 5): consumes transport events and drives takeover arbitration / deferred /// renderer join / reconnect resync / Lagged re-ask, routing diagnostics + /// lifecycle through `self.sink` + the injected `host`. Byte-identical to the /// prior inline Tauri loop; the adapter-coupled seams (lifecycle gating, /// teardown, bootstrap, renderer-join, raw error) go through `host` so both /// frontends share this control flow. pub async fn run_session_loop( &self, host: Arc, mut transport_rx: tokio::sync::broadcast::Receiver, idle_retry_active: bool, ) { // NOTE: `transport_rx` is subscribed by the adapter SYNCHRONOUSLY before // this task is spawned (and before any further await), so the receiver is // live before the WS handshake can emit its initial events. tokio // broadcast has no replay — subscribing here, inside the spawned task, // would race those events and silently drop them. log::info!("[QConnect/EventLoop] Started listening for transport events"); let mut renderer_joined = false; let mut has_disconnected = false; // One-shot latch: auto-take the render at most ONCE per fresh connect, on // the first SESSION_STATE that reports no active renderer. Prevents // re-grabbing after the user later gives the render to a peer (which makes // the session go idle again). Reset on disconnect (a reconnect rejoins via // the RECONNECTION reason, not via auto-take). let mut auto_take_attempted = false; // Set when we DECIDED to auto-take on a no-active SESSION_STATE but our // local_renderer_id was not known yet (the cloud's ADD_RENDERER for our // just-sent join lands a beat later). The per-iteration check below fires // the SET_ACTIVE as soon as the id arrives — and ONLY if nobody else has // become active meanwhile (anti-steal). Reset on disconnect. let mut pending_auto_take = false; // P1-8: budget for re-AskForQueueState after Lagged broadcast drops, // until the session_uuid is confirmed. Reset on disconnect. let mut lagged_reask_attempts: u32 = 0; loop { match transport_rx.recv().await { Ok(event) => { // P1-3: on every SESSION_STATE, capture our prior active/playing // state + classify the server's active renderer BEFORE the sink // applies the new state, so takeover arbitration runs on the // prior snapshot once the apply lands below. let mut takeover_input: Option = None; if let TransportEvent::InboundQueueServerEvent(ref evt) = event { if evt.message_type() == "MESSAGE_TYPE_SRVR_CTRL_SESSION_STATE" { takeover_input = Some(self.capture_session_state_takeover_input(&evt.payload).await); if !renderer_joined { if let Some(session_uuid) = evt.payload.get("session_uuid").and_then(|v| v.as_str()) { renderer_joined = true; host.deferred_renderer_join( session_uuid.to_string(), deferred_join_reason(has_disconnected), ) .await; } else { log::warn!("[QConnect] SESSION_STATE received but no session_uuid in payload: {}", evt.payload); } } } } match &event { TransportEvent::Connected => { log::info!("[QConnect/Transport] WebSocket connected"); } TransportEvent::Disconnected => { log::warn!("[QConnect/Transport] WebSocket disconnected — resetting renderer_joined flag"); renderer_joined = false; has_disconnected = true; auto_take_attempted = false; pending_auto_take = false; lagged_reask_attempts = 0; // Surface "Reconnecting" to the UI, but only if we're // not in a teardown path (Off/Exhausted). The host gates // this on a live runtime. host.update_lifecycle(QconnectLifecycleState::Reconnecting) .await; } TransportEvent::Authenticated => { log::info!("[QConnect/Transport] Authenticated with JWT"); } TransportEvent::Subscribed => { log::info!("[QConnect/Transport] Subscribed to channels"); // Re-bootstrap only after a reconnection (not on initial // connect, where connect() already bootstraps). if has_disconnected { log::info!("[QConnect] Re-bootstrapping after reconnect..."); host.bootstrap_after_reconnect().await; // P1-8: resync renderer state too, not just the queue. if let Err(err) = self.ask_for_active_renderer_state().await { log::warn!("[QConnect] AskForRendererState after reconnect failed: {err}"); } // P1-11: signal the frontend that the post-reconnect // resync has been issued. self.sink.on_event(QconnectAppEvent::ResyncComplete).await; } } TransportEvent::KeepalivePingSent => { log::debug!("[QConnect/Transport] Keepalive ping sent"); } TransportEvent::KeepalivePongReceived => { log::debug!("[QConnect/Transport] Keepalive pong received"); } TransportEvent::ReconnectScheduled { attempt, backoff_ms, reason, } => { log::warn!("[QConnect/Transport] Reconnect scheduled: attempt={} backoff={}ms reason={}", attempt, backoff_ms, reason); } TransportEvent::InboundQueueServerEvent(evt) => { log::info!( "[QConnect] <-- Inbound queue event: {} payload={}", evt.message_type(), evt.payload ); self.sink .on_event(QconnectAppEvent::Diagnostic { channel: "qconnect:inbound_queue_event".to_string(), level: "info".to_string(), payload: serde_json::json!({ "message_type": evt.message_type(), "action_uuid": evt.action_uuid.clone(), "queue_version": evt.queue_version, "track_count": evt.payload.get("tracks").and_then(|value| value.as_array()).map(|tracks| tracks.len()).unwrap_or(0), "autoplay_track_count": evt.payload.get("autoplay_tracks").and_then(|value| value.as_array()).map(|tracks| tracks.len()).unwrap_or(0), "preview_track_ids": queue_payload_track_preview(&evt.payload, "tracks"), "preview_autoplay_track_ids": queue_payload_track_preview(&evt.payload, "autoplay_tracks"), }), }) .await; } TransportEvent::InboundRendererServerCommand(cmd) => { log::info!( "[QConnect] <-- Inbound renderer command: {} payload={}", cmd.message_type(), cmd.payload ); } TransportEvent::InboundFrameDecoded { cloud_message_type, payload_size, } => { log::info!( "[QConnect/Transport] <-- Frame decoded: cloud_type={} size={}", cloud_message_type, payload_size ); } TransportEvent::InboundPayloadBytes { cloud_message_type, payload, } => { log::info!("[QConnect/Transport] <-- Payload bytes: cloud_type={} len={} hex={}", cloud_message_type, payload.len(), hex_preview(payload, 64)); } TransportEvent::OutboundSent { message_type, action_uuid, } => { log::info!( "[QConnect/Transport] --> Outbound sent: {} uuid={}", message_type, action_uuid ); } TransportEvent::TransportError { stage, message } => { log::error!( "[QConnect/Transport] Error: stage={} message={}", stage, message ); } TransportEvent::CloudError { msg_id, code, descr, } => { log::warn!( "[QConnect/Transport] Cloud rejected session: msg_id={} code={} descr={:?} (issue #358)", msg_id, code, descr ); self.sink .on_event(QconnectAppEvent::Diagnostic { channel: "qconnect:cloud_error".to_string(), level: "warning".to_string(), payload: serde_json::json!({ "msg_id": msg_id, "code": code, "descr": descr, }), }) .await; } TransportEvent::InboundReceived(_envelope) => { log::info!("[QConnect/Transport] <-- InboundReceived (JSON envelope)"); } TransportEvent::SessionEstablished => { log::info!( "[QConnect/Transport] Session established — backoff counters reset" ); host.update_lifecycle(QconnectLifecycleState::Connected).await; } TransportEvent::MaxReconnectAttemptsExceeded { attempts, last_reason, } => { log::error!( "[QConnect/Transport] Max reconnect attempts exceeded: attempts={} last_reason={}", attempts, last_reason ); self.sink .on_event(QconnectAppEvent::Diagnostic { channel: "qconnect:max_reconnect_attempts_exceeded".to_string(), level: "error".to_string(), payload: serde_json::json!({ "attempts": attempts, "last_reason": last_reason, }), }) .await; // R3: the adapter owns the runtime/teardown. It sets // Exhausted + last_error, drops the runtime unless idle- // retry is active, surfaces the terminal status, and tells // us whether to break (terminate) or keep idling. let should_break = host .on_reconnect_exhausted( *attempts, last_reason.clone(), idle_retry_active, ) .await; if should_break { break; } // gap #7 (idle_retry_active): keep the loop alive for the // re-armed transport; skip the reducer for this terminal // diagnostic and wait for the next event. continue; } } if let Err(err) = self.handle_transport_event(event).await { let message = format!("qconnect app transport handling error: {err}"); log::error!("{message}"); host.on_loop_error(message).await; } // P1-3: now that the sink has applied the SESSION_STATE, run // takeover arbitration on the prior snapshot captured above. // Only the claim-active path is wired here; never resets // reconnect counters (#358 latch untouched). if let Some(input) = takeover_input { // Auto-take the render only on a FRESH connect (never a // reconnect — that rejoins active via the RECONNECTION join // reason), only when the cloud reports nobody active, and // only ONCE per connect (the latch). This can never steal // from an active peer: an active peer classifies as // server==Other*/Me, not None. let auto_take_when_idle = !has_disconnected && matches!(input.server, ServerActiveState::None) && !auto_take_attempted && !pending_auto_take; let decision = compute_connection_state( input.was_active, input.was_playing, input.server, // queue_equal is not yet derivable here without a // controller/renderer queue diff; default false so the // reduced matrix never spuriously suppresses a push. false, auto_take_when_idle, ); if decision.should_set_active_renderer { let local_id = { let st = self.sync.lock().await; st.session.local_renderer_id }; match local_id { Some(local_id) => { // Latch ONLY on an actual send (reconnect // re-claim, or the idle auto-take when our // ADD_RENDERER already landed). auto_take_attempted = true; if let Err(err) = self.send_set_active_renderer(local_id).await { log::warn!( "[QConnect] takeover set_active_renderer failed: {err}" ); } } None if auto_take_when_idle => { // Our just-sent join is not yet confirmed, so // local_renderer_id is unknown. Defer to the // per-iteration check below, which fires once // the cloud's ADD_RENDERER for us lands. pending_auto_take = true; } None => {} } } } // Fire a deferred idle auto-take as soon as our // local_renderer_id lands — but ONLY while the session is still // idle (no active renderer), so we never steal a peer that // became active while we waited for our id. if pending_auto_take { let (local_id, active_id) = { let st = self.sync.lock().await; (st.session.local_renderer_id, st.session.active_renderer_id) }; if active_id.is_some() { // Someone is active now — abandon the auto-take. pending_auto_take = false; auto_take_attempted = true; } else if let Some(local_id) = local_id { pending_auto_take = false; auto_take_attempted = true; log::info!( "[QConnect] idle auto-take: claiming render (local_id={local_id})" ); if let Err(err) = self.send_set_active_renderer(local_id).await { log::warn!( "[QConnect] idle auto-take set_active_renderer failed: {err}" ); } } } } Err(tokio::sync::broadcast::error::RecvError::Lagged(skipped)) => { log::warn!("[QConnect] Transport event lagged by {skipped} messages"); // P1-8: a Lagged drop may have eaten the SESSION_STATE carrying // the session_uuid. Re-ask for queue state until the uuid is // confirmed or the attempt budget is spent. let session_uuid_known = { let st = self.sync.lock().await; st.session.session_uuid.is_some() }; if should_reask_queue_state( session_uuid_known, lagged_reask_attempts, QCONNECT_REASK_QUEUE_STATE_MAX_ATTEMPTS, ) { lagged_reask_attempts = lagged_reask_attempts.saturating_add(1); if let Err(err) = self.ask_for_queue_state().await { log::warn!("[QConnect] Lagged-recovery AskForQueueState failed: {err}"); } } } Err(tokio::sync::broadcast::error::RecvError::Closed) => { log::warn!("[QConnect/EventLoop] Transport channel closed, stopping"); break; } } } log::info!("[QConnect/EventLoop] Stopped"); } } #[cfg(test)] mod tests { use std::sync::Arc; use async_trait::async_trait; use qconnect_core::QueueVersion; use qconnect_transport_ws::InMemoryWsTransport; use crate::session::{LocalIdentity, QconnectRendererInfo, ServerActiveState}; use crate::QconnectRemoteSyncState; use serde_json::json; use tokio::sync::Mutex; use crate::{QconnectAppEvent, QconnectEventSink}; use super::{queue_hashes_diverge, QconnectApp}; use qconnect_core::QConnectQueueState; use qconnect_protocol::{ QueueCommandType, QueueEventType, QueueServerEvent, RendererCommandType, RendererServerCommand, }; use qconnect_transport_ws::WsTransportConfig; #[derive(Debug, Default, Clone)] struct TestSink { events: Arc>>, } impl TestSink { async fn snapshot(&self) -> Vec { self.events.lock().await.clone() } } #[async_trait] impl QconnectEventSink for TestSink { async fn on_event(&self, event: QconnectAppEvent) { self.events.lock().await.push(event); } } fn test_config() -> WsTransportConfig { WsTransportConfig { endpoint_url: "wss://example.invalid/ws".to_string(), subscribe_channels: vec![vec![1, 2, 3]], ..Default::default() } } async fn build_connected_app() -> ( QconnectApp, TestSink, Arc, tokio::sync::broadcast::Receiver, ) { let transport = Arc::new(InMemoryWsTransport::new()); let sink = TestSink::default(); let app = QconnectApp::new( Arc::clone(&transport), Arc::new(sink.clone()), Arc::new(Mutex::new(QconnectRemoteSyncState::default())), ); let events_rx = app.subscribe_transport_events(); app.connect(test_config()).await.expect("connect"); (app, sink, transport, events_rx) } fn renderer_info(renderer_id: i32, device_uuid: &str) -> QconnectRendererInfo { QconnectRendererInfo { renderer_id, device_uuid: Some(device_uuid.to_string()), friendly_name: None, brand: None, model: None, device_type: None, volume_remote_control: None, } } fn local_identity(device_uuid: &str) -> LocalIdentity { LocalIdentity { device_uuid: device_uuid.to_string(), ..Default::default() } } /// Seed a local(1) + peer(2) topology with the peer as the active renderer. async fn seed_local_and_active_peer(app: &QconnectApp) { let handle = app.sync_handle(); let mut state = handle.lock().await; state.session.local_renderer_id = Some(1); state.session.active_renderer_id = Some(2); state.session.renderers = vec![renderer_info(1, "local-uuid"), renderer_info(2, "peer-uuid")]; } /// SESSION_STATE writes session topology under the sync lock and reports the /// post-lock work (loop mode + local-playback handoff) in the outcome. #[tokio::test] async fn apply_session_state_sets_topology_and_returns_outcome() { let (app, _sink, _transport, _rx) = build_connected_app().await; let outcome = app .apply_session_management_event( "MESSAGE_TYPE_SRVR_CTRL_SESSION_STATE", &json!({ "session_uuid": "sess-1", "active_renderer_id": 2, "loop_mode": 3 }), &local_identity("local-uuid"), ) .await; assert!(outcome.sync_local_playback); assert_eq!(outcome.apply_loop_mode, Some(3)); let handle = app.sync_handle(); let state = handle.lock().await; assert_eq!(state.session.session_uuid.as_deref(), Some("sess-1")); assert_eq!(state.session.active_renderer_id, Some(2)); assert_eq!(state.session_loop_mode, Some(3)); } /// Regression (take-renderer-when-idle): the cloud encodes "no active /// renderer" as `active_renderer_id: -1`. The takeover classifier must /// normalize it to `ServerActiveState::None` — identical to the apply /// path's `normalize_active_renderer_id` — so the idle auto-take fires on a /// fresh connect. A raw parse mis-read -1 as `Some(-1)` (a peer is active), /// classified it as `OtherPaused`, and silently suppressed the auto-take. #[tokio::test] async fn capture_takeover_treats_negative_active_renderer_as_none() { let (app, _sink, _transport, _rx) = build_connected_app().await; { let handle = app.sync_handle(); let mut state = handle.lock().await; state.session.local_renderer_id = Some(8); } let input = app .capture_session_state_takeover_input(&json!({ "active_renderer_id": -1 })) .await; assert_eq!(input.server, ServerActiveState::None); } /// A real active peer (id >= 0, not us) still classifies as a peer, so the /// auto-take never steals it. #[tokio::test] async fn capture_takeover_treats_active_peer_as_other() { let (app, _sink, _transport, _rx) = build_connected_app().await; { let handle = app.sync_handle(); let mut state = handle.lock().await; state.session.local_renderer_id = Some(8); } let input = app .capture_session_state_takeover_input(&json!({ "active_renderer_id": 5 })) .await; assert!(matches!( input.server, ServerActiveState::OtherPlaying | ServerActiveState::OtherPaused )); } /// A RENDERER_STATE_UPDATED for a PLAYING active peer arms the watchdog and /// reports the renderer for projection. #[tokio::test] async fn renderer_state_updated_arms_watchdog_for_playing_active_peer() { let (app, _sink, _transport, _rx) = build_connected_app().await; seed_local_and_active_peer(&app).await; let outcome = app .apply_session_management_event( "MESSAGE_TYPE_SRVR_CTRL_RENDERER_STATE_UPDATED", &json!({ "renderer_id": 2, "player_state": { "playing_state": 2 } }), &local_identity("local-uuid"), ) .await; let (renderer_id, _generation) = outcome .watchdog_arm .expect("watchdog should arm for a playing active peer"); assert_eq!(renderer_id, 2); assert_eq!(outcome.remote_projection_renderer_id, Some(2)); } /// The full arm -> 12s silence -> fire path: emits RendererUnreachable and /// freezes the cached projection to UNKNOWN(0). #[tokio::test(start_paused = true)] async fn watchdog_fires_after_silence_and_freezes_projection() { let (app, sink, _transport, _rx) = build_connected_app().await; seed_local_and_active_peer(&app).await; let outcome = app .apply_session_management_event( "MESSAGE_TYPE_SRVR_CTRL_RENDERER_STATE_UPDATED", &json!({ "renderer_id": 2, "player_state": { "playing_state": 2 } }), &local_identity("local-uuid"), ) .await; let (renderer_id, generation) = outcome.watchdog_arm.expect("arm"); app.arm_renderer_watchdog(renderer_id, generation); tokio::task::yield_now().await; tokio::time::advance(std::time::Duration::from_millis(12_000 + 10)).await; tokio::task::yield_now().await; let events = sink.snapshot().await; assert!( events .iter() .any(|e| matches!(e, QconnectAppEvent::RendererUnreachable { renderer_id: 2 })), "expected RendererUnreachable for renderer 2" ); let handle = app.sync_handle(); let state = handle.lock().await; assert_eq!( state .session_renderer_states .get(&2) .and_then(|r| r.playing_state), Some(0), "frozen renderer playing_state must be UNKNOWN(0)" ); } /// Atomicity regression: a stale-epoch watchdog must no-op. A subsequent /// non-playing update bumps the epoch (disarm) without arming a new task, so /// the first task wakes to a superseded generation and does NOT fire. #[tokio::test(start_paused = true)] async fn watchdog_disarmed_by_epoch_bump_does_not_fire() { let (app, sink, _transport, _rx) = build_connected_app().await; seed_local_and_active_peer(&app).await; let armed = app .apply_session_management_event( "MESSAGE_TYPE_SRVR_CTRL_RENDERER_STATE_UPDATED", &json!({ "renderer_id": 2, "player_state": { "playing_state": 2 } }), &local_identity("local-uuid"), ) .await; let (renderer_id, generation) = armed.watchdog_arm.expect("arm"); app.arm_renderer_watchdog(renderer_id, generation); // A paused update bumps the watchdog epoch and does NOT arm a new task. let disarm = app .apply_session_management_event( "MESSAGE_TYPE_SRVR_CTRL_RENDERER_STATE_UPDATED", &json!({ "renderer_id": 2, "player_state": { "playing_state": 3 } }), &local_identity("local-uuid"), ) .await; assert!(disarm.watchdog_arm.is_none()); tokio::task::yield_now().await; tokio::time::advance(std::time::Duration::from_millis(12_000 + 10)).await; tokio::task::yield_now().await; let events = sink.snapshot().await; assert!( !events .iter() .any(|e| matches!(e, QconnectAppEvent::RendererUnreachable { .. })), "stale-epoch watchdog must not fire after a disarming bump" ); } /// ACTIVE_DISCONNECTED(status==2) for the active peer reports the /// disconnected renderer; freezing emits RendererDisconnected + UNKNOWN(0). #[tokio::test] async fn active_disconnected_reports_id_and_freeze_emits() { let (app, sink, _transport, _rx) = build_connected_app().await; seed_local_and_active_peer(&app).await; let outcome = app .apply_session_management_event( "MESSAGE_TYPE_SRVR_CTRL_RENDERER_STATE_UPDATED", &json!({ "renderer_id": 2, "status": 2, "player_state": { "playing_state": 2 } }), &local_identity("local-uuid"), ) .await; assert_eq!(outcome.disconnected_renderer_id, Some(2)); app.freeze_active_renderer_projection( 2, QconnectAppEvent::RendererDisconnected { renderer_id: 2 }, ) .await; let events = sink.snapshot().await; assert!(events .iter() .any(|e| matches!(e, QconnectAppEvent::RendererDisconnected { renderer_id: 2 }))); let handle = app.sync_handle(); let state = handle.lock().await; assert_eq!( state .session_renderer_states .get(&2) .and_then(|r| r.playing_state), Some(0) ); } #[tokio::test(start_paused = true)] async fn pending_timeout_triggers_resync() { let (app, sink, transport, _events_rx) = build_connected_app().await; let command = app .build_queue_command( QueueCommandType::CtrlSrvrQueueAddTracks, json!({"track_ids":[101]}), ) .await; app.send_queue_command(command) .await .expect("send queue command"); tokio::task::yield_now().await; tokio::time::advance(std::time::Duration::from_millis( QconnectApp::::PENDING_ACTION_TIMEOUT_MS + 10, )) .await; tokio::task::yield_now().await; let events = sink.snapshot().await; assert!(events .iter() .any(|event| { matches!(event, QconnectAppEvent::PendingActionTimedOut { .. }) })); assert!(events .iter() .any(|event| matches!(event, QconnectAppEvent::QueueResyncTriggered))); let sent = transport.sent_messages().await; assert!( sent.len() >= 2, "expected original command plus ask-for-state resync" ); } #[tokio::test] async fn concurrent_remote_event_cancels_pending_and_requests_resync() { let (app, sink, transport, _events_rx) = build_connected_app().await; let command = app .build_queue_command( QueueCommandType::CtrlSrvrQueueAddTracks, json!({"track_ids":[101]}), ) .await; let pending_uuid = app .send_queue_command(command) .await .expect("send queue command"); let remote_event = QueueServerEvent { event_type: QueueEventType::SrvrCtrlQueueTracksAdded, action_uuid: Some("0f892e1a-a2f4-4d18-82c6-31e8daf2ea0f".to_string()), queue_version: Some(QueueVersion::new(1, 1)), payload: json!({"tracks":[]}), }; app.apply_server_event(remote_event) .await .expect("apply concurrent event"); let events = sink.snapshot().await; assert!(events.iter().any(|event| { matches!( event, QconnectAppEvent::PendingActionCanceledByConcurrentRemoteEvent { pending_uuid: id, .. } if id == &pending_uuid ) })); assert!(events .iter() .any(|event| matches!(event, QconnectAppEvent::QueueResyncTriggered))); let sent = transport.sent_messages().await; assert!( sent.len() >= 2, "expected original command plus ask-for-state resync" ); } #[tokio::test] async fn shuffle_mode_set_requests_authoritative_queue_state() { let (app, sink, transport, _events_rx) = build_connected_app().await; app.apply_server_event(QueueServerEvent { event_type: QueueEventType::SrvrCtrlShuffleModeSet, action_uuid: Some("6f9f8d84-cd82-486f-a423-cd467117f39d".to_string()), queue_version: Some(QueueVersion::new(1, 2)), payload: json!({ "shuffle_mode": true, "shuffle_seed": 123, "shuffle_pivot_queue_item_id": 0, "autoplay_reset": false, "autoplay_loading": false }), }) .await .expect("apply shuffle-mode-set event"); let events = sink.snapshot().await; assert!(events .iter() .any(|event| matches!(event, QconnectAppEvent::QueueUpdated(_)))); assert!(events .iter() .any(|event| matches!(event, QconnectAppEvent::QueueResyncTriggered))); let sent = transport.sent_messages().await; assert!( !sent.is_empty(), "expected ask-for-state resync after shuffle" ); } #[tokio::test] async fn reorder_event_requests_authoritative_queue_state() { let (app, sink, transport, _events_rx) = build_connected_app().await; app.apply_server_event(QueueServerEvent { event_type: QueueEventType::SrvrCtrlQueueTracksReordered, action_uuid: Some("a1b2c3d4-e5f6-7890-abcd-ef1234567890".to_string()), queue_version: Some(QueueVersion::new(2, 1)), payload: json!({ "queue_item_ids": [3], "insert_after": 1, "autoplay_reset": false, "autoplay_loading": false }), }) .await .expect("apply reorder event"); let events = sink.snapshot().await; assert!(events .iter() .any(|event| matches!(event, QconnectAppEvent::QueueResyncTriggered))); let sent = transport.sent_messages().await; assert!( !sent.is_empty(), "expected ask-for-state resync after reorder" ); } #[tokio::test] async fn remove_event_requests_authoritative_queue_state() { let (app, sink, transport, _events_rx) = build_connected_app().await; app.apply_server_event(QueueServerEvent { event_type: QueueEventType::SrvrCtrlQueueTracksRemoved, action_uuid: Some("b2c3d4e5-f6a7-8901-bcde-f12345678901".to_string()), queue_version: Some(QueueVersion::new(3, 1)), payload: json!({ "queue_item_ids": [2], "autoplay_reset": false, "autoplay_loading": false }), }) .await .expect("apply remove event"); let events = sink.snapshot().await; assert!(events .iter() .any(|event| matches!(event, QconnectAppEvent::QueueResyncTriggered))); let sent = transport.sent_messages().await; assert!( !sent.is_empty(), "expected ask-for-state resync after remove" ); } #[test] fn queue_hashes_diverge_is_inert_without_local_algorithm() { let mut queue = QConnectQueueState::default(); queue.last_server_queue_hash = Some(vec![9, 9, 9]); assert!( !queue_hashes_diverge(&queue), "divergence detection must stay inert until the local hash algorithm is known" ); } #[tokio::test] async fn queue_state_event_surfaces_server_queue_hash() { let (app, _sink, _transport, _events_rx) = build_connected_app().await; app.apply_server_event(QueueServerEvent { event_type: QueueEventType::SrvrCtrlQueueState, action_uuid: None, queue_version: Some(QueueVersion::new(1, 0)), payload: json!({ "tracks": [], "shuffle_mode": false, "autoplay_tracks": [], "server_queue_hash": [1, 2, 3, 4] }), }) .await .expect("apply queue-state event"); let snap = app.queue_state_snapshot().await; assert_eq!( snap.last_server_queue_hash.as_deref(), Some(&[1u8, 2, 3, 4][..]) ); } #[tokio::test] async fn inbound_playback_error_emits_playback_error_app_event() { use prost::Message as _; use qconnect_protocol::{ ErrorType, PlaybackErrorMessage, QConnectMessage, QConnectMessages, QueueVersionRef, }; use qconnect_transport_ws::TransportEvent; let (app, sink, _transport, _events_rx) = build_connected_app().await; let batch = QConnectMessages { messages_time: None, messages_id: None, messages: vec![QConnectMessage { message_type: Some(2), // PLAYBACK_ERROR playback_error: Some(PlaybackErrorMessage { queue_version: Some(QueueVersionRef { major: Some(4), minor: Some(2), }), queue_item_id: Some(77), error_type: Some(5), // NETWORK_ERROR }), ..Default::default() }], }; app.handle_transport_event(TransportEvent::InboundPayloadBytes { cloud_message_type: 0, payload: batch.encode_to_vec(), }) .await .expect("handle playback-error frame"); let events = sink.snapshot().await; assert!( events.iter().any(|event| matches!( event, QconnectAppEvent::PlaybackError { queue_item_id: 77, error_type: ErrorType::NetworkError, .. } )), "expected a PlaybackError app event for queue item 77 / NetworkError" ); } #[tokio::test] async fn autoplay_growth_triggers_queue_state_resync() { let (app, sink, transport, _events_rx) = build_connected_app().await; app.apply_server_event(QueueServerEvent { event_type: QueueEventType::SrvrCtrlQueueTracksAddedFromAutoplay, action_uuid: None, queue_version: Some(QueueVersion::new(2, 0)), payload: json!({ "queue_item_ids": [101, 102] }), }) .await .expect("apply autoplay-growth event"); let events = sink.snapshot().await; assert!( events .iter() .any(|event| matches!(event, QconnectAppEvent::QueueResyncTriggered)), "autoplay growth must force an AskForQueueState resync" ); let sent = transport.sent_messages().await; assert!( !sent.is_empty(), "expected ask-for-state resync after autoplay growth" ); } #[tokio::test] async fn late_queue_error_for_concurrency_canceled_action_is_ignored() { let (app, sink, _, _events_rx) = build_connected_app().await; { let state = app.state_handle(); let mut guard = state.lock().await; guard.concurrency_canceled_action_uuid = Some("85fa0dd6-7bd6-4b3c-8f43-b8ee22e65d5e".to_string()); } let late_error = QueueServerEvent { event_type: QueueEventType::SrvrCtrlQueueErrorMessage, action_uuid: Some("85fa0dd6-7bd6-4b3c-8f43-b8ee22e65d5e".to_string()), queue_version: Some(QueueVersion::new(2, 1)), payload: json!({ "error_code": "409", "error_message": "stale_queue_version" }), }; app.apply_server_event(late_error) .await .expect("apply late queue error"); let events = sink.snapshot().await; assert!(events.iter().any(|event| { matches!( event, QconnectAppEvent::QueueErrorIgnoredByConcurrency { action_uuid } if action_uuid == "85fa0dd6-7bd6-4b3c-8f43-b8ee22e65d5e" ) })); assert!( !events .iter() .any(|event| matches!(event, QconnectAppEvent::QueueUpdated(_))), "ignored late queue error should not mutate queue" ); } #[tokio::test] async fn matching_session_management_event_completes_pending_action() { let (app, sink, _transport, _events_rx) = build_connected_app().await; let command = app .build_queue_command( QueueCommandType::CtrlSrvrSetActiveRenderer, json!({ "active_renderer_id": 1 }), ) .await; let pending_uuid = app .send_queue_command(command) .await .expect("send set-active-renderer command"); let matching_event = QueueServerEvent { event_type: QueueEventType::SrvrCtrlActiveRendererChanged, action_uuid: Some(pending_uuid.clone()), queue_version: Some(QueueVersion::new(1, 1)), payload: json!({ "active_renderer_id": 1 }), }; app.apply_server_event(matching_event) .await .expect("apply active-renderer-changed event"); let second_command = app .build_queue_command( QueueCommandType::CtrlSrvrQueueLoadTracks, json!({ "track_ids": [101, 102] }), ) .await; app.send_queue_command(second_command) .await .expect("pending action should be cleared by matching session event"); let events = sink.snapshot().await; assert!(events.iter().any(|event| { matches!( event, QconnectAppEvent::PendingActionCompleted { uuid } if uuid == &pending_uuid ) })); assert!(events.iter().any(|event| { matches!( event, QconnectAppEvent::SessionManagementEvent { message_type, .. } if message_type == "MESSAGE_TYPE_SRVR_CTRL_ACTIVE_RENDERER_CHANGED" ) })); } #[tokio::test] async fn active_renderer_changed_without_action_uuid_completes_matching_pending_action() { let (app, sink, _transport, _events_rx) = build_connected_app().await; let command = app .build_queue_command( QueueCommandType::CtrlSrvrSetActiveRenderer, json!({ "renderer_id": 16 }), ) .await; let pending_uuid = app .send_queue_command(command) .await .expect("send set-active-renderer command"); app.apply_server_event(QueueServerEvent { event_type: QueueEventType::SrvrCtrlActiveRendererChanged, action_uuid: None, queue_version: Some(QueueVersion::new(1, 1)), payload: json!({ "active_renderer_id": 16 }), }) .await .expect("apply active-renderer-changed event without action uuid"); let second_command = app .build_queue_command( QueueCommandType::CtrlSrvrQueueLoadTracks, json!({ "track_ids": [201, 202] }), ) .await; app.send_queue_command(second_command) .await .expect("matching active-renderer change should clear pending action"); let events = sink.snapshot().await; assert!(events.iter().any(|event| { matches!( event, QconnectAppEvent::PendingActionCompleted { uuid } if uuid == &pending_uuid ) })); } #[tokio::test] async fn renderer_state_update_completes_transport_control_pending_without_action_uuid() { let (app, sink, _transport, _events_rx) = build_connected_app().await; let command = app .build_queue_command( QueueCommandType::CtrlSrvrSetPlayerState, json!({ "playing_state": 2, "current_position": 0, "current_queue_item": { "queue_version": { "major": 1, "minor": 1 }, "id": 1 } }), ) .await; let pending_uuid = app .send_queue_command(command) .await .expect("send set-player-state command"); app.apply_server_event(QueueServerEvent { event_type: QueueEventType::SrvrCtrlRendererStateUpdated, action_uuid: None, queue_version: Some(QueueVersion::new(1, 1)), payload: json!({ "renderer_id": 1, "status": 1, "player_state": { "playing_state": 2, "current_position": 1234, "current_queue_item_id": 1 } }), }) .await .expect("apply renderer-state-updated event"); let second_command = app .build_queue_command( QueueCommandType::CtrlSrvrSetPlayerState, json!({ "playing_state": 2, "current_position": 0, "current_queue_item": { "queue_version": { "major": 1, "minor": 1 }, "id": 2 } }), ) .await; app.send_queue_command(second_command) .await .expect("transport control pending should clear after renderer-state update"); let events = sink.snapshot().await; assert!(events.iter().any(|event| { matches!( event, QconnectAppEvent::PendingActionCompleted { uuid } if uuid == &pending_uuid ) })); } #[tokio::test] async fn loop_mode_set_without_action_uuid_completes_matching_pending_action() { let (app, sink, _transport, _events_rx) = build_connected_app().await; let command = app .build_queue_command( QueueCommandType::CtrlSrvrSetLoopMode, json!({ "loop_mode": 3 }), ) .await; let pending_uuid = app .send_queue_command(command) .await .expect("send set-loop-mode command"); app.apply_server_event(QueueServerEvent { event_type: QueueEventType::SrvrCtrlLoopModeSet, action_uuid: None, queue_version: Some(QueueVersion::new(1, 1)), payload: json!({ "loop_mode": 3 }), }) .await .expect("apply loop-mode-set event without action uuid"); let second_command = app .build_queue_command( QueueCommandType::CtrlSrvrSetLoopMode, json!({ "loop_mode": 2 }), ) .await; app.send_queue_command(second_command) .await .expect("loop-mode-set event should clear pending action"); let events = sink.snapshot().await; assert!(events.iter().any(|event| { matches!( event, QconnectAppEvent::PendingActionCompleted { uuid } if uuid == &pending_uuid ) })); assert!(events.iter().any(|event| { matches!( event, QconnectAppEvent::SessionManagementEvent { message_type, .. } if message_type == "MESSAGE_TYPE_SRVR_CTRL_LOOP_MODE_SET" ) })); } #[tokio::test] async fn inbound_renderer_command_updates_renderer_state() { let (app, sink, transport, _events_rx) = build_connected_app().await; app.apply_renderer_server_command(RendererServerCommand { command_type: RendererCommandType::SrvrRndrSetState, payload: json!({ "playing_state": 2, "current_position": 65321, "current_track": { "track_context_uuid": "ctx-remote", "track_id": 777001, "queue_item_id": 991 } }), }) .await .expect("apply set-state command"); app.apply_renderer_server_command(RendererServerCommand { command_type: RendererCommandType::SrvrRndrSetVolume, payload: json!({ "volume": 52, "volume_delta": 3 }), }) .await .expect("apply set-volume command"); let renderer = app.renderer_state_snapshot().await; assert_eq!(renderer.playing_state, Some(2)); assert_eq!(renderer.current_position_ms, Some(65_321)); assert_eq!(renderer.volume, Some(55)); assert_eq!(renderer.volume_delta, Some(3)); assert_eq!( renderer .current_track .as_ref() .map(|item| item.queue_item_id), Some(991) ); let events = sink.snapshot().await; assert!( events .iter() .filter(|event| matches!(event, QconnectAppEvent::RendererUpdated(_))) .count() >= 2 ); assert!(events .iter() .any(|event| matches!(event, QconnectAppEvent::RendererCommandApplied { .. }))); let sent = transport.sent_messages().await; assert!(sent .iter() .any(|msg| msg.message_type == "MESSAGE_TYPE_RNDR_SRVR_STATE_UPDATED")); assert!(sent .iter() .any(|msg| msg.message_type == "MESSAGE_TYPE_RNDR_SRVR_VOLUME_CHANGED")); let state_update = sent .iter() .find(|msg| msg.message_type == "MESSAGE_TYPE_RNDR_SRVR_STATE_UPDATED") .expect("state update report"); assert!(state_update .payload .get("current_queue_item_id") .expect("current_queue_item_id field") .is_null()); assert!(state_update .payload .get("next_queue_item_id") .expect("next_queue_item_id field") .is_null()); } }