diff --git a/crates/qconnect-protocol/src/lib.rs b/crates/qconnect-protocol/src/lib.rs index ffb3c831f..a29f0a69a 100644 --- a/crates/qconnect-protocol/src/lib.rs +++ b/crates/qconnect-protocol/src/lib.rs @@ -16,8 +16,13 @@ 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 mapper::{ + build_qconnect_outbound_envelope, build_qconnect_renderer_outbound_envelope, + encode_queue_command_batch, encode_renderer_report_batch, +}; +pub use renderer::{ + RendererCommandType, RendererReport, RendererReportType, RendererServerCommand, +}; pub use wire::{ build_outbound_envelope, decode_inbound_json, encode_outbound_json, encode_outbound_payload_bytes, parse_inbound_event, InboundEnvelope, OutboundEnvelope, diff --git a/crates/qconnect-protocol/src/mapper.rs b/crates/qconnect-protocol/src/mapper.rs index a379ea88b..f0c8451f4 100644 --- a/crates/qconnect-protocol/src/mapper.rs +++ b/crates/qconnect-protocol/src/mapper.rs @@ -11,13 +11,16 @@ use crate::{ build_outbound_envelope, queue_command_proto::{ AskForQueueStateMessage, AutoplayLoadTracksMessage, AutoplayRemoveTracksMessage, - ClearQueueMessage, QConnectMessage, QConnectMessageType, QConnectMessages, - QueueAddTracksMessage, QueueInsertTracksMessage, QueueLoadTracksMessage, + ClearQueueMessage, PlaybackPositionMessage, QConnectMessage, QConnectMessageType, + QConnectMessages, QueueAddTracksMessage, QueueInsertTracksMessage, QueueLoadTracksMessage, QueueRemoveTracksMessage, QueueReorderTracksMessage, QueueVersionRef, - SetAutoplayModeMessage, SetQueueStateMessage, SetQueueTrackWithContext, - SetShuffleModeMessage, + RendererFileAudioQualityChangedMessage, RendererMaxAudioQualityChangedMessage, + RendererStateMessage, RendererStateUpdatedMessage, RendererVolumeChangedMessage, + RendererVolumeMutedMessage, SetAutoplayModeMessage, SetQueueStateMessage, + SetQueueTrackWithContext, SetShuffleModeMessage, }, - OutboundEnvelope, ProtocolError, QueueCommand, QueueCommandType, + OutboundEnvelope, ProtocolError, QueueCommand, QueueCommandType, RendererReport, + RendererReportType, }; static BATCH_SEQ: AtomicI32 = AtomicI32::new(1); @@ -41,6 +44,32 @@ pub fn encode_queue_command_batch(command: &QueueCommand) -> Result, Pro Ok(batch.encode_to_vec()) } +pub fn build_qconnect_renderer_outbound_envelope( + report: RendererReport, +) -> Result { + let payload_bytes = encode_renderer_report_batch(&report)?; + let message_type = report.message_type().to_string(); + let mut envelope = build_outbound_envelope(QueueCommand::new( + QueueCommandType::CtrlSrvrAskForQueueState, + report.action_uuid, + report.queue_version_ref, + report.payload, + )); + envelope.message_type = message_type; + envelope.payload_bytes = Some(payload_bytes); + Ok(envelope) +} + +pub fn encode_renderer_report_batch(report: &RendererReport) -> Result, ProtocolError> { + let message = map_renderer_report(report)?; + let batch = QConnectMessages { + messages_time: Some(now_ms()), + messages_id: Some(next_batch_seq()), + messages: vec![message], + }; + Ok(batch.encode_to_vec()) +} + fn map_queue_command(command: &QueueCommand) -> Result { let queue_version_ref = Some(to_proto_queue_version(command.queue_version_ref)?); let action_uuid = Some(action_uuid_bytes(&command.action_uuid)?); @@ -281,6 +310,76 @@ fn map_queue_command(command: &QueueCommand) -> Result Result { + match report.report_type { + RendererReportType::RndrSrvrStateUpdated => { + let queue_version = optional_queue_version(&report.payload, "queue_version")? + .unwrap_or(report.queue_version_ref); + let current_position = optional_i32(&report.payload, "current_position")?; + let duration = optional_i32(&report.payload, "duration")?; + let playback_position = current_position.map(|value| PlaybackPositionMessage { + timestamp: Some(now_ms()), + value: Some(value), + }); + + Ok(QConnectMessage { + message_type: Some(QConnectMessageType::MessageTypeRndrSrvrStateUpdated as i32), + rndr_srvr_state_updated: Some(RendererStateUpdatedMessage { + state: Some(RendererStateMessage { + playing_state: optional_i32(&report.payload, "playing_state")?, + buffer_state: optional_i32(&report.payload, "buffer_state")?, + current_position: playback_position, + duration, + queue_version: Some(to_proto_queue_version(queue_version)?), + current_queue_item_id: optional_i32( + &report.payload, + "current_queue_item_id", + )?, + next_queue_item_id: optional_i32(&report.payload, "next_queue_item_id")?, + }), + }), + ..Default::default() + }) + } + RendererReportType::RndrSrvrVolumeChanged => Ok(QConnectMessage { + message_type: Some(QConnectMessageType::MessageTypeRndrSrvrVolumeChanged as i32), + rndr_srvr_volume_changed: Some(RendererVolumeChangedMessage { + volume: optional_i32(&report.payload, "volume")?, + }), + ..Default::default() + }), + RendererReportType::RndrSrvrVolumeMuted => Ok(QConnectMessage { + message_type: Some(QConnectMessageType::MessageTypeRndrSrvrVolumeMuted as i32), + rndr_srvr_volume_muted: Some(RendererVolumeMutedMessage { + value: Some(optional_bool(&report.payload, "value", false)), + }), + ..Default::default() + }), + RendererReportType::RndrSrvrFileAudioQualityChanged => Ok(QConnectMessage { + message_type: Some( + QConnectMessageType::MessageTypeRndrSrvrFileAudioQualityChanged as i32, + ), + rndr_srvr_file_audio_quality_changed: Some(RendererFileAudioQualityChangedMessage { + sampling_rate: optional_i32(&report.payload, "sampling_rate")?, + bit_depth: optional_i32(&report.payload, "bit_depth")?, + nb_channels: optional_i32(&report.payload, "nb_channels")?, + audio_quality: optional_i32(&report.payload, "audio_quality")?, + }), + ..Default::default() + }), + RendererReportType::RndrSrvrMaxAudioQualityChanged => Ok(QConnectMessage { + message_type: Some( + QConnectMessageType::MessageTypeRndrSrvrMaxAudioQualityChanged as i32, + ), + rndr_srvr_max_audio_quality_changed: Some(RendererMaxAudioQualityChangedMessage { + max_audio_quality: optional_i32(&report.payload, "max_audio_quality")?, + network_type: optional_i32(&report.payload, "network_type")?, + }), + ..Default::default() + }), + } +} + fn to_proto_queue_version( version: qconnect_core::QueueVersion, ) -> Result { @@ -397,9 +496,28 @@ fn required_tracks_with_context( .collect() } +fn optional_queue_version( + payload: &Value, + key: &str, +) -> Result, ProtocolError> { + let Some(version) = payload.get(key) else { + return Ok(None); + }; + + let Some(major) = version.get("major").and_then(Value::as_u64) else { + return Ok(None); + }; + let Some(minor) = version.get("minor").and_then(Value::as_u64) else { + return Ok(None); + }; + + Ok(Some(qconnect_core::QueueVersion { major, minor })) +} + fn optional_i32(payload: &Value, key: &str) -> Result, ProtocolError> { match payload.get(key) { None => Ok(None), + Some(value) if value.is_null() => Ok(None), Some(value) => { let raw = value .as_i64() @@ -448,7 +566,9 @@ fn now_ms() -> u64 { #[cfg(test)] mod tests { use super::*; - use crate::QueueCommand; + use crate::queue_command_proto::{QConnectMessageType, QConnectMessages}; + use crate::{QueueCommand, RendererReport, RendererReportType}; + use prost::Message; use qconnect_core::QueueVersion; use serde_json::json; @@ -494,4 +614,64 @@ mod tests { let payload = encode_queue_command_batch(&command).expect("batch payload"); assert!(!payload.is_empty()); } + + #[test] + fn encodes_renderer_state_updated_report_with_queue_version() { + let report = RendererReport::new( + RendererReportType::RndrSrvrStateUpdated, + "6d8ef3af-b863-4581-9b72-17bd32792c6d", + QueueVersion::new(9, 4), + json!({ + "playing_state": 2, + "buffer_state": 2, + "current_position": 42123, + "duration": 185000, + "current_queue_item_id": 9002, + "next_queue_item_id": 9003 + }), + ); + + let payload = encode_renderer_report_batch(&report).expect("renderer report batch"); + let decoded = QConnectMessages::decode(payload.as_slice()).expect("decode batch"); + assert_eq!(decoded.messages.len(), 1); + let message = &decoded.messages[0]; + assert_eq!( + message.message_type, + Some(QConnectMessageType::MessageTypeRndrSrvrStateUpdated as i32) + ); + + let state = message + .rndr_srvr_state_updated + .as_ref() + .and_then(|payload| payload.state.as_ref()) + .expect("state payload"); + assert_eq!(state.playing_state, Some(2)); + assert_eq!(state.buffer_state, Some(2)); + assert_eq!( + state.current_position.as_ref().and_then(|pos| pos.value), + Some(42_123) + ); + assert_eq!(state.queue_version.as_ref().and_then(|v| v.major), Some(9)); + assert_eq!(state.queue_version.as_ref().and_then(|v| v.minor), Some(4)); + assert_eq!(state.current_queue_item_id, Some(9002)); + assert_eq!(state.next_queue_item_id, Some(9003)); + } + + #[test] + fn build_renderer_outbound_envelope_uses_renderer_message_type() { + let report = RendererReport::new( + RendererReportType::RndrSrvrVolumeChanged, + "0f892e1a-a2f4-4d18-82c6-31e8daf2ea0f", + QueueVersion::new(5, 6), + json!({"volume": 58}), + ); + + let envelope = + build_qconnect_renderer_outbound_envelope(report).expect("renderer envelope"); + assert_eq!( + envelope.message_type, + "MESSAGE_TYPE_RNDR_SRVR_VOLUME_CHANGED" + ); + assert!(envelope.payload_bytes.is_some()); + } } diff --git a/crates/qconnect-protocol/src/renderer.rs b/crates/qconnect-protocol/src/renderer.rs index 996468e25..2fb096ad9 100644 --- a/crates/qconnect-protocol/src/renderer.rs +++ b/crates/qconnect-protocol/src/renderer.rs @@ -1,3 +1,4 @@ +use qconnect_core::QueueVersion; use serde::{Deserialize, Serialize}; use serde_json::Value; @@ -38,3 +39,57 @@ impl RendererServerCommand { self.command_type.as_message_type() } } + +#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] +pub enum RendererReportType { + RndrSrvrStateUpdated, + RndrSrvrVolumeChanged, + RndrSrvrVolumeMuted, + RndrSrvrFileAudioQualityChanged, + RndrSrvrMaxAudioQualityChanged, +} + +impl RendererReportType { + pub const fn as_message_type(self) -> &'static str { + match self { + Self::RndrSrvrStateUpdated => "MESSAGE_TYPE_RNDR_SRVR_STATE_UPDATED", + Self::RndrSrvrVolumeChanged => "MESSAGE_TYPE_RNDR_SRVR_VOLUME_CHANGED", + Self::RndrSrvrVolumeMuted => "MESSAGE_TYPE_RNDR_SRVR_VOLUME_MUTED", + Self::RndrSrvrFileAudioQualityChanged => { + "MESSAGE_TYPE_RNDR_SRVR_FILE_AUDIO_QUALITY_CHANGED" + } + Self::RndrSrvrMaxAudioQualityChanged => { + "MESSAGE_TYPE_RNDR_SRVR_MAX_AUDIO_QUALITY_CHANGED" + } + } + } +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct RendererReport { + pub report_type: RendererReportType, + pub action_uuid: String, + pub queue_version_ref: QueueVersion, + #[serde(default)] + pub payload: Value, +} + +impl RendererReport { + pub fn new( + report_type: RendererReportType, + action_uuid: impl Into, + queue_version_ref: QueueVersion, + payload: Value, + ) -> Self { + Self { + report_type, + action_uuid: action_uuid.into(), + queue_version_ref, + payload, + } + } + + pub const fn message_type(&self) -> &'static str { + self.report_type.as_message_type() + } +}