feat(qconnect-protocol): implement protobuf queue command and server event contracts
-cx
This commit is contained in:
1 parent
18b1bd76e0
commit
d1b01bbd5e
9 files changed
+1910
No files matched your search
@@ -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()
|
||||
}
|
||||
}
|
||||
@@ -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"
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -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),
|
||||
}
|
||||
@@ -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()
|
||||
}
|
||||
}
|
||||
@@ -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,
|
||||
};
|
||||
@@ -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>,
|
||||
}
|
||||
@@ -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())),
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user