feat(qconnect-protocol): decode SRVR_RNDR command contracts from protobuf

-cx
This commit is contained in:
vicrodh committed 2026-02-21 12:35:16 -06:00
1 parent 5659bf794a
commit 0124728aa9
4 files changed
+468 -7

No files matched your search

+269 -7
View File
@@ -10,9 +10,12 @@ use crate::{
QueueErrorMessage, QueueStateMessage, QueueTrack, QueueTrackWithContext,
QueueTracksAddedFromAutoplayMessage, QueueTracksAddedMessage, QueueTracksInsertedMessage,
QueueTracksLoadedMessage, QueueTracksRemovedMessage, QueueTracksReorderedMessage,
QueueVersionRef, ShuffleModeSetMessage,
QueueVersionRef, RendererMuteVolumeMessage, RendererSetActiveMessage,
RendererSetLoopModeMessage, RendererSetMaxAudioQualityMessage,
RendererSetShuffleModeMessage, RendererSetStateMessage, RendererSetVolumeMessage,
ShuffleModeSetMessage,
},
ProtocolError, QueueEventType, QueueServerEvent,
ProtocolError, QueueEventType, QueueServerEvent, RendererCommandType, RendererServerCommand,
};
pub fn decode_queue_server_events(payload: &[u8]) -> Result<Vec<QueueServerEvent>, ProtocolError> {
@@ -31,7 +34,7 @@ pub fn decode_queue_server_events(payload: &[u8]) -> Result<Vec<QueueServerEvent
fn decode_queue_server_event(
message: QConnectMessage,
) -> Result<Option<QueueServerEvent>, ProtocolError> {
let message_type = resolve_message_type(&message);
let message_type = resolve_queue_message_type(&message);
let Some(message_type) = message_type else {
return Ok(None);
};
@@ -123,7 +126,7 @@ fn decode_queue_server_event(
Ok(Some(event))
}
fn resolve_message_type(message: &QConnectMessage) -> Option<i32> {
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);
@@ -170,6 +173,197 @@ fn resolve_message_type(message: &QConnectMessage) -> Option<i32> {
})
}
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
@@ -548,11 +742,12 @@ mod tests {
use prost::Message;
use crate::queue_command_proto::{
QConnectMessage, QConnectMessageType, QConnectMessages, QueueTrack,
QueueTracksAddedMessage, QueueVersionRef,
QConnectMessage, QConnectMessageType, QConnectMessages, QueueTrack, QueueTrackWithContext,
QueueTracksAddedMessage, QueueVersionRef, RendererMuteVolumeMessage,
RendererSetStateMessage,
};
use super::decode_queue_server_events;
use super::{decode_queue_server_events, decode_renderer_server_commands};
#[test]
fn decodes_tracks_added_server_event_batch() {
@@ -601,4 +796,71 @@ mod tests {
"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_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);
}
}
+3
View File
@@ -8,13 +8,16 @@ mod error;
mod event;
mod mapper;
mod queue_command_proto;
mod renderer;
mod wire;
pub use command::{QueueCommand, QueueCommandType};
pub use decoder::decode_queue_server_events;
pub use decoder::decode_renderer_server_commands;
pub use error::ProtocolError;
pub use event::{QueueEventType, QueueServerEvent};
pub use mapper::{build_qconnect_outbound_envelope, encode_queue_command_batch};
pub use renderer::{RendererCommandType, RendererServerCommand};
pub use wire::{
build_outbound_envelope, decode_inbound_json, encode_outbound_json,
encode_outbound_payload_bytes, parse_inbound_event, InboundEnvelope, OutboundEnvelope,
@@ -1,6 +1,22 @@
#[derive(Clone, Copy, PartialEq, Eq, Debug, ::prost::Enumeration)]
#[repr(i32)]
pub enum QConnectMessageType {
MessageTypeRndrSrvrJoinSession = 21,
MessageTypeRndrSrvrDeviceInfoUpdated = 22,
MessageTypeRndrSrvrStateUpdated = 23,
MessageTypeRndrSrvrRendererAction = 24,
MessageTypeRndrSrvrVolumeChanged = 25,
MessageTypeRndrSrvrFileAudioQualityChanged = 26,
MessageTypeRndrSrvrDeviceAudioQualityChanged = 27,
MessageTypeRndrSrvrMaxAudioQualityChanged = 28,
MessageTypeRndrSrvrVolumeMuted = 29,
MessageTypeSrvrRndrSetState = 41,
MessageTypeSrvrRndrSetVolume = 42,
MessageTypeSrvrRndrSetActive = 43,
MessageTypeSrvrRndrSetMaxAudioQuality = 44,
MessageTypeSrvrRndrSetLoopMode = 45,
MessageTypeSrvrRndrSetShuffleMode = 46,
MessageTypeSrvrRndrMuteVolume = 47,
MessageTypeCtrlSrvrClearQueue = 65,
MessageTypeCtrlSrvrQueueLoadTracks = 66,
MessageTypeCtrlSrvrQueueInsertTracks = 67,
@@ -460,6 +476,122 @@ pub struct QueueTracksAddedFromAutoplayMessage {
pub queue_hash: Option<Vec<u8>>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RendererSetStateMessage {
#[prost(int32, optional, tag = "1")]
pub playing_state: Option<i32>,
#[prost(int32, optional, tag = "2")]
pub current_position: Option<i32>,
#[prost(message, optional, tag = "3")]
pub queue_version: Option<QueueVersionRef>,
#[prost(message, optional, tag = "4")]
pub current_track: Option<QueueTrackWithContext>,
#[prost(message, optional, tag = "5")]
pub next_track: Option<QueueTrackWithContext>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RendererSetVolumeMessage {
#[prost(int32, optional, tag = "1")]
pub volume: Option<i32>,
#[prost(int32, optional, tag = "2")]
pub volume_delta: Option<i32>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RendererSetActiveMessage {
#[prost(bool, optional, tag = "1")]
pub active: Option<bool>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RendererSetMaxAudioQualityMessage {
#[prost(int32, optional, tag = "1")]
pub max_audio_quality: Option<i32>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RendererSetLoopModeMessage {
#[prost(int32, optional, tag = "1")]
pub loop_mode: Option<i32>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RendererSetShuffleModeMessage {
#[prost(bool, optional, tag = "1")]
pub shuffle_mode: Option<bool>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RendererMuteVolumeMessage {
#[prost(bool, optional, tag = "1")]
pub value: Option<bool>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PlaybackPositionMessage {
#[prost(uint64, optional, tag = "1")]
pub timestamp: Option<u64>,
#[prost(int32, optional, tag = "2")]
pub value: Option<i32>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RendererStateMessage {
#[prost(int32, optional, tag = "1")]
pub playing_state: Option<i32>,
#[prost(int32, optional, tag = "2")]
pub buffer_state: Option<i32>,
#[prost(message, optional, tag = "3")]
pub current_position: Option<PlaybackPositionMessage>,
#[prost(int32, optional, tag = "4")]
pub duration: Option<i32>,
#[prost(message, optional, tag = "5")]
pub queue_version: Option<QueueVersionRef>,
#[prost(int32, optional, tag = "6")]
pub current_queue_item_id: Option<i32>,
#[prost(int32, optional, tag = "7")]
pub next_queue_item_id: Option<i32>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RendererStateUpdatedMessage {
#[prost(message, optional, tag = "1")]
pub state: Option<RendererStateMessage>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RendererVolumeChangedMessage {
#[prost(int32, optional, tag = "1")]
pub volume: Option<i32>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RendererVolumeMutedMessage {
#[prost(bool, optional, tag = "1")]
pub value: Option<bool>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RendererFileAudioQualityChangedMessage {
#[prost(int32, optional, tag = "1")]
pub sampling_rate: Option<i32>,
#[prost(int32, optional, tag = "2")]
pub bit_depth: Option<i32>,
#[prost(int32, optional, tag = "3")]
pub nb_channels: Option<i32>,
#[prost(int32, optional, tag = "4")]
pub audio_quality: Option<i32>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RendererMaxAudioQualityChangedMessage {
#[prost(int32, optional, tag = "1")]
pub max_audio_quality: Option<i32>,
#[prost(int32, optional, tag = "2")]
pub network_type: Option<i32>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct QConnectMessages {
#[prost(uint64, optional, tag = "1")]
@@ -474,6 +606,30 @@ pub struct QConnectMessages {
pub struct QConnectMessage {
#[prost(int32, optional, tag = "1")]
pub message_type: Option<i32>,
#[prost(message, optional, tag = "23")]
pub rndr_srvr_state_updated: Option<RendererStateUpdatedMessage>,
#[prost(message, optional, tag = "25")]
pub rndr_srvr_volume_changed: Option<RendererVolumeChangedMessage>,
#[prost(message, optional, tag = "26")]
pub rndr_srvr_file_audio_quality_changed: Option<RendererFileAudioQualityChangedMessage>,
#[prost(message, optional, tag = "28")]
pub rndr_srvr_max_audio_quality_changed: Option<RendererMaxAudioQualityChangedMessage>,
#[prost(message, optional, tag = "29")]
pub rndr_srvr_volume_muted: Option<RendererVolumeMutedMessage>,
#[prost(message, optional, tag = "41")]
pub srvr_rndr_set_state: Option<RendererSetStateMessage>,
#[prost(message, optional, tag = "42")]
pub srvr_rndr_set_volume: Option<RendererSetVolumeMessage>,
#[prost(message, optional, tag = "43")]
pub srvr_rndr_set_active: Option<RendererSetActiveMessage>,
#[prost(message, optional, tag = "44")]
pub srvr_rndr_set_max_audio_quality: Option<RendererSetMaxAudioQualityMessage>,
#[prost(message, optional, tag = "45")]
pub srvr_rndr_set_loop_mode: Option<RendererSetLoopModeMessage>,
#[prost(message, optional, tag = "46")]
pub srvr_rndr_set_shuffle_mode: Option<RendererSetShuffleModeMessage>,
#[prost(message, optional, tag = "47")]
pub srvr_rndr_mute_volume: Option<RendererMuteVolumeMessage>,
#[prost(message, optional, tag = "65")]
pub ctrl_srvr_clear_queue: Option<ClearQueueMessage>,
#[prost(message, optional, tag = "66")]
+40
View File
@@ -0,0 +1,40 @@
use serde::{Deserialize, Serialize};
use serde_json::Value;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum RendererCommandType {
SrvrRndrSetState,
SrvrRndrSetVolume,
SrvrRndrSetActive,
SrvrRndrSetMaxAudioQuality,
SrvrRndrSetLoopMode,
SrvrRndrSetShuffleMode,
SrvrRndrMuteVolume,
}
impl RendererCommandType {
pub const fn as_message_type(self) -> &'static str {
match self {
Self::SrvrRndrSetState => "MESSAGE_TYPE_SRVR_RNDR_SET_STATE",
Self::SrvrRndrSetVolume => "MESSAGE_TYPE_SRVR_RNDR_SET_VOLUME",
Self::SrvrRndrSetActive => "MESSAGE_TYPE_SRVR_RNDR_SET_ACTIVE",
Self::SrvrRndrSetMaxAudioQuality => "MESSAGE_TYPE_SRVR_RNDR_SET_MAX_AUDIO_QUALITY",
Self::SrvrRndrSetLoopMode => "MESSAGE_TYPE_SRVR_RNDR_SET_LOOP_MODE",
Self::SrvrRndrSetShuffleMode => "MESSAGE_TYPE_SRVR_RNDR_SET_SHUFFLE_MODE",
Self::SrvrRndrMuteVolume => "MESSAGE_TYPE_SRVR_RNDR_MUTE_VOLUME",
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RendererServerCommand {
pub command_type: RendererCommandType,
#[serde(default)]
pub payload: Value,
}
impl RendererServerCommand {
pub const fn message_type(&self) -> &'static str {
self.command_type.as_message_type()
}
}