feat(qconnect-protocol): implement protobuf queue command and server event contracts

-cx
This commit is contained in:
vicrodh committed 2026-02-21 12:17:42 -06:00
1 parent 18b1bd76e0
commit d1b01bbd5e
9 files changed
+1910

No files matched your search

+67
View File
@@ -0,0 +1,67 @@
use qconnect_core::QueueVersion;
use serde::{Deserialize, Serialize};
use serde_json::Value;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum QueueCommandType {
CtrlSrvrQueueAddTracks,
CtrlSrvrQueueLoadTracks,
CtrlSrvrQueueInsertTracks,
CtrlSrvrQueueRemoveTracks,
CtrlSrvrQueueReorderTracks,
CtrlSrvrClearQueue,
CtrlSrvrSetShuffleMode,
CtrlSrvrSetAutoplayMode,
CtrlSrvrAutoplayLoadTracks,
CtrlSrvrAutoplayRemoveTracks,
CtrlSrvrSetQueueState,
CtrlSrvrAskForQueueState,
}
impl QueueCommandType {
pub const fn as_message_type(self) -> &'static str {
match self {
Self::CtrlSrvrQueueAddTracks => "MESSAGE_TYPE_CTRL_SRVR_QUEUE_ADD_TRACKS",
Self::CtrlSrvrQueueLoadTracks => "MESSAGE_TYPE_CTRL_SRVR_QUEUE_LOAD_TRACKS",
Self::CtrlSrvrQueueInsertTracks => "MESSAGE_TYPE_CTRL_SRVR_QUEUE_INSERT_TRACKS",
Self::CtrlSrvrQueueRemoveTracks => "MESSAGE_TYPE_CTRL_SRVR_QUEUE_REMOVE_TRACKS",
Self::CtrlSrvrQueueReorderTracks => "MESSAGE_TYPE_CTRL_SRVR_QUEUE_REORDER_TRACKS",
Self::CtrlSrvrClearQueue => "MESSAGE_TYPE_CTRL_SRVR_CLEAR_QUEUE",
Self::CtrlSrvrSetShuffleMode => "MESSAGE_TYPE_CTRL_SRVR_SET_SHUFFLE_MODE",
Self::CtrlSrvrSetAutoplayMode => "MESSAGE_TYPE_CTRL_SRVR_SET_AUTOPLAY_MODE",
Self::CtrlSrvrAutoplayLoadTracks => "MESSAGE_TYPE_CTRL_SRVR_AUTOPLAY_LOAD_TRACKS",
Self::CtrlSrvrAutoplayRemoveTracks => "MESSAGE_TYPE_CTRL_SRVR_AUTOPLAY_REMOVE_TRACKS",
Self::CtrlSrvrSetQueueState => "MESSAGE_TYPE_CTRL_SRVR_SET_QUEUE_STATE",
Self::CtrlSrvrAskForQueueState => "MESSAGE_TYPE_CTRL_SRVR_ASK_FOR_QUEUE_STATE",
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct QueueCommand {
pub command_type: QueueCommandType,
pub action_uuid: String,
pub queue_version_ref: QueueVersion,
#[serde(default)]
pub payload: Value,
}
impl QueueCommand {
pub fn new(
command_type: QueueCommandType,
action_uuid: impl Into<String>,
queue_version_ref: QueueVersion,
payload: Value,
) -> Self {
Self {
command_type,
action_uuid: action_uuid.into(),
queue_version_ref,
payload,
}
}
pub const fn message_type(&self) -> &'static str {
self.command_type.as_message_type()
}
}
+604
View File
@@ -0,0 +1,604 @@
use prost::Message;
use qconnect_core::QueueVersion;
use serde_json::{json, Value};
use uuid::Uuid;
use crate::{
queue_command_proto::{
AutoplayModeSetMessage, AutoplayTracksLoadedMessage, AutoplayTracksRemovedMessage,
QConnectMessage, QConnectMessageType, QConnectMessages, QueueClearedMessage,
QueueErrorMessage, QueueStateMessage, QueueTrack, QueueTrackWithContext,
QueueTracksAddedFromAutoplayMessage, QueueTracksAddedMessage, QueueTracksInsertedMessage,
QueueTracksLoadedMessage, QueueTracksRemovedMessage, QueueTracksReorderedMessage,
QueueVersionRef, ShuffleModeSetMessage,
},
ProtocolError, QueueEventType, QueueServerEvent,
};
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)
}
fn decode_queue_server_event(
message: QConnectMessage,
) -> Result<Option<QueueServerEvent>, ProtocolError> {
let message_type = resolve_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)?
}
_ => return Ok(None),
};
Ok(Some(event))
}
fn resolve_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,
);
}
None
})
}
fn map_queue_error(payload: QueueErrorMessage) -> Result<QueueServerEvent, ProtocolError> {
let error_code = payload
.error
.as_ref()
.and_then(|err| err.code)
.map(|code| code.to_string())
.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());
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
}),
})
}
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": optional_i32_to_u64(payload.shuffle_seed)?,
"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": optional_i32_to_u64(payload.shuffle_seed)?,
"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": optional_i32_to_u64(payload.shuffle_seed)?,
"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": optional_i32_to_u64(payload.shuffle_seed)?,
"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
}),
})
}
fn queue_track_to_json(
track: QueueTrack,
context_uuid: Option<&str>,
) -> Result<Value, ProtocolError> {
let track_id = required_i32_to_u64(track.track_id, "queue_track.track_id")?;
let queue_item_id =
optional_i32_to_u64_named(track.queue_item_id, "queue_track.queue_item_id")?
.unwrap_or(track_id);
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 = required_i32_to_u64(track.track_id, "queue_track_with_context.track_id")?;
let queue_item_id = optional_i32_to_u64_named(
track.queue_item_id,
"queue_track_with_context.queue_item_id",
)?
.unwrap_or(track_id);
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);
};
let major = required_i32_to_u64(version.major, "queue_version.major")?;
let minor = required_i32_to_u64(version.minor, "queue_version.minor")?;
Ok(Some(QueueVersion::new(major, minor)))
}
fn required_i32_to_u64(value: Option<i32>, field_name: &str) -> Result<u64, ProtocolError> {
let raw = value.ok_or_else(|| {
ProtocolError::InvalidPayload(format!("missing required numeric field '{field_name}'"))
})?;
i32_to_u64(raw)
}
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::{
QConnectMessage, QConnectMessageType, QConnectMessages, QueueTrack,
QueueTracksAddedMessage, QueueVersionRef,
};
use super::decode_queue_server_events;
#[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"
);
}
}
+17
View File
@@ -0,0 +1,17 @@
use thiserror::Error;
#[derive(Debug, Error)]
pub enum ProtocolError {
#[error("unknown queue event message type: {0}")]
UnknownMessageType(String),
#[error("unsupported queue command type for protobuf mapping: {0}")]
UnsupportedQueueCommand(String),
#[error("invalid queue command payload: {0}")]
InvalidPayload(String),
#[error("invalid uuid value: {0}")]
InvalidUuid(String),
#[error("protobuf decode error: {0}")]
Decode(#[from] prost::DecodeError),
#[error("serialization error: {0}")]
Serialize(#[from] serde_json::Error),
}
+57
View File
@@ -0,0 +1,57 @@
use qconnect_core::QueueVersion;
use serde::{Deserialize, Serialize};
use serde_json::Value;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum QueueEventType {
SrvrCtrlQueueState,
SrvrCtrlQueueTracksAdded,
SrvrCtrlQueueTracksLoaded,
SrvrCtrlQueueTracksInserted,
SrvrCtrlQueueTracksRemoved,
SrvrCtrlQueueTracksReordered,
SrvrCtrlQueueCleared,
SrvrCtrlShuffleModeSet,
SrvrCtrlAutoplayModeSet,
SrvrCtrlAutoplayTracksLoaded,
SrvrCtrlAutoplayTracksRemoved,
SrvrCtrlQueueTracksAddedFromAutoplay,
SrvrCtrlQueueErrorMessage,
}
impl QueueEventType {
pub const fn as_message_type(self) -> &'static str {
match self {
Self::SrvrCtrlQueueState => "MESSAGE_TYPE_SRVR_CTRL_QUEUE_STATE",
Self::SrvrCtrlQueueTracksAdded => "MESSAGE_TYPE_SRVR_CTRL_QUEUE_TRACKS_ADDED",
Self::SrvrCtrlQueueTracksLoaded => "MESSAGE_TYPE_SRVR_CTRL_QUEUE_TRACKS_LOADED",
Self::SrvrCtrlQueueTracksInserted => "MESSAGE_TYPE_SRVR_CTRL_QUEUE_TRACKS_INSERTED",
Self::SrvrCtrlQueueTracksRemoved => "MESSAGE_TYPE_SRVR_CTRL_QUEUE_TRACKS_REMOVED",
Self::SrvrCtrlQueueTracksReordered => "MESSAGE_TYPE_SRVR_CTRL_QUEUE_TRACKS_REORDERED",
Self::SrvrCtrlQueueCleared => "MESSAGE_TYPE_SRVR_CTRL_QUEUE_CLEARED",
Self::SrvrCtrlShuffleModeSet => "MESSAGE_TYPE_SRVR_CTRL_SHUFFLE_MODE_SET",
Self::SrvrCtrlAutoplayModeSet => "MESSAGE_TYPE_SRVR_CTRL_AUTOPLAY_MODE_SET",
Self::SrvrCtrlAutoplayTracksLoaded => "MESSAGE_TYPE_SRVR_CTRL_AUTOPLAY_TRACKS_LOADED",
Self::SrvrCtrlAutoplayTracksRemoved => "MESSAGE_TYPE_SRVR_CTRL_AUTOPLAY_TRACKS_REMOVED",
Self::SrvrCtrlQueueTracksAddedFromAutoplay => {
"MESSAGE_TYPE_SRVR_CTRL_QUEUE_TRACKS_ADDED_FROM_AUTOPLAY"
}
Self::SrvrCtrlQueueErrorMessage => "MESSAGE_TYPE_SRVR_CTRL_QUEUE_ERROR_MESSAGE",
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct QueueServerEvent {
pub event_type: QueueEventType,
pub action_uuid: Option<String>,
pub queue_version: Option<QueueVersion>,
#[serde(default)]
pub payload: Value,
}
impl QueueServerEvent {
pub const fn message_type(&self) -> &'static str {
self.event_type.as_message_type()
}
}
+22
View File
@@ -0,0 +1,22 @@
//! qconnect-protocol
//!
//! Wire-level contracts for Qobuz Connect WS commands/events.
mod command;
mod decoder;
mod error;
mod event;
mod mapper;
mod queue_command_proto;
mod wire;
pub use command::{QueueCommand, QueueCommandType};
pub use decoder::decode_queue_server_events;
pub use error::ProtocolError;
pub use event::{QueueEventType, QueueServerEvent};
pub use mapper::{build_qconnect_outbound_envelope, encode_queue_command_batch};
pub use wire::{
build_outbound_envelope, decode_inbound_json, encode_outbound_json,
encode_outbound_payload_bytes, parse_inbound_event, InboundEnvelope, OutboundEnvelope,
QCONNECT_BACKEND_DESTINATION, QCONNECT_SERVICE,
};
+497
View File
@@ -0,0 +1,497 @@
use std::{
sync::atomic::{AtomicI32, Ordering},
time::{SystemTime, UNIX_EPOCH},
};
use prost::Message;
use serde_json::Value;
use uuid::Uuid;
use crate::{
build_outbound_envelope,
queue_command_proto::{
AskForQueueStateMessage, AutoplayLoadTracksMessage, AutoplayRemoveTracksMessage,
ClearQueueMessage, QConnectMessage, QConnectMessageType, QConnectMessages,
QueueAddTracksMessage, QueueInsertTracksMessage, QueueLoadTracksMessage,
QueueRemoveTracksMessage, QueueReorderTracksMessage, QueueVersionRef,
SetAutoplayModeMessage, SetQueueStateMessage, SetQueueTrackWithContext,
SetShuffleModeMessage,
},
OutboundEnvelope, ProtocolError, QueueCommand, QueueCommandType,
};
static BATCH_SEQ: AtomicI32 = AtomicI32::new(1);
pub fn build_qconnect_outbound_envelope(
command: QueueCommand,
) -> Result<OutboundEnvelope, ProtocolError> {
let payload_bytes = encode_queue_command_batch(&command)?;
let mut envelope = build_outbound_envelope(command);
envelope.payload_bytes = Some(payload_bytes);
Ok(envelope)
}
pub fn encode_queue_command_batch(command: &QueueCommand) -> Result<Vec<u8>, ProtocolError> {
let message = map_queue_command(command)?;
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<QConnectMessage, ProtocolError> {
let queue_version_ref = Some(to_proto_queue_version(command.queue_version_ref)?);
let action_uuid = Some(action_uuid_bytes(&command.action_uuid)?);
match command.command_type {
QueueCommandType::CtrlSrvrQueueAddTracks => {
let track_ids = required_i32_list(&command.payload, "track_ids")?;
let shuffle_seed = optional_i32(&command.payload, "shuffle_seed")?;
let context_uuid = optional_uuid_bytes(&command.payload, &["context_uuid"])?;
let autoplay_reset = optional_bool(&command.payload, "autoplay_reset", false);
let autoplay_loading =
optional_bool(&command.payload, "autoplay_loading", autoplay_reset);
Ok(QConnectMessage {
message_type: Some(QConnectMessageType::MessageTypeCtrlSrvrQueueAddTracks as i32),
ctrl_srvr_queue_add_tracks: Some(QueueAddTracksMessage {
queue_version_ref,
action_uuid,
track_ids,
shuffle_seed,
context_uuid,
autoplay_reset: Some(autoplay_reset),
autoplay_loading: Some(autoplay_loading),
}),
..Default::default()
})
}
QueueCommandType::CtrlSrvrQueueLoadTracks => {
let track_ids = required_i32_list(&command.payload, "track_ids")?;
let queue_position = optional_i32(&command.payload, "queue_position")?;
let shuffle_seed = optional_i32(&command.payload, "shuffle_seed")?;
let shuffle_pivot_index = optional_i32(&command.payload, "shuffle_pivot_index")?;
let shuffle_mode = optional_bool(&command.payload, "shuffle_mode", false);
let context_uuid = optional_uuid_bytes(&command.payload, &["context_uuid"])?;
let autoplay_reset = optional_bool(&command.payload, "autoplay_reset", false);
let autoplay_loading =
optional_bool(&command.payload, "autoplay_loading", autoplay_reset);
Ok(QConnectMessage {
message_type: Some(QConnectMessageType::MessageTypeCtrlSrvrQueueLoadTracks as i32),
ctrl_srvr_queue_load_tracks: Some(QueueLoadTracksMessage {
queue_version_ref,
action_uuid,
track_ids,
queue_position,
shuffle_seed,
shuffle_pivot_index,
shuffle_mode: Some(shuffle_mode),
context_uuid,
autoplay_reset: Some(autoplay_reset),
autoplay_loading: Some(autoplay_loading),
}),
..Default::default()
})
}
QueueCommandType::CtrlSrvrQueueInsertTracks => {
let track_ids = required_i32_list(&command.payload, "track_ids")?;
let insert_after = optional_i32(&command.payload, "insert_after")?;
let shuffle_seed = optional_i32(&command.payload, "shuffle_seed")?;
let context_uuid = optional_uuid_bytes(&command.payload, &["context_uuid"])?;
let autoplay_reset = optional_bool(&command.payload, "autoplay_reset", false);
let autoplay_loading =
optional_bool(&command.payload, "autoplay_loading", autoplay_reset);
Ok(QConnectMessage {
message_type: Some(
QConnectMessageType::MessageTypeCtrlSrvrQueueInsertTracks as i32,
),
ctrl_srvr_queue_insert_tracks: Some(QueueInsertTracksMessage {
queue_version_ref,
action_uuid,
track_ids,
insert_after,
shuffle_seed,
context_uuid,
autoplay_reset: Some(autoplay_reset),
autoplay_loading: Some(autoplay_loading),
}),
..Default::default()
})
}
QueueCommandType::CtrlSrvrQueueRemoveTracks => {
let queue_item_ids = required_i32_list(&command.payload, "queue_item_ids")?;
let autoplay_reset = optional_bool(&command.payload, "autoplay_reset", false);
let autoplay_loading =
optional_bool(&command.payload, "autoplay_loading", autoplay_reset);
Ok(QConnectMessage {
message_type: Some(
QConnectMessageType::MessageTypeCtrlSrvrQueueRemoveTracks as i32,
),
ctrl_srvr_queue_remove_tracks: Some(QueueRemoveTracksMessage {
queue_version_ref,
action_uuid,
queue_item_ids,
autoplay_reset: Some(autoplay_reset),
autoplay_loading: Some(autoplay_loading),
}),
..Default::default()
})
}
QueueCommandType::CtrlSrvrQueueReorderTracks => {
let queue_item_ids = required_i32_list(&command.payload, "queue_item_ids")?;
let insert_after = optional_i32(&command.payload, "insert_after")?;
let autoplay_reset = optional_bool(&command.payload, "autoplay_reset", false);
let autoplay_loading =
optional_bool(&command.payload, "autoplay_loading", autoplay_reset);
Ok(QConnectMessage {
message_type: Some(
QConnectMessageType::MessageTypeCtrlSrvrQueueReorderTracks as i32,
),
ctrl_srvr_queue_reorder_tracks: Some(QueueReorderTracksMessage {
queue_version_ref,
action_uuid,
queue_item_ids,
insert_after,
autoplay_reset: Some(autoplay_reset),
autoplay_loading: Some(autoplay_loading),
}),
..Default::default()
})
}
QueueCommandType::CtrlSrvrClearQueue => Ok(QConnectMessage {
message_type: Some(QConnectMessageType::MessageTypeCtrlSrvrClearQueue as i32),
ctrl_srvr_clear_queue: Some(ClearQueueMessage {
queue_version_ref,
action_uuid,
}),
..Default::default()
}),
QueueCommandType::CtrlSrvrSetShuffleMode => {
let shuffle_mode = optional_bool(&command.payload, "shuffle_mode", false);
let shuffle_seed = optional_i32(&command.payload, "shuffle_seed")?;
let shuffle_pivot_queue_item_id =
optional_i32(&command.payload, "shuffle_pivot_queue_item_id")?;
let autoplay_reset = optional_bool(&command.payload, "autoplay_reset", false);
let autoplay_loading =
optional_bool(&command.payload, "autoplay_loading", autoplay_reset);
Ok(QConnectMessage {
message_type: Some(QConnectMessageType::MessageTypeCtrlSrvrSetShuffleMode as i32),
ctrl_srvr_set_shuffle_mode: Some(SetShuffleModeMessage {
queue_version_ref,
action_uuid,
shuffle_mode: Some(shuffle_mode),
shuffle_seed,
shuffle_pivot_queue_item_id,
autoplay_reset: Some(autoplay_reset),
autoplay_loading: Some(autoplay_loading),
}),
..Default::default()
})
}
QueueCommandType::CtrlSrvrSetAutoplayMode => {
let autoplay_mode = optional_bool(&command.payload, "autoplay_mode", false);
// Android forces these defaults for setAutoplayMode.
let autoplay_reset = optional_bool(&command.payload, "autoplay_reset", true);
let autoplay_loading = optional_bool(&command.payload, "autoplay_loading", false);
Ok(QConnectMessage {
message_type: Some(QConnectMessageType::MessageTypeCtrlSrvrSetAutoplayMode as i32),
ctrl_srvr_set_autoplay_mode: Some(SetAutoplayModeMessage {
queue_version_ref,
action_uuid,
autoplay_mode: Some(autoplay_mode),
autoplay_reset: Some(autoplay_reset),
autoplay_loading: Some(autoplay_loading),
}),
..Default::default()
})
}
QueueCommandType::CtrlSrvrAutoplayLoadTracks => {
let track_ids = required_i32_list(&command.payload, "track_ids")?;
let context_uuid = optional_uuid_bytes(&command.payload, &["context_uuid"])?;
Ok(QConnectMessage {
message_type: Some(
QConnectMessageType::MessageTypeCtrlSrvrAutoplayLoadTracks as i32,
),
ctrl_srvr_autoplay_load_tracks: Some(AutoplayLoadTracksMessage {
queue_version_ref,
action_uuid,
track_ids,
context_uuid,
}),
..Default::default()
})
}
QueueCommandType::CtrlSrvrAutoplayRemoveTracks => {
let queue_item_ids = required_i32_list(&command.payload, "queue_item_ids")?;
Ok(QConnectMessage {
message_type: Some(
QConnectMessageType::MessageTypeCtrlSrvrAutoplayRemoveTracks as i32,
),
ctrl_srvr_autoplay_remove_tracks: Some(AutoplayRemoveTracksMessage {
queue_version_ref,
action_uuid,
queue_item_ids,
}),
..Default::default()
})
}
QueueCommandType::CtrlSrvrSetQueueState => {
let tracks = required_tracks_with_context(&command.payload, "tracks")?;
let shuffle_mode = optional_bool(&command.payload, "shuffle_mode", false);
let shuffled_track_indexes =
optional_i32_list(&command.payload, "shuffled_track_indexes")?;
let autoplay_mode = optional_bool(&command.payload, "autoplay_mode", false);
let autoplay_loading = optional_bool(&command.payload, "autoplay_loading", false);
let autoplay_tracks =
required_tracks_with_context(&command.payload, "autoplay_tracks")?;
Ok(QConnectMessage {
message_type: Some(QConnectMessageType::MessageTypeCtrlSrvrSetQueueState as i32),
ctrl_srvr_set_queue_state: Some(SetQueueStateMessage {
queue_version_ref,
action_uuid,
tracks,
shuffle_mode: Some(shuffle_mode),
shuffled_track_indexes,
autoplay_mode: Some(autoplay_mode),
autoplay_loading: Some(autoplay_loading),
autoplay_tracks,
}),
..Default::default()
})
}
QueueCommandType::CtrlSrvrAskForQueueState => Ok(QConnectMessage {
message_type: Some(QConnectMessageType::MessageTypeCtrlSrvrAskForQueueState as i32),
ctrl_srvr_ask_for_queue_state: Some(AskForQueueStateMessage {
queue_version_ref,
action_uuid,
}),
..Default::default()
}),
}
}
fn to_proto_queue_version(
version: qconnect_core::QueueVersion,
) -> Result<QueueVersionRef, ProtocolError> {
Ok(QueueVersionRef {
major: Some(to_i32_from_u64(version.major, "queue_version_ref.major")?),
minor: Some(to_i32_from_u64(version.minor, "queue_version_ref.minor")?),
})
}
fn action_uuid_bytes(value: &str) -> Result<Vec<u8>, ProtocolError> {
let uuid = Uuid::parse_str(value).map_err(|err| {
ProtocolError::InvalidUuid(format!("action_uuid '{}' parse error: {err}", value))
})?;
Ok(uuid.as_bytes().to_vec())
}
fn optional_uuid_bytes(payload: &Value, keys: &[&str]) -> Result<Option<Vec<u8>>, ProtocolError> {
for key in keys {
if let Some(raw) = payload.get(*key).and_then(Value::as_str) {
let uuid = Uuid::parse_str(raw).map_err(|err| {
ProtocolError::InvalidUuid(format!("{} '{}' parse error: {err}", key, raw))
})?;
return Ok(Some(uuid.as_bytes().to_vec()));
}
}
Ok(None)
}
fn required_i32_list(payload: &Value, key: &str) -> Result<Vec<i32>, ProtocolError> {
let values = payload
.get(key)
.and_then(Value::as_array)
.ok_or_else(|| ProtocolError::InvalidPayload(format!("missing array field '{key}'")))?;
values
.iter()
.enumerate()
.map(|(idx, value)| {
let raw = value
.as_i64()
.or_else(|| value.as_u64().map(|v| v as i64))
.ok_or_else(|| {
ProtocolError::InvalidPayload(format!("field '{key}[{idx}]' is not numeric"))
})?;
to_i32_from_i64(raw, &format!("{key}[{idx}]"))
})
.collect()
}
fn optional_i32_list(payload: &Value, key: &str) -> Result<Vec<i32>, ProtocolError> {
let Some(values) = payload.get(key).and_then(Value::as_array) else {
return Ok(Vec::new());
};
values
.iter()
.enumerate()
.map(|(idx, value)| {
let raw = value
.as_i64()
.or_else(|| value.as_u64().map(|v| v as i64))
.ok_or_else(|| {
ProtocolError::InvalidPayload(format!("field '{key}[{idx}]' is not numeric"))
})?;
to_i32_from_i64(raw, &format!("{key}[{idx}]"))
})
.collect()
}
fn required_tracks_with_context(
payload: &Value,
key: &str,
) -> Result<Vec<SetQueueTrackWithContext>, ProtocolError> {
let Some(values) = payload.get(key).and_then(Value::as_array) else {
return Ok(Vec::new());
};
values
.iter()
.enumerate()
.map(|(idx, value)| {
let track_id = value
.get("track_id")
.or_else(|| value.get("trackId"))
.and_then(Value::as_i64)
.or_else(|| {
value
.get("track_id")
.or_else(|| value.get("trackId"))
.and_then(Value::as_u64)
.map(|v| v as i64)
})
.ok_or_else(|| {
ProtocolError::InvalidPayload(format!(
"field '{key}[{idx}].track_id' is required"
))
})?;
let context_uuid = value
.get("context_uuid")
.or_else(|| value.get("track_context_uuid"))
.and_then(Value::as_str)
.map(parse_uuid)
.transpose()?;
Ok(SetQueueTrackWithContext {
track_id: Some(to_i32_from_i64(
track_id,
&format!("{key}[{idx}].track_id"),
)?),
context_uuid,
})
})
.collect()
}
fn optional_i32(payload: &Value, key: &str) -> Result<Option<i32>, ProtocolError> {
match payload.get(key) {
None => Ok(None),
Some(value) => {
let raw = value
.as_i64()
.or_else(|| value.as_u64().map(|v| v as i64))
.ok_or_else(|| {
ProtocolError::InvalidPayload(format!("field '{key}' is not numeric"))
})?;
Ok(Some(to_i32_from_i64(raw, key)?))
}
}
}
fn optional_bool(payload: &Value, key: &str, default: bool) -> bool {
payload.get(key).and_then(Value::as_bool).unwrap_or(default)
}
fn parse_uuid(value: &str) -> Result<Vec<u8>, ProtocolError> {
let parsed = Uuid::parse_str(value)
.map_err(|err| ProtocolError::InvalidUuid(format!("'{value}' parse error: {err}")))?;
Ok(parsed.as_bytes().to_vec())
}
fn to_i32_from_u64(value: u64, field_name: &str) -> Result<i32, ProtocolError> {
i32::try_from(value).map_err(|_| {
ProtocolError::InvalidPayload(format!("field '{field_name}' is out of i32 range: {value}"))
})
}
fn to_i32_from_i64(value: i64, field_name: &str) -> Result<i32, ProtocolError> {
i32::try_from(value).map_err(|_| {
ProtocolError::InvalidPayload(format!("field '{field_name}' is out of i32 range: {value}"))
})
}
fn next_batch_seq() -> i32 {
BATCH_SEQ.fetch_add(1, Ordering::Relaxed)
}
fn now_ms() -> u64 {
SystemTime::now()
.duration_since(UNIX_EPOCH)
.unwrap_or_default()
.as_millis() as u64
}
#[cfg(test)]
mod tests {
use super::*;
use crate::QueueCommand;
use qconnect_core::QueueVersion;
use serde_json::json;
#[test]
fn encodes_add_tracks_command_into_binary_batch() {
let command = QueueCommand::new(
QueueCommandType::CtrlSrvrQueueAddTracks,
"85fa0dd6-7bd6-4b3c-8f43-b8ee22e65d5e",
QueueVersion::new(1, 2),
json!({
"track_ids": [101, 102],
"context_uuid": "0f892e1a-a2f4-4d18-82c6-31e8daf2ea0f",
"autoplay_reset": true
}),
);
let payload = encode_queue_command_batch(&command).expect("batch payload");
assert!(!payload.is_empty());
}
#[test]
fn rejects_non_uuid_action_id() {
let command = QueueCommand::new(
QueueCommandType::CtrlSrvrQueueAddTracks,
"not-a-uuid",
QueueVersion::new(1, 2),
json!({"track_ids": [1]}),
);
let err = encode_queue_command_batch(&command).expect_err("expected invalid uuid");
assert!(matches!(err, ProtocolError::InvalidUuid(_)));
}
#[test]
fn set_autoplay_mode_defaults_follow_android_behavior() {
let command = QueueCommand::new(
QueueCommandType::CtrlSrvrSetAutoplayMode,
"2d8292c8-4f23-40f3-98a4-e3899eb0d03a",
QueueVersion::new(7, 8),
json!({"autoplay_mode": true}),
);
let payload = encode_queue_command_batch(&command).expect("batch payload");
assert!(!payload.is_empty());
}
}
@@ -0,0 +1,527 @@
#[derive(Clone, Copy, PartialEq, Eq, Debug, ::prost::Enumeration)]
#[repr(i32)]
pub enum QConnectMessageType {
MessageTypeCtrlSrvrClearQueue = 65,
MessageTypeCtrlSrvrQueueLoadTracks = 66,
MessageTypeCtrlSrvrQueueInsertTracks = 67,
MessageTypeCtrlSrvrQueueAddTracks = 68,
MessageTypeCtrlSrvrQueueRemoveTracks = 69,
MessageTypeCtrlSrvrQueueReorderTracks = 70,
MessageTypeCtrlSrvrSetShuffleMode = 71,
MessageTypeCtrlSrvrSetQueueState = 75,
MessageTypeCtrlSrvrAskForQueueState = 76,
MessageTypeCtrlSrvrSetAutoplayMode = 78,
MessageTypeCtrlSrvrAutoplayLoadTracks = 79,
MessageTypeCtrlSrvrAutoplayRemoveTracks = 80,
MessageTypeSrvrCtrlQueueErrorMessage = 88,
MessageTypeSrvrCtrlQueueCleared = 89,
MessageTypeSrvrCtrlQueueState = 90,
MessageTypeSrvrCtrlQueueTracksLoaded = 91,
MessageTypeSrvrCtrlQueueTracksInserted = 92,
MessageTypeSrvrCtrlQueueTracksAdded = 93,
MessageTypeSrvrCtrlQueueTracksRemoved = 94,
MessageTypeSrvrCtrlQueueTracksReordered = 95,
MessageTypeSrvrCtrlShuffleModeSet = 96,
MessageTypeSrvrCtrlAutoplayModeSet = 102,
MessageTypeSrvrCtrlAutoplayTracksLoaded = 103,
MessageTypeSrvrCtrlAutoplayTracksRemoved = 104,
MessageTypeSrvrCtrlQueueTracksAddedFromAutoplay = 105,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct QueueVersionRef {
#[prost(int32, optional, tag = "1")]
pub major: Option<i32>,
#[prost(int32, optional, tag = "2")]
pub minor: Option<i32>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ErrorMessage {
#[prost(int32, optional, tag = "1")]
pub code: Option<i32>,
#[prost(string, optional, tag = "2")]
pub message: Option<String>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct QueueTrack {
#[prost(int32, optional, tag = "1")]
pub queue_item_id: Option<i32>,
#[prost(int32, optional, tag = "2")]
pub track_id: Option<i32>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct QueueTrackWithContext {
#[prost(int32, optional, tag = "1")]
pub queue_item_id: Option<i32>,
#[prost(int32, optional, tag = "2")]
pub track_id: Option<i32>,
#[prost(bytes = "vec", optional, tag = "3")]
pub context_uuid: Option<Vec<u8>>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SetQueueTrackWithContext {
#[prost(int32, optional, tag = "1")]
pub track_id: Option<i32>,
#[prost(bytes = "vec", optional, tag = "2")]
pub context_uuid: Option<Vec<u8>>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ClearQueueMessage {
#[prost(message, optional, tag = "1")]
pub queue_version_ref: Option<QueueVersionRef>,
#[prost(bytes = "vec", optional, tag = "2")]
pub action_uuid: Option<Vec<u8>>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct QueueLoadTracksMessage {
#[prost(message, optional, tag = "1")]
pub queue_version_ref: Option<QueueVersionRef>,
#[prost(bytes = "vec", optional, tag = "2")]
pub action_uuid: Option<Vec<u8>>,
#[prost(int32, repeated, packed = "false", tag = "3")]
pub track_ids: Vec<i32>,
#[prost(int32, optional, tag = "4")]
pub queue_position: Option<i32>,
#[prost(int32, optional, tag = "5")]
pub shuffle_seed: Option<i32>,
#[prost(int32, optional, tag = "6")]
pub shuffle_pivot_index: Option<i32>,
#[prost(bool, optional, tag = "7")]
pub shuffle_mode: Option<bool>,
#[prost(bytes = "vec", optional, tag = "8")]
pub context_uuid: Option<Vec<u8>>,
#[prost(bool, optional, tag = "9")]
pub autoplay_reset: Option<bool>,
#[prost(bool, optional, tag = "10")]
pub autoplay_loading: Option<bool>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct QueueInsertTracksMessage {
#[prost(message, optional, tag = "1")]
pub queue_version_ref: Option<QueueVersionRef>,
#[prost(bytes = "vec", optional, tag = "2")]
pub action_uuid: Option<Vec<u8>>,
#[prost(int32, repeated, packed = "false", tag = "3")]
pub track_ids: Vec<i32>,
#[prost(int32, optional, tag = "4")]
pub insert_after: Option<i32>,
#[prost(int32, optional, tag = "5")]
pub shuffle_seed: Option<i32>,
#[prost(bytes = "vec", optional, tag = "6")]
pub context_uuid: Option<Vec<u8>>,
#[prost(bool, optional, tag = "7")]
pub autoplay_reset: Option<bool>,
#[prost(bool, optional, tag = "8")]
pub autoplay_loading: Option<bool>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct QueueAddTracksMessage {
#[prost(message, optional, tag = "1")]
pub queue_version_ref: Option<QueueVersionRef>,
#[prost(bytes = "vec", optional, tag = "2")]
pub action_uuid: Option<Vec<u8>>,
#[prost(int32, repeated, packed = "false", tag = "3")]
pub track_ids: Vec<i32>,
#[prost(int32, optional, tag = "4")]
pub shuffle_seed: Option<i32>,
#[prost(bytes = "vec", optional, tag = "5")]
pub context_uuid: Option<Vec<u8>>,
#[prost(bool, optional, tag = "6")]
pub autoplay_reset: Option<bool>,
#[prost(bool, optional, tag = "7")]
pub autoplay_loading: Option<bool>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct QueueRemoveTracksMessage {
#[prost(message, optional, tag = "1")]
pub queue_version_ref: Option<QueueVersionRef>,
#[prost(bytes = "vec", optional, tag = "2")]
pub action_uuid: Option<Vec<u8>>,
#[prost(int32, repeated, packed = "false", tag = "3")]
pub queue_item_ids: Vec<i32>,
#[prost(bool, optional, tag = "4")]
pub autoplay_reset: Option<bool>,
#[prost(bool, optional, tag = "5")]
pub autoplay_loading: Option<bool>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct QueueReorderTracksMessage {
#[prost(message, optional, tag = "1")]
pub queue_version_ref: Option<QueueVersionRef>,
#[prost(bytes = "vec", optional, tag = "2")]
pub action_uuid: Option<Vec<u8>>,
#[prost(int32, repeated, packed = "false", tag = "3")]
pub queue_item_ids: Vec<i32>,
#[prost(int32, optional, tag = "4")]
pub insert_after: Option<i32>,
#[prost(bool, optional, tag = "5")]
pub autoplay_reset: Option<bool>,
#[prost(bool, optional, tag = "6")]
pub autoplay_loading: Option<bool>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SetShuffleModeMessage {
#[prost(message, optional, tag = "1")]
pub queue_version_ref: Option<QueueVersionRef>,
#[prost(bytes = "vec", optional, tag = "2")]
pub action_uuid: Option<Vec<u8>>,
#[prost(bool, optional, tag = "3")]
pub shuffle_mode: Option<bool>,
#[prost(int32, optional, tag = "4")]
pub shuffle_seed: Option<i32>,
#[prost(int32, optional, tag = "5")]
pub shuffle_pivot_queue_item_id: Option<i32>,
#[prost(bool, optional, tag = "6")]
pub autoplay_reset: Option<bool>,
#[prost(bool, optional, tag = "7")]
pub autoplay_loading: Option<bool>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SetAutoplayModeMessage {
#[prost(message, optional, tag = "1")]
pub queue_version_ref: Option<QueueVersionRef>,
#[prost(bytes = "vec", optional, tag = "2")]
pub action_uuid: Option<Vec<u8>>,
#[prost(bool, optional, tag = "3")]
pub autoplay_mode: Option<bool>,
#[prost(bool, optional, tag = "4")]
pub autoplay_reset: Option<bool>,
#[prost(bool, optional, tag = "5")]
pub autoplay_loading: Option<bool>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AutoplayLoadTracksMessage {
#[prost(message, optional, tag = "1")]
pub queue_version_ref: Option<QueueVersionRef>,
#[prost(bytes = "vec", optional, tag = "2")]
pub action_uuid: Option<Vec<u8>>,
#[prost(int32, repeated, packed = "false", tag = "3")]
pub track_ids: Vec<i32>,
#[prost(bytes = "vec", optional, tag = "4")]
pub context_uuid: Option<Vec<u8>>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AutoplayRemoveTracksMessage {
#[prost(message, optional, tag = "1")]
pub queue_version_ref: Option<QueueVersionRef>,
#[prost(bytes = "vec", optional, tag = "2")]
pub action_uuid: Option<Vec<u8>>,
#[prost(int32, repeated, packed = "false", tag = "3")]
pub queue_item_ids: Vec<i32>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct SetQueueStateMessage {
#[prost(message, optional, tag = "1")]
pub queue_version_ref: Option<QueueVersionRef>,
#[prost(bytes = "vec", optional, tag = "2")]
pub action_uuid: Option<Vec<u8>>,
#[prost(message, repeated, tag = "3")]
pub tracks: Vec<SetQueueTrackWithContext>,
#[prost(bool, optional, tag = "4")]
pub shuffle_mode: Option<bool>,
#[prost(int32, repeated, packed = "false", tag = "5")]
pub shuffled_track_indexes: Vec<i32>,
#[prost(bool, optional, tag = "6")]
pub autoplay_mode: Option<bool>,
#[prost(bool, optional, tag = "7")]
pub autoplay_loading: Option<bool>,
#[prost(message, repeated, tag = "8")]
pub autoplay_tracks: Vec<SetQueueTrackWithContext>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AskForQueueStateMessage {
#[prost(message, optional, tag = "1")]
pub queue_version_ref: Option<QueueVersionRef>,
#[prost(bytes = "vec", optional, tag = "2")]
pub action_uuid: Option<Vec<u8>>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct QueueErrorMessage {
#[prost(message, optional, tag = "1")]
pub queue_version: Option<QueueVersionRef>,
#[prost(bytes = "vec", optional, tag = "2")]
pub action_uuid: Option<Vec<u8>>,
#[prost(message, optional, tag = "3")]
pub error: Option<ErrorMessage>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct QueueClearedMessage {
#[prost(message, optional, tag = "1")]
pub queue_version: Option<QueueVersionRef>,
#[prost(bytes = "vec", optional, tag = "2")]
pub action_uuid: Option<Vec<u8>>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct QueueStateMessage {
#[prost(message, optional, tag = "1")]
pub queue_version: Option<QueueVersionRef>,
#[prost(bytes = "vec", optional, tag = "2")]
pub action_uuid: Option<Vec<u8>>,
#[prost(message, repeated, tag = "3")]
pub tracks: Vec<QueueTrackWithContext>,
#[prost(bool, optional, tag = "4")]
pub shuffle_mode: Option<bool>,
#[prost(int32, repeated, packed = "false", tag = "5")]
pub shuffled_track_indexes: Vec<i32>,
#[prost(bool, optional, tag = "6")]
pub autoplay_mode: Option<bool>,
#[prost(bool, optional, tag = "7")]
pub autoplay_loading: Option<bool>,
#[prost(message, repeated, tag = "8")]
pub autoplay_tracks: Vec<QueueTrackWithContext>,
#[prost(bytes = "vec", optional, tag = "100")]
pub queue_hash: Option<Vec<u8>>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct QueueTracksLoadedMessage {
#[prost(message, optional, tag = "1")]
pub queue_version: Option<QueueVersionRef>,
#[prost(bytes = "vec", optional, tag = "2")]
pub action_uuid: Option<Vec<u8>>,
#[prost(message, repeated, tag = "3")]
pub tracks: Vec<QueueTrack>,
#[prost(int32, optional, tag = "4")]
pub queue_position: Option<i32>,
#[prost(int32, optional, tag = "5")]
pub shuffle_seed: Option<i32>,
#[prost(int32, optional, tag = "6")]
pub shuffle_pivot_queue_item_id: Option<i32>,
#[prost(bool, optional, tag = "7")]
pub shuffle_mode: Option<bool>,
#[prost(bytes = "vec", optional, tag = "8")]
pub context_uuid: Option<Vec<u8>>,
#[prost(bool, optional, tag = "9")]
pub autoplay_reset: Option<bool>,
#[prost(bool, optional, tag = "10")]
pub autoplay_loading: Option<bool>,
#[prost(bytes = "vec", optional, tag = "100")]
pub queue_hash: Option<Vec<u8>>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct QueueTracksInsertedMessage {
#[prost(message, optional, tag = "1")]
pub queue_version: Option<QueueVersionRef>,
#[prost(bytes = "vec", optional, tag = "2")]
pub action_uuid: Option<Vec<u8>>,
#[prost(message, repeated, tag = "3")]
pub tracks: Vec<QueueTrack>,
#[prost(int32, optional, tag = "4")]
pub insert_after: Option<i32>,
#[prost(int32, optional, tag = "5")]
pub shuffle_seed: Option<i32>,
#[prost(bytes = "vec", optional, tag = "6")]
pub context_uuid: Option<Vec<u8>>,
#[prost(bool, optional, tag = "7")]
pub autoplay_reset: Option<bool>,
#[prost(bool, optional, tag = "8")]
pub autoplay_loading: Option<bool>,
#[prost(bytes = "vec", optional, tag = "100")]
pub queue_hash: Option<Vec<u8>>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct QueueTracksAddedMessage {
#[prost(message, optional, tag = "1")]
pub queue_version: Option<QueueVersionRef>,
#[prost(bytes = "vec", optional, tag = "2")]
pub action_uuid: Option<Vec<u8>>,
#[prost(message, repeated, tag = "3")]
pub tracks: Vec<QueueTrack>,
#[prost(int32, optional, tag = "4")]
pub shuffle_seed: Option<i32>,
#[prost(bytes = "vec", optional, tag = "5")]
pub context_uuid: Option<Vec<u8>>,
#[prost(bool, optional, tag = "6")]
pub autoplay_reset: Option<bool>,
#[prost(bool, optional, tag = "7")]
pub autoplay_loading: Option<bool>,
#[prost(bytes = "vec", optional, tag = "100")]
pub queue_hash: Option<Vec<u8>>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct QueueTracksRemovedMessage {
#[prost(message, optional, tag = "1")]
pub queue_version: Option<QueueVersionRef>,
#[prost(bytes = "vec", optional, tag = "2")]
pub action_uuid: Option<Vec<u8>>,
#[prost(int32, repeated, packed = "false", tag = "3")]
pub queue_item_ids: Vec<i32>,
#[prost(bool, optional, tag = "4")]
pub autoplay_reset: Option<bool>,
#[prost(bool, optional, tag = "5")]
pub autoplay_loading: Option<bool>,
#[prost(bytes = "vec", optional, tag = "100")]
pub queue_hash: Option<Vec<u8>>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct QueueTracksReorderedMessage {
#[prost(message, optional, tag = "1")]
pub queue_version: Option<QueueVersionRef>,
#[prost(bytes = "vec", optional, tag = "2")]
pub action_uuid: Option<Vec<u8>>,
#[prost(int32, repeated, packed = "false", tag = "3")]
pub queue_item_ids: Vec<i32>,
#[prost(int32, optional, tag = "4")]
pub insert_after: Option<i32>,
#[prost(bool, optional, tag = "5")]
pub autoplay_reset: Option<bool>,
#[prost(bool, optional, tag = "6")]
pub autoplay_loading: Option<bool>,
#[prost(bytes = "vec", optional, tag = "100")]
pub queue_hash: Option<Vec<u8>>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ShuffleModeSetMessage {
#[prost(message, optional, tag = "1")]
pub queue_version: Option<QueueVersionRef>,
#[prost(bytes = "vec", optional, tag = "2")]
pub action_uuid: Option<Vec<u8>>,
#[prost(bool, optional, tag = "3")]
pub shuffle_mode: Option<bool>,
#[prost(int32, optional, tag = "4")]
pub shuffle_seed: Option<i32>,
#[prost(int32, optional, tag = "5")]
pub shuffle_pivot_queue_item_id: Option<i32>,
#[prost(bool, optional, tag = "6")]
pub autoplay_reset: Option<bool>,
#[prost(bool, optional, tag = "7")]
pub autoplay_loading: Option<bool>,
#[prost(bytes = "vec", optional, tag = "100")]
pub queue_hash: Option<Vec<u8>>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AutoplayModeSetMessage {
#[prost(message, optional, tag = "1")]
pub queue_version: Option<QueueVersionRef>,
#[prost(bytes = "vec", optional, tag = "2")]
pub action_uuid: Option<Vec<u8>>,
#[prost(bool, optional, tag = "3")]
pub autoplay_mode: Option<bool>,
#[prost(bool, optional, tag = "4")]
pub autoplay_reset: Option<bool>,
#[prost(bool, optional, tag = "5")]
pub autoplay_loading: Option<bool>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AutoplayTracksLoadedMessage {
#[prost(message, optional, tag = "1")]
pub queue_version: Option<QueueVersionRef>,
#[prost(bytes = "vec", optional, tag = "2")]
pub action_uuid: Option<Vec<u8>>,
#[prost(message, repeated, tag = "3")]
pub tracks: Vec<QueueTrack>,
#[prost(bytes = "vec", optional, tag = "4")]
pub context_uuid: Option<Vec<u8>>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AutoplayTracksRemovedMessage {
#[prost(message, optional, tag = "1")]
pub queue_version: Option<QueueVersionRef>,
#[prost(bytes = "vec", optional, tag = "2")]
pub action_uuid: Option<Vec<u8>>,
#[prost(int32, repeated, packed = "false", tag = "3")]
pub queue_item_ids: Vec<i32>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct QueueTracksAddedFromAutoplayMessage {
#[prost(message, optional, tag = "1")]
pub queue_version: Option<QueueVersionRef>,
#[prost(int32, repeated, packed = "false", tag = "2")]
pub queue_item_ids: Vec<i32>,
#[prost(bytes = "vec", optional, tag = "100")]
pub queue_hash: Option<Vec<u8>>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct QConnectMessages {
#[prost(uint64, optional, tag = "1")]
pub messages_time: Option<u64>,
#[prost(int32, optional, tag = "2")]
pub messages_id: Option<i32>,
#[prost(message, repeated, tag = "3")]
pub messages: Vec<QConnectMessage>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct QConnectMessage {
#[prost(int32, optional, tag = "1")]
pub message_type: Option<i32>,
#[prost(message, optional, tag = "65")]
pub ctrl_srvr_clear_queue: Option<ClearQueueMessage>,
#[prost(message, optional, tag = "66")]
pub ctrl_srvr_queue_load_tracks: Option<QueueLoadTracksMessage>,
#[prost(message, optional, tag = "67")]
pub ctrl_srvr_queue_insert_tracks: Option<QueueInsertTracksMessage>,
#[prost(message, optional, tag = "68")]
pub ctrl_srvr_queue_add_tracks: Option<QueueAddTracksMessage>,
#[prost(message, optional, tag = "69")]
pub ctrl_srvr_queue_remove_tracks: Option<QueueRemoveTracksMessage>,
#[prost(message, optional, tag = "70")]
pub ctrl_srvr_queue_reorder_tracks: Option<QueueReorderTracksMessage>,
#[prost(message, optional, tag = "71")]
pub ctrl_srvr_set_shuffle_mode: Option<SetShuffleModeMessage>,
#[prost(message, optional, tag = "75")]
pub ctrl_srvr_set_queue_state: Option<SetQueueStateMessage>,
#[prost(message, optional, tag = "76")]
pub ctrl_srvr_ask_for_queue_state: Option<AskForQueueStateMessage>,
#[prost(message, optional, tag = "78")]
pub ctrl_srvr_set_autoplay_mode: Option<SetAutoplayModeMessage>,
#[prost(message, optional, tag = "79")]
pub ctrl_srvr_autoplay_load_tracks: Option<AutoplayLoadTracksMessage>,
#[prost(message, optional, tag = "80")]
pub ctrl_srvr_autoplay_remove_tracks: Option<AutoplayRemoveTracksMessage>,
#[prost(message, optional, tag = "88")]
pub srvr_ctrl_queue_error_message: Option<QueueErrorMessage>,
#[prost(message, optional, tag = "89")]
pub srvr_ctrl_queue_cleared: Option<QueueClearedMessage>,
#[prost(message, optional, tag = "90")]
pub srvr_ctrl_queue_state: Option<QueueStateMessage>,
#[prost(message, optional, tag = "91")]
pub srvr_ctrl_queue_tracks_loaded: Option<QueueTracksLoadedMessage>,
#[prost(message, optional, tag = "92")]
pub srvr_ctrl_queue_tracks_inserted: Option<QueueTracksInsertedMessage>,
#[prost(message, optional, tag = "93")]
pub srvr_ctrl_queue_tracks_added: Option<QueueTracksAddedMessage>,
#[prost(message, optional, tag = "94")]
pub srvr_ctrl_queue_tracks_removed: Option<QueueTracksRemovedMessage>,
#[prost(message, optional, tag = "95")]
pub srvr_ctrl_queue_tracks_reordered: Option<QueueTracksReorderedMessage>,
#[prost(message, optional, tag = "96")]
pub srvr_ctrl_shuffle_mode_set: Option<ShuffleModeSetMessage>,
#[prost(message, optional, tag = "102")]
pub srvr_ctrl_autoplay_mode_set: Option<AutoplayModeSetMessage>,
#[prost(message, optional, tag = "103")]
pub srvr_ctrl_autoplay_tracks_loaded: Option<AutoplayTracksLoadedMessage>,
#[prost(message, optional, tag = "104")]
pub srvr_ctrl_autoplay_tracks_removed: Option<AutoplayTracksRemovedMessage>,
#[prost(message, optional, tag = "105")]
pub srvr_ctrl_queue_tracks_added_from_autoplay: Option<QueueTracksAddedFromAutoplayMessage>,
}
+105
View File
@@ -0,0 +1,105 @@
use qconnect_core::QueueVersion;
use serde::{Deserialize, Serialize};
use serde_json::Value;
use crate::{ProtocolError, QueueCommand, QueueEventType, QueueServerEvent};
pub const QCONNECT_SERVICE: &str = "QConnect";
pub const QCONNECT_BACKEND_DESTINATION: &str = "Backend";
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct OutboundEnvelope {
pub service: String,
pub destination: String,
pub message_type: String,
pub action_uuid: String,
pub queue_version_ref: QueueVersion,
#[serde(default)]
pub payload: Value,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub payload_bytes: Option<Vec<u8>>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct InboundEnvelope {
pub service: String,
pub source: String,
pub message_type: String,
pub action_uuid: Option<String>,
pub queue_version: Option<QueueVersion>,
#[serde(default)]
pub payload: Value,
}
pub fn build_outbound_envelope(command: QueueCommand) -> OutboundEnvelope {
OutboundEnvelope {
service: QCONNECT_SERVICE.to_string(),
destination: QCONNECT_BACKEND_DESTINATION.to_string(),
message_type: command.message_type().to_string(),
action_uuid: command.action_uuid,
queue_version_ref: command.queue_version_ref,
payload: command.payload,
payload_bytes: None,
}
}
pub fn parse_inbound_event(envelope: InboundEnvelope) -> Result<QueueServerEvent, ProtocolError> {
Ok(QueueServerEvent {
event_type: parse_event_type(&envelope.message_type)?,
action_uuid: envelope.action_uuid,
queue_version: envelope.queue_version,
payload: envelope.payload,
})
}
pub fn encode_outbound_json(envelope: &OutboundEnvelope) -> Result<Vec<u8>, ProtocolError> {
Ok(serde_json::to_vec(envelope)?)
}
pub fn encode_outbound_payload_bytes(
envelope: &OutboundEnvelope,
) -> Result<Vec<u8>, ProtocolError> {
if let Some(payload_bytes) = &envelope.payload_bytes {
return Ok(payload_bytes.clone());
}
Ok(serde_json::to_vec(envelope)?)
}
pub fn decode_inbound_json(bytes: &[u8]) -> Result<InboundEnvelope, ProtocolError> {
Ok(serde_json::from_slice::<InboundEnvelope>(bytes)?)
}
fn parse_event_type(message_type: &str) -> Result<QueueEventType, ProtocolError> {
match message_type {
"MESSAGE_TYPE_SRVR_CTRL_QUEUE_STATE" => Ok(QueueEventType::SrvrCtrlQueueState),
"MESSAGE_TYPE_SRVR_CTRL_QUEUE_TRACKS_ADDED" => Ok(QueueEventType::SrvrCtrlQueueTracksAdded),
"MESSAGE_TYPE_SRVR_CTRL_QUEUE_TRACKS_LOADED" => {
Ok(QueueEventType::SrvrCtrlQueueTracksLoaded)
}
"MESSAGE_TYPE_SRVR_CTRL_QUEUE_TRACKS_INSERTED" => {
Ok(QueueEventType::SrvrCtrlQueueTracksInserted)
}
"MESSAGE_TYPE_SRVR_CTRL_QUEUE_TRACKS_REMOVED" => {
Ok(QueueEventType::SrvrCtrlQueueTracksRemoved)
}
"MESSAGE_TYPE_SRVR_CTRL_QUEUE_TRACKS_REORDERED" => {
Ok(QueueEventType::SrvrCtrlQueueTracksReordered)
}
"MESSAGE_TYPE_SRVR_CTRL_QUEUE_CLEARED" => Ok(QueueEventType::SrvrCtrlQueueCleared),
"MESSAGE_TYPE_SRVR_CTRL_SHUFFLE_MODE_SET" => Ok(QueueEventType::SrvrCtrlShuffleModeSet),
"MESSAGE_TYPE_SRVR_CTRL_AUTOPLAY_MODE_SET" => Ok(QueueEventType::SrvrCtrlAutoplayModeSet),
"MESSAGE_TYPE_SRVR_CTRL_AUTOPLAY_TRACKS_LOADED" => {
Ok(QueueEventType::SrvrCtrlAutoplayTracksLoaded)
}
"MESSAGE_TYPE_SRVR_CTRL_AUTOPLAY_TRACKS_REMOVED" => {
Ok(QueueEventType::SrvrCtrlAutoplayTracksRemoved)
}
"MESSAGE_TYPE_SRVR_CTRL_QUEUE_TRACKS_ADDED_FROM_AUTOPLAY" => {
Ok(QueueEventType::SrvrCtrlQueueTracksAddedFromAutoplay)
}
"MESSAGE_TYPE_SRVR_CTRL_QUEUE_ERROR_MESSAGE" => {
Ok(QueueEventType::SrvrCtrlQueueErrorMessage)
}
other => Err(ProtocolError::UnknownMessageType(other.to_string())),
}
}