snapcast-control 0.4.0

a wrapper for the Snapcast JSON-RPC Control API based on tokio
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120

//! # protocol
//!
//! This module contains all code for communicating with the Snapcast server.
//!
//! The module is split into submodules for each type of request and response for server,
//! as well as a `super` scoped `de` module for deserialization.
//!
//! Most users will only need to interact with the following modules:
//! - [client] for interacting with clients
//! - [group] for interacting with groups
//! - [server] for interacting with the server
//! - [stream] for interacting with streams
//!
//! The [errors] module contains all error types that can be returned from the server. This is
//! reexported higher up in the crate.

use serde::Serialize;

/// module for interacting with client devices connected to the Snapcast server
pub mod client;
/// module for interacting with groups of clients
pub mod group;
/// module for interacting with the Snapcast server itself
pub mod server;
/// module for interacting with audio streams
pub mod stream;

/// module for all error types that can be returned from the server
pub mod errors;

mod de;
mod notification;
mod request;
mod result;

pub use de::DeserializationError;
pub(super) use de::{SentRequests, SnapcastDeserializer};
pub(super) use request::{Request, RequestMethod};

pub use notification::Notification;
pub use request::Method;
pub use result::SnapcastResult;

/// A message received from the Snapcast server
#[derive(Debug, Clone, Serialize, PartialEq)]
#[serde(untagged)]
pub enum Message {
  /// A message that is in response to a request
  Result {
    /// The id of the request
    id: uuid::Uuid,
    /// The jsonrpc version (2.0)
    jsonrpc: String,
    /// The result of the request
    result: Box<SnapcastResult>,
  },
  /// An error from the server
  Error {
    /// The id of the request
    id: uuid::Uuid,
    /// The jsonrpc version (2.0)
    jsonrpc: String,
    /// The error
    error: errors::SnapcastError,
  },
  /// A notification from the server
  Notification {
    /// The jsonrpc version (2.0)
    jsonrpc: String,
    /// The notification data itself as a tagged enum
    #[serde(flatten)]
    method: Box<Notification>,
  },
}

/// A message received from the Snapcast server that is not an error
#[derive(Debug, Clone, Serialize, PartialEq)]
#[serde(untagged)]
pub enum ValidMessage {
  /// A message that is in response to a request
  Result {
    /// The id of the request
    id: uuid::Uuid,
    /// The jsonrpc version (2.0)
    jsonrpc: String,
    /// The result of the request
    result: Box<SnapcastResult>,
  },
  /// A notification from the server
  Notification {
    /// The jsonrpc version (2.0)
    jsonrpc: String,
    /// The notification data itself as a tagged enum
    #[serde(flatten)]
    method: Box<Notification>,
  },
}

impl TryFrom<Message> for ValidMessage {
  type Error = errors::SnapcastError;

  fn try_from(value: Message) -> Result<Self, Self::Error> {
    match value {
      Message::Result { id, jsonrpc, result } => Ok(ValidMessage::Result { id, jsonrpc, result }),
      Message::Error { error, .. } => Err(error),
      Message::Notification { jsonrpc, method } => Ok(ValidMessage::Notification { jsonrpc, method }),
    }
  }
}

/// connection status changes reported via callbacks
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize)]
pub enum ConnectionStatus {
  /// connection established (initial or after reconnection)
  Connected,
  /// connection lost, will attempt to reconnect
  Disconnected,
  /// a reconnection attempt failed
  ReconnectFailed,
}