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
121

use serde::{Deserialize, Serialize};

use crate::{client, group, server, stream};

/// The method of a request that the client can call
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(tag = "method")]
pub enum Method {
  // client
  #[serde(rename = "Client.GetStatus")]
  ClientGetStatus { params: client::GetStatusParams },
  #[serde(rename = "Client.SetVolume")]
  ClientSetVolume { params: client::SetVolumeParams },
  #[serde(rename = "Client.SetLatency")]
  ClientSetLatency { params: client::SetLatencyParams },
  #[serde(rename = "Client.SetName")]
  ClientSetName { params: client::SetNameParams },

  // group
  #[serde(rename = "Group.GetStatus")]
  GroupGetStatus { params: group::GetStatusParams },
  #[serde(rename = "Group.SetMute")]
  GroupSetMute { params: group::SetMuteParams },
  #[serde(rename = "Group.SetStream")]
  GroupSetStream { params: group::SetStreamParams },
  #[serde(rename = "Group.SetClients")]
  GroupSetClients { params: group::SetClientsParams },
  #[serde(rename = "Group.SetName")]
  GroupSetName { params: group::SetNameParams },

  // server
  #[serde(rename = "Server.GetRPCVersion")]
  ServerGetRPCVersion,
  #[serde(rename = "Server.GetStatus")]
  ServerGetStatus,
  #[serde(rename = "Server.DeleteClient")]
  ServerDeleteClient { params: server::DeleteClientParams },

  // stream
  #[serde(rename = "Stream.AddStream")]
  StreamAddStream { params: stream::AddStreamParams },
  #[serde(rename = "Stream.RemoveStream")]
  StreamRemoveStream { params: stream::RemoveStreamParams },
  #[serde(rename = "Stream.Control")]
  StreamControl { params: stream::ControlParams },
  #[serde(rename = "Stream.SetProperty")]
  StreamSetProperty { params: stream::SetPropertyParams },
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Request {
  pub id: uuid::Uuid,
  pub jsonrpc: String,
  #[serde(flatten)]
  pub method: Method,
}

impl TryInto<String> for Request {
  type Error = serde_json::Error;

  fn try_into(self) -> Result<String, Self::Error> {
    serde_json::to_string(&self)
  }
}

#[derive(Clone, Debug)]
pub enum RequestMethod {
  // client
  ClientGetStatus,
  ClientSetVolume(String),
  ClientSetLatency(String),
  ClientSetName(String),

  // group
  GroupGetStatus,
  GroupSetMute(String),
  GroupSetStream(String),
  GroupSetClients,
  GroupSetName(String),

  // server
  ServerGetRPCVersion,
  ServerGetStatus,
  ServerDeleteClient,

  // stream
  StreamAddStream,
  StreamRemoveStream,
  StreamControl,
  StreamSetProperty,
}

impl From<&Method> for RequestMethod {
  fn from(method: &Method) -> Self {
    match method {
      // client
      Method::ClientGetStatus { .. } => Self::ClientGetStatus,
      Method::ClientSetVolume { params } => Self::ClientSetVolume(params.id.clone()),
      Method::ClientSetLatency { params } => Self::ClientSetLatency(params.id.clone()),
      Method::ClientSetName { params } => Self::ClientSetName(params.id.clone()),

      // group
      Method::GroupGetStatus { .. } => Self::GroupGetStatus,
      Method::GroupSetMute { params } => Self::GroupSetMute(params.id.clone()),
      Method::GroupSetStream { params } => Self::GroupSetStream(params.id.clone()),
      Method::GroupSetClients { .. } => Self::GroupSetClients,
      Method::GroupSetName { params } => Self::GroupSetName(params.id.clone()),

      // server
      Method::ServerGetRPCVersion => Self::ServerGetRPCVersion,
      Method::ServerGetStatus => Self::ServerGetStatus,
      Method::ServerDeleteClient { .. } => Self::ServerDeleteClient,

      // stream
      Method::StreamAddStream { .. } => Self::StreamAddStream,
      Method::StreamRemoveStream { .. } => Self::StreamRemoveStream,
      Method::StreamControl { .. } => Self::StreamControl,
      Method::StreamSetProperty { .. } => Self::StreamSetProperty,
    }
  }
}