Files
qbz/crates/qconnect-protocol/src/decoder.rs
T
vicrodh d865097a4c feat(qconnect-protocol): decode PlaybackErrorMessage + ErrorType
Models the renderer per-track failure (TRACK_NOT_STREAMABLE/NETWORK_ERROR/...).
Envelope-vs-batch placement verified against transport bytes: the decoder
receives the batch QConnectMessages (CloudPayload.payload tag 7), and the
official Message record carries playback_error at tag 3, so the field is
attached to QConnectMessage inside messages[], NOT to the batch wrapper.

cc
2026-06-01 03:20:09 -06:00

1369 lines
51 KiB
Rust

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<Vec<QueueServerEvent>, 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<crate::event::PlaybackErrorEvent> {
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<Option<QueueServerEvent>, 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<i32> {
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<Vec<RendererServerCommand>, 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<Option<RendererServerCommand>, 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<i32> {
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<RendererServerCommand, ProtocolError> {
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<RendererServerCommand, ProtocolError> {
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<RendererServerCommand, ProtocolError> {
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<RendererServerCommand, ProtocolError> {
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<RendererServerCommand, ProtocolError> {
Ok(RendererServerCommand {
command_type: RendererCommandType::SrvrRndrSetLoopMode,
payload: json!({
"loop_mode": payload.loop_mode
}),
})
}
fn map_srvr_rndr_set_shuffle_mode(
payload: RendererSetShuffleModeMessage,
) -> Result<RendererServerCommand, ProtocolError> {
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<RendererServerCommand, ProtocolError> {
Ok(RendererServerCommand {
command_type: RendererCommandType::SrvrRndrMuteVolume,
payload: json!({
"value": payload.value.unwrap_or(false)
}),
})
}
fn map_queue_error(payload: QueueErrorMessage) -> Result<QueueServerEvent, ProtocolError> {
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<QueueServerEvent, ProtocolError> {
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<QueueServerEvent, ProtocolError> {
let tracks = payload
.tracks
.into_iter()
.map(queue_track_with_context_to_json)
.collect::<Result<Vec<_>, _>>()?;
let autoplay_tracks = payload
.autoplay_tracks
.into_iter()
.map(queue_track_with_context_to_json)
.collect::<Result<Vec<_>, _>>()?;
let shuffled_indexes = payload
.shuffled_track_indexes
.into_iter()
.map(i32_to_u64)
.collect::<Result<Vec<_>, _>>()?;
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<QueueServerEvent, ProtocolError> {
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::<Result<Vec<_>, _>>()?;
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<QueueServerEvent, ProtocolError> {
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::<Result<Vec<_>, _>>()?;
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<QueueServerEvent, ProtocolError> {
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::<Result<Vec<_>, _>>()?;
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<QueueServerEvent, ProtocolError> {
let queue_item_ids = payload
.queue_item_ids
.into_iter()
.map(i32_to_u64)
.collect::<Result<Vec<_>, _>>()?;
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<QueueServerEvent, ProtocolError> {
let queue_item_ids = payload
.queue_item_ids
.into_iter()
.map(i32_to_u64)
.collect::<Result<Vec<_>, _>>()?;
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<QueueServerEvent, ProtocolError> {
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<QueueServerEvent, ProtocolError> {
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<QueueServerEvent, ProtocolError> {
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::<Result<Vec<_>, _>>()?;
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<QueueServerEvent, ProtocolError> {
let queue_item_ids = payload
.queue_item_ids
.into_iter()
.map(i32_to_u64)
.collect::<Result<Vec<_>, _>>()?;
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<QueueServerEvent, ProtocolError> {
let queue_item_ids = payload
.queue_item_ids
.into_iter()
.map(i32_to_u64)
.collect::<Result<Vec<_>, _>>()?;
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<QueueServerEvent, ProtocolError> {
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<QueueServerEvent, ProtocolError> {
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<QueueServerEvent, ProtocolError> {
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<QueueServerEvent, ProtocolError> {
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<QueueServerEvent, ProtocolError> {
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<QueueServerEvent, ProtocolError> {
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<QueueServerEvent, ProtocolError> {
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<QueueServerEvent, ProtocolError> {
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<QueueServerEvent, ProtocolError> {
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<QueueServerEvent, ProtocolError> {
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<QueueServerEvent, ProtocolError> {
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<QueueServerEvent, ProtocolError> {
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<Value, ProtocolError> {
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<Value, ProtocolError> {
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<QueueVersionRef>,
) -> Result<Option<QueueVersion>, 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<i32>,
field_name: &str,
) -> Result<Option<u64>, 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<i32>) -> Result<Option<u64>, ProtocolError> {
value.map(i32_to_u64).transpose()
}
fn i32_to_u64(value: i32) -> Result<u64, ProtocolError> {
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<Vec<u8>>,
field_name: &str,
) -> Result<Option<String>, 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));
}
}