hues/service/
thirdparty.rs1use crate::{
2 api::HueAPIError,
3 command::{merge_commands, HomeKitCommand, MatterCommand},
4 service::{Bridge, ResourceIdentifier, ResourceType},
5};
6use serde::Deserialize;
7
8#[derive(Debug)]
10pub struct HomeKit<'a> {
11 bridge: &'a Bridge,
12 data: HomeKitData,
13}
14
15impl<'a> HomeKit<'a> {
16 pub fn new(bridge: &'a Bridge, data: HomeKitData) -> Self {
17 HomeKit { bridge, data }
18 }
19
20 pub fn data(&self) -> &HomeKitData {
21 &self.data
22 }
23
24 pub fn id(&self) -> &str {
25 &self.data.id
26 }
27
28 pub fn rid(&self) -> ResourceIdentifier {
29 self.data.rid()
30 }
31
32 pub async fn send(
33 &self,
34 commands: &[HomeKitCommand],
35 ) -> Result<Vec<ResourceIdentifier>, HueAPIError> {
36 let payload = merge_commands(commands);
37 self.bridge.api.put_homekit(self.id(), &payload).await
38 }
39}
40
41#[derive(Clone, Debug, Deserialize)]
43pub struct HomeKitData {
44 pub id: String,
46 pub id_v1: Option<String>,
48 pub status: HomeKitStatus,
56}
57
58impl HomeKitData {
59 pub fn rid(&self) -> ResourceIdentifier {
60 ResourceIdentifier {
61 rid: self.id.to_owned(),
62 rtype: ResourceType::HomeKit,
63 }
64 }
65}
66
67#[derive(Clone, Copy, Debug, Deserialize, Eq, Hash, PartialEq)]
68#[serde(rename_all = "snake_case")]
69pub enum HomeKitStatus {
70 Paired,
71 Pairing,
72 Unpaired,
73}
74
75#[derive(Debug)]
78pub struct Matter<'a> {
79 bridge: &'a Bridge,
80 data: MatterData,
81}
82
83impl<'a> Matter<'a> {
84 pub fn new(bridge: &'a Bridge, data: MatterData) -> Self {
85 Matter { bridge, data }
86 }
87
88 pub fn data(&self) -> &MatterData {
89 &self.data
90 }
91
92 pub fn id(&self) -> &str {
93 &self.data.id
94 }
95
96 pub fn rid(&self) -> ResourceIdentifier {
97 self.data.rid()
98 }
99
100 pub async fn send(
101 &self,
102 commands: &[MatterCommand],
103 ) -> Result<Vec<ResourceIdentifier>, HueAPIError> {
104 let payload = merge_commands(commands);
105 self.bridge.api.put_matter(self.id(), &payload).await
106 }
107}
108
109#[derive(Clone, Debug, Deserialize)]
111pub struct MatterData {
112 pub id: String,
114 pub id_v1: Option<String>,
116 pub max_fabrics: usize,
118 pub has_qr_code: bool,
120}
121
122impl MatterData {
123 pub fn rid(&self) -> ResourceIdentifier {
124 ResourceIdentifier {
125 rid: self.id.to_owned(),
126 rtype: ResourceType::Matter,
127 }
128 }
129}
130
131#[derive(Debug)]
134pub struct MatterFabric {
135 data: MatterFabricData,
136}
137
138impl MatterFabric {
139 pub fn new(data: MatterFabricData) -> Self {
140 MatterFabric { data }
141 }
142
143 pub fn data(&self) -> &MatterFabricData {
144 &self.data
145 }
146
147 pub fn id(&self) -> &str {
148 &self.data.id
149 }
150
151 pub fn rid(&self) -> ResourceIdentifier {
152 self.data.rid()
153 }
154}
155
156#[derive(Clone, Debug, Deserialize)]
158pub struct MatterFabricData {
159 pub id: String,
161 pub id_v1: Option<String>,
163 pub status: MatterFabricStatus,
165 pub fabric_data: Option<FabricData>,
167 pub creation_time: String,
169}
170
171impl MatterFabricData {
172 pub fn rid(&self) -> ResourceIdentifier {
173 ResourceIdentifier {
174 rid: self.id.to_owned(),
175 rtype: ResourceType::MatterFabric,
176 }
177 }
178}
179
180#[derive(Clone, Copy, Debug, Deserialize, Eq, Hash, PartialEq)]
181#[serde(rename_all = "snake_case")]
182pub enum MatterFabricStatus {
183 Pending,
184 #[serde(rename = "timedout")]
185 TimedOut,
186 Paired,
187}
188
189#[derive(Clone, Debug, Deserialize)]
190pub struct FabricData {
191 pub label: String,
192 pub vendor_id: usize,
194}