use prost::Message; use qconnect_core::QueueVersion; use serde_json::{json, Value}; use uuid::Uuid; use crate::{ queue_command_proto::{ AutoplayModeSetMessage, AutoplayTracksLoadedMessage, AutoplayTracksRemovedMessage, CtrlActiveRendererChangedMessage, CtrlAddRendererMessage, CtrlDeviceAudioQualityChangedMessage, CtrlFileAudioQualityChangedMessage, CtrlLoopModeSetMessage, CtrlMaxAudioQualityChangedMessage, CtrlRemoveRendererMessage, CtrlRendererStateUpdatedMessage, CtrlSessionStateMessage, CtrlUpdateRendererMessage, CtrlVolumeChangedMessage, CtrlVolumeMutedMessage, QConnectMessage, QConnectMessageType, QConnectMessages, QueueClearedMessage, QueueErrorMessage, QueueStateMessage, QueueTrack, QueueTrackWithContext, QueueTracksAddedFromAutoplayMessage, QueueTracksAddedMessage, QueueTracksInsertedMessage, QueueTracksLoadedMessage, QueueTracksRemovedMessage, QueueTracksReorderedMessage, QueueVersionRef, RendererMuteVolumeMessage, RendererSetActiveMessage, RendererSetLoopModeMessage, RendererSetMaxAudioQualityMessage, RendererSetShuffleModeMessage, RendererSetStateMessage, RendererSetVolumeMessage, ShuffleModeSetMessage, }, ProtocolError, QueueEventType, QueueServerEvent, RendererCommandType, RendererServerCommand, }; pub fn decode_queue_server_events(payload: &[u8]) -> Result, ProtocolError> { let batch = QConnectMessages::decode(payload)?; let mut events = Vec::new(); for message in batch.messages { if let Some(event) = decode_queue_server_event(message)? { events.push(event); } } Ok(events) } /// Decode the first renderer `PlaybackErrorMessage` from a batch, if any. /// /// `playback_error` rides at tag 3 of each `QConnectMessage` inside the batch /// `messages[]` (the official `Message` envelope record: message_type #1, /// error #2, playback_error #3, oneof payloads 21-105). This is resolved from /// the actual transport bytes: the decoder receives the batch `QConnectMessages`, /// so the field lives on the per-message record, not on the batch wrapper. pub fn decode_playback_error(payload: &[u8]) -> Option { let batch = QConnectMessages::decode(payload).ok()?; let msg = batch .messages .into_iter() .find_map(|message| message.playback_error)?; Some(crate::event::PlaybackErrorEvent { queue_item_id: i32_to_u64(msg.queue_item_id.unwrap_or(0)).ok()?, error_type: crate::event::ErrorType::from_wire(msg.error_type.unwrap_or(0)), queue_version: queue_version_opt(msg.queue_version).ok().flatten(), }) } fn decode_queue_server_event( message: QConnectMessage, ) -> Result, ProtocolError> { let message_type = resolve_queue_message_type(&message); let Some(message_type) = message_type else { return Ok(None); }; let event = match message_type { code if code == QConnectMessageType::MessageTypeSrvrCtrlQueueErrorMessage as i32 => { let Some(payload) = message.srvr_ctrl_queue_error_message else { return Ok(None); }; map_queue_error(payload)? } code if code == QConnectMessageType::MessageTypeSrvrCtrlQueueCleared as i32 => { let Some(payload) = message.srvr_ctrl_queue_cleared else { return Ok(None); }; map_queue_cleared(payload)? } code if code == QConnectMessageType::MessageTypeSrvrCtrlQueueState as i32 => { let Some(payload) = message.srvr_ctrl_queue_state else { return Ok(None); }; map_queue_state(payload)? } code if code == QConnectMessageType::MessageTypeSrvrCtrlQueueTracksLoaded as i32 => { let Some(payload) = message.srvr_ctrl_queue_tracks_loaded else { return Ok(None); }; map_tracks_loaded(payload)? } code if code == QConnectMessageType::MessageTypeSrvrCtrlQueueTracksInserted as i32 => { let Some(payload) = message.srvr_ctrl_queue_tracks_inserted else { return Ok(None); }; map_tracks_inserted(payload)? } code if code == QConnectMessageType::MessageTypeSrvrCtrlQueueTracksAdded as i32 => { let Some(payload) = message.srvr_ctrl_queue_tracks_added else { return Ok(None); }; map_tracks_added(payload)? } code if code == QConnectMessageType::MessageTypeSrvrCtrlQueueTracksRemoved as i32 => { let Some(payload) = message.srvr_ctrl_queue_tracks_removed else { return Ok(None); }; map_tracks_removed(payload)? } code if code == QConnectMessageType::MessageTypeSrvrCtrlQueueTracksReordered as i32 => { let Some(payload) = message.srvr_ctrl_queue_tracks_reordered else { return Ok(None); }; map_tracks_reordered(payload)? } code if code == QConnectMessageType::MessageTypeSrvrCtrlShuffleModeSet as i32 => { let Some(payload) = message.srvr_ctrl_shuffle_mode_set else { return Ok(None); }; map_shuffle_mode_set(payload)? } code if code == QConnectMessageType::MessageTypeSrvrCtrlAutoplayModeSet as i32 => { let Some(payload) = message.srvr_ctrl_autoplay_mode_set else { return Ok(None); }; map_autoplay_mode_set(payload)? } code if code == QConnectMessageType::MessageTypeSrvrCtrlAutoplayTracksLoaded as i32 => { let Some(payload) = message.srvr_ctrl_autoplay_tracks_loaded else { return Ok(None); }; map_autoplay_tracks_loaded(payload)? } code if code == QConnectMessageType::MessageTypeSrvrCtrlAutoplayTracksRemoved as i32 => { let Some(payload) = message.srvr_ctrl_autoplay_tracks_removed else { return Ok(None); }; map_autoplay_tracks_removed(payload)? } code if code == QConnectMessageType::MessageTypeSrvrCtrlQueueTracksAddedFromAutoplay as i32 => { let Some(payload) = message.srvr_ctrl_queue_tracks_added_from_autoplay else { return Ok(None); }; map_tracks_added_from_autoplay(payload)? } // Session management events (81-87, 97-101) code if code == QConnectMessageType::MessageTypeSrvrCtrlSessionState as i32 => { let Some(payload) = message.srvr_ctrl_session_state else { return Ok(None); }; map_session_state(payload)? } code if code == QConnectMessageType::MessageTypeSrvrCtrlRendererStateUpdated as i32 => { let Some(payload) = message.srvr_ctrl_renderer_state_updated else { return Ok(None); }; map_ctrl_renderer_state_updated(payload)? } code if code == QConnectMessageType::MessageTypeSrvrCtrlAddRenderer as i32 => { let Some(payload) = message.srvr_ctrl_add_renderer else { return Ok(None); }; map_add_renderer(payload)? } code if code == QConnectMessageType::MessageTypeSrvrCtrlUpdateRenderer as i32 => { let Some(payload) = message.srvr_ctrl_update_renderer else { return Ok(None); }; map_update_renderer(payload)? } code if code == QConnectMessageType::MessageTypeSrvrCtrlRemoveRenderer as i32 => { let Some(payload) = message.srvr_ctrl_remove_renderer else { return Ok(None); }; map_remove_renderer(payload)? } code if code == QConnectMessageType::MessageTypeSrvrCtrlActiveRendererChanged as i32 => { let Some(payload) = message.srvr_ctrl_active_renderer_changed else { return Ok(None); }; map_active_renderer_changed(payload)? } code if code == QConnectMessageType::MessageTypeSrvrCtrlVolumeChanged as i32 => { let Some(payload) = message.srvr_ctrl_volume_changed else { return Ok(None); }; map_ctrl_volume_changed(payload)? } code if code == QConnectMessageType::MessageTypeSrvrCtrlLoopModeSet as i32 => { let Some(payload) = message.srvr_ctrl_loop_mode_set else { return Ok(None); }; map_ctrl_loop_mode_set(payload)? } code if code == QConnectMessageType::MessageTypeSrvrCtrlVolumeMuted as i32 => { let Some(payload) = message.srvr_ctrl_volume_muted else { return Ok(None); }; map_ctrl_volume_muted(payload)? } code if code == QConnectMessageType::MessageTypeSrvrCtrlMaxAudioQualityChanged as i32 => { let Some(payload) = message.srvr_ctrl_max_audio_quality_changed else { return Ok(None); }; map_ctrl_max_audio_quality_changed(payload)? } code if code == QConnectMessageType::MessageTypeSrvrCtrlFileAudioQualityChanged as i32 => { let Some(payload) = message.srvr_ctrl_file_audio_quality_changed else { return Ok(None); }; map_ctrl_file_audio_quality_changed(payload)? } code if code == QConnectMessageType::MessageTypeSrvrCtrlDeviceAudioQualityChanged as i32 => { let Some(payload) = message.srvr_ctrl_device_audio_quality_changed else { return Ok(None); }; map_ctrl_device_audio_quality_changed(payload)? } _ => return Ok(None), }; Ok(Some(event)) } fn resolve_queue_message_type(message: &QConnectMessage) -> Option { message.message_type.or_else(|| { if message.srvr_ctrl_queue_error_message.is_some() { return Some(QConnectMessageType::MessageTypeSrvrCtrlQueueErrorMessage as i32); } if message.srvr_ctrl_queue_cleared.is_some() { return Some(QConnectMessageType::MessageTypeSrvrCtrlQueueCleared as i32); } if message.srvr_ctrl_queue_state.is_some() { return Some(QConnectMessageType::MessageTypeSrvrCtrlQueueState as i32); } if message.srvr_ctrl_queue_tracks_loaded.is_some() { return Some(QConnectMessageType::MessageTypeSrvrCtrlQueueTracksLoaded as i32); } if message.srvr_ctrl_queue_tracks_inserted.is_some() { return Some(QConnectMessageType::MessageTypeSrvrCtrlQueueTracksInserted as i32); } if message.srvr_ctrl_queue_tracks_added.is_some() { return Some(QConnectMessageType::MessageTypeSrvrCtrlQueueTracksAdded as i32); } if message.srvr_ctrl_queue_tracks_removed.is_some() { return Some(QConnectMessageType::MessageTypeSrvrCtrlQueueTracksRemoved as i32); } if message.srvr_ctrl_queue_tracks_reordered.is_some() { return Some(QConnectMessageType::MessageTypeSrvrCtrlQueueTracksReordered as i32); } if message.srvr_ctrl_shuffle_mode_set.is_some() { return Some(QConnectMessageType::MessageTypeSrvrCtrlShuffleModeSet as i32); } if message.srvr_ctrl_autoplay_mode_set.is_some() { return Some(QConnectMessageType::MessageTypeSrvrCtrlAutoplayModeSet as i32); } if message.srvr_ctrl_autoplay_tracks_loaded.is_some() { return Some(QConnectMessageType::MessageTypeSrvrCtrlAutoplayTracksLoaded as i32); } if message.srvr_ctrl_autoplay_tracks_removed.is_some() { return Some(QConnectMessageType::MessageTypeSrvrCtrlAutoplayTracksRemoved as i32); } if message.srvr_ctrl_queue_tracks_added_from_autoplay.is_some() { return Some( QConnectMessageType::MessageTypeSrvrCtrlQueueTracksAddedFromAutoplay as i32, ); } // Session management if message.srvr_ctrl_session_state.is_some() { return Some(QConnectMessageType::MessageTypeSrvrCtrlSessionState as i32); } if message.srvr_ctrl_renderer_state_updated.is_some() { return Some(QConnectMessageType::MessageTypeSrvrCtrlRendererStateUpdated as i32); } if message.srvr_ctrl_add_renderer.is_some() { return Some(QConnectMessageType::MessageTypeSrvrCtrlAddRenderer as i32); } if message.srvr_ctrl_update_renderer.is_some() { return Some(QConnectMessageType::MessageTypeSrvrCtrlUpdateRenderer as i32); } if message.srvr_ctrl_remove_renderer.is_some() { return Some(QConnectMessageType::MessageTypeSrvrCtrlRemoveRenderer as i32); } if message.srvr_ctrl_active_renderer_changed.is_some() { return Some(QConnectMessageType::MessageTypeSrvrCtrlActiveRendererChanged as i32); } if message.srvr_ctrl_volume_changed.is_some() { return Some(QConnectMessageType::MessageTypeSrvrCtrlVolumeChanged as i32); } if message.srvr_ctrl_loop_mode_set.is_some() { return Some(QConnectMessageType::MessageTypeSrvrCtrlLoopModeSet as i32); } if message.srvr_ctrl_volume_muted.is_some() { return Some(QConnectMessageType::MessageTypeSrvrCtrlVolumeMuted as i32); } if message.srvr_ctrl_max_audio_quality_changed.is_some() { return Some(QConnectMessageType::MessageTypeSrvrCtrlMaxAudioQualityChanged as i32); } if message.srvr_ctrl_file_audio_quality_changed.is_some() { return Some(QConnectMessageType::MessageTypeSrvrCtrlFileAudioQualityChanged as i32); } if message.srvr_ctrl_device_audio_quality_changed.is_some() { return Some(QConnectMessageType::MessageTypeSrvrCtrlDeviceAudioQualityChanged as i32); } None }) } pub fn decode_renderer_server_commands( payload: &[u8], ) -> Result, ProtocolError> { let batch = QConnectMessages::decode(payload)?; let mut commands = Vec::new(); for message in batch.messages { if let Some(command) = decode_renderer_server_command(message)? { commands.push(command); } } Ok(commands) } fn decode_renderer_server_command( message: QConnectMessage, ) -> Result, ProtocolError> { let message_type = resolve_renderer_message_type(&message); let Some(message_type) = message_type else { return Ok(None); }; let command = match message_type { code if code == QConnectMessageType::MessageTypeSrvrRndrSetState as i32 => { let Some(payload) = message.srvr_rndr_set_state else { return Ok(None); }; map_srvr_rndr_set_state(payload)? } code if code == QConnectMessageType::MessageTypeSrvrRndrSetVolume as i32 => { let Some(payload) = message.srvr_rndr_set_volume else { return Ok(None); }; map_srvr_rndr_set_volume(payload)? } code if code == QConnectMessageType::MessageTypeSrvrRndrSetActive as i32 => { let Some(payload) = message.srvr_rndr_set_active else { return Ok(None); }; map_srvr_rndr_set_active(payload)? } code if code == QConnectMessageType::MessageTypeSrvrRndrSetMaxAudioQuality as i32 => { let Some(payload) = message.srvr_rndr_set_max_audio_quality else { return Ok(None); }; map_srvr_rndr_set_max_audio_quality(payload)? } code if code == QConnectMessageType::MessageTypeSrvrRndrSetLoopMode as i32 => { let Some(payload) = message.srvr_rndr_set_loop_mode else { return Ok(None); }; map_srvr_rndr_set_loop_mode(payload)? } code if code == QConnectMessageType::MessageTypeSrvrRndrSetShuffleMode as i32 => { let Some(payload) = message.srvr_rndr_set_shuffle_mode else { return Ok(None); }; map_srvr_rndr_set_shuffle_mode(payload)? } code if code == QConnectMessageType::MessageTypeSrvrRndrMuteVolume as i32 => { let Some(payload) = message.srvr_rndr_mute_volume else { return Ok(None); }; map_srvr_rndr_mute_volume(payload)? } _ => return Ok(None), }; Ok(Some(command)) } fn resolve_renderer_message_type(message: &QConnectMessage) -> Option { message.message_type.or_else(|| { if message.srvr_rndr_set_state.is_some() { return Some(QConnectMessageType::MessageTypeSrvrRndrSetState as i32); } if message.srvr_rndr_set_volume.is_some() { return Some(QConnectMessageType::MessageTypeSrvrRndrSetVolume as i32); } if message.srvr_rndr_set_active.is_some() { return Some(QConnectMessageType::MessageTypeSrvrRndrSetActive as i32); } if message.srvr_rndr_set_max_audio_quality.is_some() { return Some(QConnectMessageType::MessageTypeSrvrRndrSetMaxAudioQuality as i32); } if message.srvr_rndr_set_loop_mode.is_some() { return Some(QConnectMessageType::MessageTypeSrvrRndrSetLoopMode as i32); } if message.srvr_rndr_set_shuffle_mode.is_some() { return Some(QConnectMessageType::MessageTypeSrvrRndrSetShuffleMode as i32); } if message.srvr_rndr_mute_volume.is_some() { return Some(QConnectMessageType::MessageTypeSrvrRndrMuteVolume as i32); } None }) } fn map_srvr_rndr_set_state( payload: RendererSetStateMessage, ) -> Result { let current_track = payload .current_track .map(queue_track_with_context_to_json) .transpose()?; let next_track = payload .next_track .map(queue_track_with_context_to_json) .transpose()?; let queue_version = queue_version_opt(payload.queue_version)?; Ok(RendererServerCommand { command_type: RendererCommandType::SrvrRndrSetState, payload: json!({ "playing_state": payload.playing_state, "current_position": optional_i32_to_u64(payload.current_position)?, "queue_version": queue_version, "current_track": current_track, "next_track": next_track }), }) } fn map_srvr_rndr_set_volume( payload: RendererSetVolumeMessage, ) -> Result { Ok(RendererServerCommand { command_type: RendererCommandType::SrvrRndrSetVolume, payload: json!({ "volume": payload.volume, "volume_delta": payload.volume_delta }), }) } fn map_srvr_rndr_set_active( payload: RendererSetActiveMessage, ) -> Result { Ok(RendererServerCommand { command_type: RendererCommandType::SrvrRndrSetActive, payload: json!({ "active": payload.active.unwrap_or(false) }), }) } fn map_srvr_rndr_set_max_audio_quality( payload: RendererSetMaxAudioQualityMessage, ) -> Result { Ok(RendererServerCommand { command_type: RendererCommandType::SrvrRndrSetMaxAudioQuality, payload: json!({ "max_audio_quality": payload.max_audio_quality }), }) } fn map_srvr_rndr_set_loop_mode( payload: RendererSetLoopModeMessage, ) -> Result { Ok(RendererServerCommand { command_type: RendererCommandType::SrvrRndrSetLoopMode, payload: json!({ "loop_mode": payload.loop_mode }), }) } fn map_srvr_rndr_set_shuffle_mode( payload: RendererSetShuffleModeMessage, ) -> Result { Ok(RendererServerCommand { command_type: RendererCommandType::SrvrRndrSetShuffleMode, payload: json!({ "shuffle_mode": payload.shuffle_mode.unwrap_or(false) }), }) } fn map_srvr_rndr_mute_volume( payload: RendererMuteVolumeMessage, ) -> Result { Ok(RendererServerCommand { command_type: RendererCommandType::SrvrRndrMuteVolume, payload: json!({ "value": payload.value.unwrap_or(false) }), }) } fn map_queue_error(payload: QueueErrorMessage) -> Result { let error_code = payload .error .as_ref() .and_then(|err| err.code.clone()) .unwrap_or_else(|| "remote_error".to_string()); let error_message = payload .error .as_ref() .and_then(|err| err.message.clone()) .unwrap_or_else(|| "queue_error_message".to_string()); log::warn!( "[QConnect/Decode] Queue error from server: code={error_code} message={error_message}" ); Ok(QueueServerEvent { event_type: QueueEventType::SrvrCtrlQueueErrorMessage, action_uuid: uuid_bytes_to_string_opt(payload.action_uuid, "queue_error.action_uuid")?, queue_version: queue_version_opt(payload.queue_version)?, payload: json!({ "error_code": error_code, "error_message": error_message }), }) } fn map_queue_cleared(payload: QueueClearedMessage) -> Result { Ok(QueueServerEvent { event_type: QueueEventType::SrvrCtrlQueueCleared, action_uuid: uuid_bytes_to_string_opt(payload.action_uuid, "queue_cleared.action_uuid")?, queue_version: queue_version_opt(payload.queue_version)?, payload: json!({}), }) } fn map_queue_state(payload: QueueStateMessage) -> Result { let tracks = payload .tracks .into_iter() .map(queue_track_with_context_to_json) .collect::, _>>()?; let autoplay_tracks = payload .autoplay_tracks .into_iter() .map(queue_track_with_context_to_json) .collect::, _>>()?; let shuffled_indexes = payload .shuffled_track_indexes .into_iter() .map(i32_to_u64) .collect::, _>>()?; Ok(QueueServerEvent { event_type: QueueEventType::SrvrCtrlQueueState, action_uuid: uuid_bytes_to_string_opt(payload.action_uuid, "queue_state.action_uuid")?, queue_version: queue_version_opt(payload.queue_version)?, payload: json!({ "tracks": tracks, "shuffle_mode": payload.shuffle_mode.unwrap_or(false), "shuffled_track_indexes": shuffled_indexes, "autoplay_mode": payload.autoplay_mode.unwrap_or(false), "autoplay_loading": payload.autoplay_loading.unwrap_or(false), "autoplay_tracks": autoplay_tracks, // Field #100: previously decoded-then-dropped. Surfaced for the // queue_hash divergence seam (algorithm is a BLOCKING unknown). "server_queue_hash": payload.queue_hash }), }) } fn map_tracks_loaded(payload: QueueTracksLoadedMessage) -> Result { let context_uuid = uuid_bytes_to_string_opt(payload.context_uuid, "tracks_loaded.context_uuid")?; let tracks = payload .tracks .into_iter() .map(|track| queue_track_to_json(track, context_uuid.as_deref())) .collect::, _>>()?; Ok(QueueServerEvent { event_type: QueueEventType::SrvrCtrlQueueTracksLoaded, action_uuid: uuid_bytes_to_string_opt(payload.action_uuid, "tracks_loaded.action_uuid")?, queue_version: queue_version_opt(payload.queue_version)?, payload: json!({ "tracks": tracks, "queue_position": optional_i32_to_u64(payload.queue_position)?, "shuffle_seed": payload.shuffle_seed.map(|v| v as u64), "shuffle_pivot_queue_item_id": optional_i32_to_u64(payload.shuffle_pivot_queue_item_id)?, "shuffle_mode": payload.shuffle_mode.unwrap_or(false), "autoplay_reset": payload.autoplay_reset.unwrap_or(false), "autoplay_loading": payload.autoplay_loading.unwrap_or(false) }), }) } fn map_tracks_inserted( payload: QueueTracksInsertedMessage, ) -> Result { let context_uuid = uuid_bytes_to_string_opt(payload.context_uuid, "tracks_inserted.context_uuid")?; let tracks = payload .tracks .into_iter() .map(|track| queue_track_to_json(track, context_uuid.as_deref())) .collect::, _>>()?; Ok(QueueServerEvent { event_type: QueueEventType::SrvrCtrlQueueTracksInserted, action_uuid: uuid_bytes_to_string_opt(payload.action_uuid, "tracks_inserted.action_uuid")?, queue_version: queue_version_opt(payload.queue_version)?, payload: json!({ "tracks": tracks, "insert_after": optional_i32_to_u64(payload.insert_after)?, "shuffle_seed": payload.shuffle_seed.map(|v| v as u64), "autoplay_reset": payload.autoplay_reset.unwrap_or(false), "autoplay_loading": payload.autoplay_loading.unwrap_or(false) }), }) } fn map_tracks_added(payload: QueueTracksAddedMessage) -> Result { let context_uuid = uuid_bytes_to_string_opt(payload.context_uuid, "tracks_added.context_uuid")?; let tracks = payload .tracks .into_iter() .map(|track| queue_track_to_json(track, context_uuid.as_deref())) .collect::, _>>()?; Ok(QueueServerEvent { event_type: QueueEventType::SrvrCtrlQueueTracksAdded, action_uuid: uuid_bytes_to_string_opt(payload.action_uuid, "tracks_added.action_uuid")?, queue_version: queue_version_opt(payload.queue_version)?, payload: json!({ "tracks": tracks, "shuffle_seed": payload.shuffle_seed.map(|v| v as u64), "autoplay_reset": payload.autoplay_reset.unwrap_or(false), "autoplay_loading": payload.autoplay_loading.unwrap_or(false) }), }) } fn map_tracks_removed( payload: QueueTracksRemovedMessage, ) -> Result { let queue_item_ids = payload .queue_item_ids .into_iter() .map(i32_to_u64) .collect::, _>>()?; Ok(QueueServerEvent { event_type: QueueEventType::SrvrCtrlQueueTracksRemoved, action_uuid: uuid_bytes_to_string_opt(payload.action_uuid, "tracks_removed.action_uuid")?, queue_version: queue_version_opt(payload.queue_version)?, payload: json!({ "queue_item_ids": queue_item_ids, "autoplay_reset": payload.autoplay_reset.unwrap_or(false), "autoplay_loading": payload.autoplay_loading.unwrap_or(false) }), }) } fn map_tracks_reordered( payload: QueueTracksReorderedMessage, ) -> Result { let queue_item_ids = payload .queue_item_ids .into_iter() .map(i32_to_u64) .collect::, _>>()?; Ok(QueueServerEvent { event_type: QueueEventType::SrvrCtrlQueueTracksReordered, action_uuid: uuid_bytes_to_string_opt(payload.action_uuid, "tracks_reordered.action_uuid")?, queue_version: queue_version_opt(payload.queue_version)?, payload: json!({ "queue_item_ids": queue_item_ids, "insert_after": optional_i32_to_u64(payload.insert_after)?, "autoplay_reset": payload.autoplay_reset.unwrap_or(false), "autoplay_loading": payload.autoplay_loading.unwrap_or(false) }), }) } fn map_shuffle_mode_set(payload: ShuffleModeSetMessage) -> Result { Ok(QueueServerEvent { event_type: QueueEventType::SrvrCtrlShuffleModeSet, action_uuid: uuid_bytes_to_string_opt(payload.action_uuid, "shuffle_mode_set.action_uuid")?, queue_version: queue_version_opt(payload.queue_version)?, payload: json!({ "shuffle_mode": payload.shuffle_mode.unwrap_or(false), "shuffle_seed": payload.shuffle_seed.map(|v| v as u64), "shuffle_pivot_queue_item_id": optional_i32_to_u64(payload.shuffle_pivot_queue_item_id)?, "autoplay_reset": payload.autoplay_reset.unwrap_or(false), "autoplay_loading": payload.autoplay_loading.unwrap_or(false) }), }) } fn map_autoplay_mode_set( payload: AutoplayModeSetMessage, ) -> Result { Ok(QueueServerEvent { event_type: QueueEventType::SrvrCtrlAutoplayModeSet, action_uuid: uuid_bytes_to_string_opt( payload.action_uuid, "autoplay_mode_set.action_uuid", )?, queue_version: queue_version_opt(payload.queue_version)?, payload: json!({ "autoplay_mode": payload.autoplay_mode.unwrap_or(false), "autoplay_reset": payload.autoplay_reset.unwrap_or(false), "autoplay_loading": payload.autoplay_loading.unwrap_or(false) }), }) } fn map_autoplay_tracks_loaded( payload: AutoplayTracksLoadedMessage, ) -> Result { let context_uuid = uuid_bytes_to_string_opt(payload.context_uuid, "autoplay_tracks_loaded.context_uuid")?; let tracks = payload .tracks .into_iter() .map(|track| queue_track_to_json(track, context_uuid.as_deref())) .collect::, _>>()?; Ok(QueueServerEvent { event_type: QueueEventType::SrvrCtrlAutoplayTracksLoaded, action_uuid: uuid_bytes_to_string_opt( payload.action_uuid, "autoplay_tracks_loaded.action_uuid", )?, queue_version: queue_version_opt(payload.queue_version)?, payload: json!({ "tracks": tracks }), }) } fn map_autoplay_tracks_removed( payload: AutoplayTracksRemovedMessage, ) -> Result { let queue_item_ids = payload .queue_item_ids .into_iter() .map(i32_to_u64) .collect::, _>>()?; Ok(QueueServerEvent { event_type: QueueEventType::SrvrCtrlAutoplayTracksRemoved, action_uuid: uuid_bytes_to_string_opt( payload.action_uuid, "autoplay_tracks_removed.action_uuid", )?, queue_version: queue_version_opt(payload.queue_version)?, payload: json!({ "queue_item_ids": queue_item_ids }), }) } fn map_tracks_added_from_autoplay( payload: QueueTracksAddedFromAutoplayMessage, ) -> Result { let queue_item_ids = payload .queue_item_ids .into_iter() .map(i32_to_u64) .collect::, _>>()?; Ok(QueueServerEvent { event_type: QueueEventType::SrvrCtrlQueueTracksAddedFromAutoplay, action_uuid: None, queue_version: queue_version_opt(payload.queue_version)?, payload: json!({ "queue_item_ids": queue_item_ids }), }) } // --- Session management event mappers --- fn map_session_state(payload: CtrlSessionStateMessage) -> Result { let session_uuid = uuid_bytes_to_string_opt(payload.session_uuid, "session_state.session_uuid")?; Ok(QueueServerEvent { event_type: QueueEventType::SrvrCtrlSessionState, action_uuid: None, queue_version: queue_version_opt(payload.queue_version)?, payload: json!({ "session_uuid": session_uuid, "active_renderer_id": payload.active_renderer_id, "playing_state": payload.playing_state, "loop_mode": payload.loop_mode }), }) } fn map_ctrl_renderer_state_updated( payload: CtrlRendererStateUpdatedMessage, ) -> Result { let player_state = payload.player_state.map(|ps| { json!({ "playing_state": ps.playing_state, "buffer_state": ps.buffer_state, "current_position": ps.current_position.as_ref().and_then(|pos| pos.value), "duration": ps.duration, "current_queue_item_id": ps.current_queue_item_id }) }); Ok(QueueServerEvent { event_type: QueueEventType::SrvrCtrlRendererStateUpdated, action_uuid: None, queue_version: None, payload: json!({ "renderer_id": payload.renderer_id, "status": payload.status, "player_state": player_state }), }) } fn map_add_renderer(payload: CtrlAddRendererMessage) -> Result { let device_info = payload.device_info.map(|di| { json!({ "friendly_name": di.friendly_name, "brand": di.brand, "model": di.model, "device_type": di.device_type }) }); Ok(QueueServerEvent { event_type: QueueEventType::SrvrCtrlAddRenderer, action_uuid: None, queue_version: None, payload: json!({ "renderer_id": payload.renderer_id, "device_info": device_info }), }) } fn map_update_renderer( payload: CtrlUpdateRendererMessage, ) -> Result { let device_info = payload.device_info.map(|di| { json!({ "friendly_name": di.friendly_name, "brand": di.brand, "model": di.model, "device_type": di.device_type }) }); Ok(QueueServerEvent { event_type: QueueEventType::SrvrCtrlUpdateRenderer, action_uuid: None, queue_version: None, payload: json!({ "renderer_id": payload.renderer_id, "device_info": device_info }), }) } fn map_remove_renderer( payload: CtrlRemoveRendererMessage, ) -> Result { Ok(QueueServerEvent { event_type: QueueEventType::SrvrCtrlRemoveRenderer, action_uuid: None, queue_version: None, payload: json!({ "renderer_id": payload.renderer_id }), }) } fn map_active_renderer_changed( payload: CtrlActiveRendererChangedMessage, ) -> Result { Ok(QueueServerEvent { event_type: QueueEventType::SrvrCtrlActiveRendererChanged, action_uuid: None, queue_version: None, payload: json!({ "active_renderer_id": payload.active_renderer_id }), }) } fn map_ctrl_volume_changed( payload: CtrlVolumeChangedMessage, ) -> Result { Ok(QueueServerEvent { event_type: QueueEventType::SrvrCtrlVolumeChanged, action_uuid: None, queue_version: None, payload: json!({ "renderer_id": payload.renderer_id, "volume": payload.volume }), }) } fn map_ctrl_loop_mode_set( payload: CtrlLoopModeSetMessage, ) -> Result { Ok(QueueServerEvent { event_type: QueueEventType::SrvrCtrlLoopModeSet, action_uuid: None, queue_version: None, payload: json!({ "loop_mode": payload.loop_mode }), }) } fn map_ctrl_volume_muted( payload: CtrlVolumeMutedMessage, ) -> Result { Ok(QueueServerEvent { event_type: QueueEventType::SrvrCtrlVolumeMuted, action_uuid: None, queue_version: None, payload: json!({ "renderer_id": payload.renderer_id, "value": payload.value }), }) } fn map_ctrl_max_audio_quality_changed( payload: CtrlMaxAudioQualityChangedMessage, ) -> Result { Ok(QueueServerEvent { event_type: QueueEventType::SrvrCtrlMaxAudioQualityChanged, action_uuid: None, queue_version: None, payload: json!({ "renderer_id": payload.renderer_id, "max_audio_quality": payload.max_audio_quality, "network_type": payload.network_type }), }) } fn map_ctrl_file_audio_quality_changed( payload: CtrlFileAudioQualityChangedMessage, ) -> Result { Ok(QueueServerEvent { event_type: QueueEventType::SrvrCtrlFileAudioQualityChanged, action_uuid: None, queue_version: None, payload: json!({ "renderer_id": payload.renderer_id, "sampling_rate": payload.sampling_rate, "bit_depth": payload.bit_depth, "nb_channels": payload.nb_channels, "audio_quality": payload.audio_quality }), }) } fn map_ctrl_device_audio_quality_changed( payload: CtrlDeviceAudioQualityChangedMessage, ) -> Result { Ok(QueueServerEvent { event_type: QueueEventType::SrvrCtrlDeviceAudioQualityChanged, action_uuid: None, queue_version: None, payload: json!({ "renderer_id": payload.renderer_id, "sampling_rate": payload.sampling_rate, "bit_depth": payload.bit_depth, "nb_channels": payload.nb_channels }), }) } fn queue_track_to_json( track: QueueTrack, context_uuid: Option<&str>, ) -> Result { let track_id = track.track_id.map(|v| v as u64).ok_or_else(|| { ProtocolError::InvalidPayload("missing required field 'queue_track.track_id'".to_string()) })?; let queue_item_id = optional_i32_to_u64_named(track.queue_item_id, "queue_track.queue_item_id")?.unwrap_or(0); Ok(json!({ "track_context_uuid": context_uuid.unwrap_or_default(), "track_id": track_id, "queue_item_id": queue_item_id })) } fn queue_track_with_context_to_json(track: QueueTrackWithContext) -> Result { let track_id = track.track_id.map(|v| v as u64).ok_or_else(|| { ProtocolError::InvalidPayload( "missing required field 'queue_track_with_context.track_id'".to_string(), ) })?; let queue_item_id = optional_i32_to_u64_named( track.queue_item_id, "queue_track_with_context.queue_item_id", )? .unwrap_or(0); let context_uuid = uuid_bytes_to_string_opt(track.context_uuid, "queue_track_with_context.context_uuid")? .unwrap_or_default(); Ok(json!({ "track_context_uuid": context_uuid, "track_id": track_id, "queue_item_id": queue_item_id })) } fn queue_version_opt( value: Option, ) -> Result, ProtocolError> { let Some(version) = value else { return Ok(None); }; // Qobuz may send QueueVersionRef with missing major/minor — default to 0 let major = version.major.map(|v| i32_to_u64(v)).transpose()?.unwrap_or(0); let minor = version.minor.map(|v| i32_to_u64(v)).transpose()?.unwrap_or(0); Ok(Some(QueueVersion::new(major, minor))) } fn optional_i32_to_u64_named( value: Option, field_name: &str, ) -> Result, ProtocolError> { value .map(|raw| { if raw < 0 { return Err(ProtocolError::InvalidPayload(format!( "negative value where unsigned expected in '{field_name}': {raw}" ))); } Ok(raw as u64) }) .transpose() } fn optional_i32_to_u64(value: Option) -> Result, ProtocolError> { value.map(i32_to_u64).transpose() } fn i32_to_u64(value: i32) -> Result { if value < 0 { return Err(ProtocolError::InvalidPayload(format!( "negative value where unsigned expected: {value}" ))); } Ok(value as u64) } fn uuid_bytes_to_string_opt( value: Option>, field_name: &str, ) -> Result, ProtocolError> { let Some(bytes) = value else { return Ok(None); }; let uuid = Uuid::from_slice(&bytes).map_err(|err| { ProtocolError::InvalidUuid(format!("{field_name} invalid UUID bytes: {err}")) })?; Ok(Some(uuid.to_string())) } #[cfg(test)] mod tests { use prost::Message; use crate::queue_command_proto::{ PlaybackErrorMessage, QConnectMessage, QConnectMessageType, QConnectMessages, QueueTrack, QueueTrackWithContext, QueueTracksAddedMessage, QueueTracksLoadedMessage, QueueVersionRef, RendererMuteVolumeMessage, RendererSetStateMessage, }; use crate::ErrorType; use super::{ decode_playback_error, decode_queue_server_events, decode_renderer_server_commands, }; #[test] fn decodes_playback_error_track_not_streamable() { // playback_error rides at tag 3 of a QConnectMessage inside the batch // messages[], not on the QConnectMessages wrapper (verified from the // transport bytes: decoder receives the batch). let message = QConnectMessage { // message_type = PLAYBACK_ERROR(2) per Common.MessageType. message_type: Some(2), playback_error: Some(PlaybackErrorMessage { queue_version: Some(QueueVersionRef { major: Some(2), minor: Some(0), }), queue_item_id: Some(55), error_type: Some(2), // TRACK_NOT_STREAMABLE }), ..Default::default() }; let batch = QConnectMessages { messages_time: None, messages_id: None, messages: vec![message], }; let bytes = batch.encode_to_vec(); let parsed = decode_playback_error(&bytes).expect("playback error decoded"); assert_eq!(parsed.queue_item_id, 55); assert_eq!(parsed.error_type, ErrorType::TrackNotStreamable); } #[test] fn decodes_tracks_added_server_event_batch() { let message = QConnectMessage { message_type: Some(QConnectMessageType::MessageTypeSrvrCtrlQueueTracksAdded as i32), srvr_ctrl_queue_tracks_added: Some(QueueTracksAddedMessage { queue_version: Some(QueueVersionRef { major: Some(3), minor: Some(4), }), action_uuid: Some( uuid::Uuid::parse_str("85fa0dd6-7bd6-4b3c-8f43-b8ee22e65d5e") .expect("uuid") .as_bytes() .to_vec(), ), tracks: vec![QueueTrack { queue_item_id: Some(44), track_id: Some(555), }], shuffle_seed: Some(99), context_uuid: Some( uuid::Uuid::parse_str("0f892e1a-a2f4-4d18-82c6-31e8daf2ea0f") .expect("context uuid") .as_bytes() .to_vec(), ), autoplay_reset: Some(false), autoplay_loading: Some(false), queue_hash: None, }), ..Default::default() }; let batch = QConnectMessages { messages_time: Some(1), messages_id: Some(1), messages: vec![message], }; let encoded = batch.encode_to_vec(); let events = decode_queue_server_events(&encoded).expect("decode events"); assert_eq!(events.len(), 1); assert_eq!( events[0].message_type(), "MESSAGE_TYPE_SRVR_CTRL_QUEUE_TRACKS_ADDED" ); } #[test] fn decodes_srvr_rndr_set_state_command_batch() { let message = QConnectMessage { message_type: Some(QConnectMessageType::MessageTypeSrvrRndrSetState as i32), srvr_rndr_set_state: Some(RendererSetStateMessage { playing_state: Some(2), current_position: Some(42_000), queue_version: Some(QueueVersionRef { major: Some(7), minor: Some(8), }), current_track: Some(QueueTrackWithContext { queue_item_id: Some(1001), track_id: Some(555_666), context_uuid: Some( uuid::Uuid::parse_str("95f28997-6c88-47cc-a535-9f8e5b9c5fe1") .expect("context uuid") .as_bytes() .to_vec(), ), }), next_track: None, }), ..Default::default() }; let batch = QConnectMessages { messages_time: Some(1), messages_id: Some(2), messages: vec![message], }; let encoded = batch.encode_to_vec(); let commands = decode_renderer_server_commands(&encoded).expect("decode renderer commands"); assert_eq!(commands.len(), 1); assert_eq!( commands[0].message_type(), "MESSAGE_TYPE_SRVR_RNDR_SET_STATE" ); assert_eq!(commands[0].payload["playing_state"], 2); assert_eq!(commands[0].payload["current_position"], 42_000); } #[test] fn decodes_missing_queue_item_id_as_zero_in_queue_events() { let message = QConnectMessage { message_type: Some(QConnectMessageType::MessageTypeSrvrCtrlQueueTracksLoaded as i32), srvr_ctrl_queue_tracks_loaded: Some(QueueTracksLoadedMessage { queue_version: Some(QueueVersionRef { major: Some(7), minor: Some(1), }), action_uuid: Some( uuid::Uuid::parse_str("f2b1f0a4-3d0a-4a67-b234-4d1df4d58c8f") .expect("uuid") .as_bytes() .to_vec(), ), tracks: vec![QueueTrack { queue_item_id: None, track_id: Some(126_886_862), }], queue_position: Some(0), shuffle_mode: Some(false), shuffle_seed: None, shuffle_pivot_queue_item_id: None, context_uuid: Some( uuid::Uuid::parse_str("4c321d71-aef2-4c98-8cd3-8d2ad4bfe0f4") .expect("context uuid") .as_bytes() .to_vec(), ), autoplay_reset: Some(true), autoplay_loading: Some(false), queue_hash: None, }), ..Default::default() }; let batch = QConnectMessages { messages_time: Some(1), messages_id: Some(4), messages: vec![message], }; let encoded = batch.encode_to_vec(); let events = decode_queue_server_events(&encoded).expect("decode queue events"); assert_eq!(events.len(), 1); assert_eq!(events[0].payload["tracks"][0]["queue_item_id"], 0); assert_eq!(events[0].payload["tracks"][0]["track_id"], 126_886_862); } #[test] fn decodes_missing_queue_item_id_as_zero_in_renderer_state() { let message = QConnectMessage { message_type: Some(QConnectMessageType::MessageTypeSrvrRndrSetState as i32), srvr_rndr_set_state: Some(RendererSetStateMessage { playing_state: Some(2), current_position: Some(8_000), queue_version: Some(QueueVersionRef { major: Some(7), minor: Some(1), }), current_track: Some(QueueTrackWithContext { queue_item_id: None, track_id: Some(126_886_862), context_uuid: Some( uuid::Uuid::parse_str("4c321d71-aef2-4c98-8cd3-8d2ad4bfe0f4") .expect("context uuid") .as_bytes() .to_vec(), ), }), next_track: Some(QueueTrackWithContext { queue_item_id: Some(1), track_id: Some(25_584_418), context_uuid: Some( uuid::Uuid::parse_str("4c321d71-aef2-4c98-8cd3-8d2ad4bfe0f4") .expect("context uuid") .as_bytes() .to_vec(), ), }), }), ..Default::default() }; let batch = QConnectMessages { messages_time: Some(1), messages_id: Some(5), messages: vec![message], }; let encoded = batch.encode_to_vec(); let commands = decode_renderer_server_commands(&encoded).expect("decode renderer commands"); assert_eq!(commands.len(), 1); assert_eq!(commands[0].payload["current_track"]["queue_item_id"], 0); assert_eq!( commands[0].payload["current_track"]["track_id"], 126_886_862 ); assert_eq!(commands[0].payload["next_track"]["queue_item_id"], 1); } #[test] fn decodes_srvr_rndr_mute_volume_command_batch() { let message = QConnectMessage { message_type: Some(QConnectMessageType::MessageTypeSrvrRndrMuteVolume as i32), srvr_rndr_mute_volume: Some(RendererMuteVolumeMessage { value: Some(true) }), ..Default::default() }; let batch = QConnectMessages { messages_time: Some(1), messages_id: Some(3), messages: vec![message], }; let encoded = batch.encode_to_vec(); let commands = decode_renderer_server_commands(&encoded).expect("decode renderer commands"); assert_eq!(commands.len(), 1); assert_eq!( commands[0].message_type(), "MESSAGE_TYPE_SRVR_RNDR_MUTE_VOLUME" ); assert_eq!(commands[0].payload["value"], true); } #[test] fn decodes_official_renderer_state_updated_fixed64_timestamp_frame() { let raw_message = vec![ 0x08, 0x17, 0xba, 0x01, 0x21, 0x0a, 0x1f, 0x08, 0x02, 0x10, 0x02, 0x1a, 0x0d, 0x09, 0xe1, 0x08, 0x7e, 0xe5, 0x9c, 0x01, 0x00, 0x00, 0x10, 0xa1, 0xec, 0x01, 0x20, 0xa8, 0x9e, 0x14, 0x2a, 0x04, 0x08, 0x09, 0x10, 0x02, 0x38, 0x0c, ]; let message = QConnectMessage::decode(raw_message.as_slice()).expect("decode message"); let state = message .rndr_srvr_state_updated .as_ref() .and_then(|payload| payload.state.as_ref()) .expect("renderer state"); let position = state.current_position.as_ref().expect("playback position"); assert_eq!( message.message_type, Some(QConnectMessageType::MessageTypeRndrSrvrStateUpdated as i32) ); assert_eq!(position.timestamp, Some(1_773_376_768_225)); assert_eq!(position.value, Some(30_241)); assert_eq!(state.current_queue_item_id, None); assert_eq!(state.next_queue_item_id, Some(12)); } }