1use crate::dm::meta::{AttributeDescriptor, AttributeQualities, ClusterDescriptor};
33use crate::dm::{Endpoint, Node, Resolved};
34use crate::im::{AttributeId, ClusterHandler, ClusterId, EndpointId, InteractionContext, Status};
35use crate::tlv::{Tag, TlvWriter};
36
37use super::Cluster;
38
39pub const ID: ClusterId = 0x001D;
41
42pub const REVISION: u16 = 3;
44
45pub const DEVICE_TYPE_LIST: AttributeId = 0x0000;
47pub const SERVER_LIST: AttributeId = 0x0001;
49pub const CLIENT_LIST: AttributeId = 0x0002;
51pub const PARTS_LIST: AttributeId = 0x0003;
54pub const TAG_LIST: AttributeId = 0x0004;
56pub const ENDPOINT_UNIQUE_ID: AttributeId = 0x0005;
58
59pub const FEATURE_TAG_LIST: u32 = 1 << 0;
61
62pub use crate::dm::DeviceType;
63
64#[derive(Debug, Clone, Copy, PartialEq, Eq)]
66pub struct SemanticTag<'a> {
67 pub mfg_code: Option<crate::msg::VendorId>,
71 pub namespace_id: u8,
73 pub tag: u8,
75 pub label: Option<&'a str>,
77}
78
79const BASE_ATTRIBUTES: [AttributeDescriptor; 4] = [
83 AttributeDescriptor::read_only(DEVICE_TYPE_LIST).with_qualities(AttributeQualities::FIXED),
84 AttributeDescriptor::read_only(SERVER_LIST).with_qualities(AttributeQualities::FIXED),
85 AttributeDescriptor::read_only(CLIENT_LIST).with_qualities(AttributeQualities::FIXED),
86 AttributeDescriptor::read_only(PARTS_LIST),
87];
88
89const TAGGED_ATTRIBUTES: [AttributeDescriptor; 5] = [
91 BASE_ATTRIBUTES[0],
92 BASE_ATTRIBUTES[1],
93 BASE_ATTRIBUTES[2],
94 BASE_ATTRIBUTES[3],
95 AttributeDescriptor::read_only(TAG_LIST).with_qualities(AttributeQualities::FIXED),
96];
97
98const IDENTIFIED_ATTRIBUTES: [AttributeDescriptor; 5] = [
100 BASE_ATTRIBUTES[0],
101 BASE_ATTRIBUTES[1],
102 BASE_ATTRIBUTES[2],
103 BASE_ATTRIBUTES[3],
104 AttributeDescriptor::read_only(ENDPOINT_UNIQUE_ID).with_qualities(AttributeQualities::FIXED),
105];
106
107const FULL_ATTRIBUTES: [AttributeDescriptor; 6] = [
109 TAGGED_ATTRIBUTES[0],
110 TAGGED_ATTRIBUTES[1],
111 TAGGED_ATTRIBUTES[2],
112 TAGGED_ATTRIBUTES[3],
113 TAGGED_ATTRIBUTES[4],
114 AttributeDescriptor::read_only(ENDPOINT_UNIQUE_ID).with_qualities(AttributeQualities::FIXED),
115];
116
117#[must_use]
119pub const fn cluster() -> ClusterDescriptor<'static> {
120 descriptor_with(&BASE_ATTRIBUTES, 0)
121}
122
123#[must_use]
125pub const fn cluster_with_tags() -> ClusterDescriptor<'static> {
126 descriptor_with(&TAGGED_ATTRIBUTES, FEATURE_TAG_LIST)
127}
128
129#[must_use]
131pub const fn cluster_with_unique_id() -> ClusterDescriptor<'static> {
132 descriptor_with(&IDENTIFIED_ATTRIBUTES, 0)
133}
134
135#[must_use]
137pub const fn cluster_full() -> ClusterDescriptor<'static> {
138 descriptor_with(&FULL_ATTRIBUTES, FEATURE_TAG_LIST)
139}
140
141const fn descriptor_with(
142 attributes: &'static [AttributeDescriptor],
143 feature_map: u32,
144) -> ClusterDescriptor<'static> {
145 ClusterDescriptor {
146 id: ID,
147 revision: REVISION,
148 feature_map,
149 attributes,
150 accepted_commands: &[],
151 generated_commands: &[],
152 events: &[],
153 }
154}
155
156#[derive(Debug, Clone, Copy)]
166pub struct Descriptor<'a> {
167 pub node: Node<'a>,
169 pub endpoint: EndpointId,
171 pub parts: &'a [EndpointId],
173 pub tags: &'a [SemanticTag<'a>],
175 pub unique_id: Option<&'a str>,
177}
178
179impl<'a> Descriptor<'a> {
180 #[must_use]
188 pub const fn new(node: Node<'a>, endpoint: EndpointId) -> Self {
189 Self {
190 node,
191 endpoint,
192 parts: &[],
193 tags: &[],
194 unique_id: None,
195 }
196 }
197
198 #[must_use]
200 pub fn device_types(&self) -> &'a [DeviceType] {
201 match self.node.endpoint(self.endpoint) {
202 Some(endpoint) => endpoint.device_types,
203 None => &[],
204 }
205 }
206
207 #[must_use]
213 pub fn clients(&self) -> &'a [ClusterId] {
214 match self.node.endpoint(self.endpoint) {
215 Some(endpoint) => endpoint.clients,
216 None => &[],
217 }
218 }
219
220 #[must_use]
222 pub const fn with_parts(mut self, parts: &'a [EndpointId]) -> Self {
223 self.parts = parts;
224 self
225 }
226
227 #[must_use]
229 pub const fn with_tags(mut self, tags: &'a [SemanticTag<'a>]) -> Self {
230 self.tags = tags;
231 self
232 }
233
234 #[must_use]
236 pub const fn with_unique_id(mut self, unique_id: &'a str) -> Self {
237 self.unique_id = Some(unique_id);
238 self
239 }
240
241 #[must_use]
248 pub fn descriptor(&self) -> ClusterDescriptor<'static> {
249 match (!self.tags.is_empty(), self.unique_id.is_some()) {
250 (false, false) => cluster(),
251 (true, false) => cluster_with_tags(),
252 (false, true) => cluster_with_unique_id(),
253 (true, true) => cluster_full(),
254 }
255 }
256
257 fn this_endpoint(&self) -> Option<&'a Endpoint<'a>> {
258 self.node.endpoint(self.endpoint)
259 }
260}
261
262impl ClusterHandler for Descriptor<'_> {
263 fn read(
264 &self,
265 resolved: &Resolved<'_>,
266 _ctx: &InteractionContext<'_>,
267 w: &mut TlvWriter<'_>,
268 tag: Tag,
269 ) -> core::result::Result<(), Status> {
270 if resolved.endpoint != self.endpoint {
274 return Err(Status::UnsupportedEndpoint);
275 }
276 match resolved.attribute {
277 DEVICE_TYPE_LIST => {
278 w.start_array(tag).map_err(|_| Status::ResourceExhausted)?;
279 for device_type in self.device_types() {
280 w.start_structure(Tag::Anonymous)
281 .map_err(|_| Status::ResourceExhausted)?;
282 w.unsigned(Tag::Context(0), u64::from(device_type.device_type))
283 .map_err(|_| Status::ResourceExhausted)?;
284 w.unsigned(Tag::Context(1), u64::from(device_type.revision))
285 .map_err(|_| Status::ResourceExhausted)?;
286 w.end_container().map_err(|_| Status::ResourceExhausted)?;
287 }
288 w.end_container().map_err(|_| Status::ResourceExhausted)?;
289 Ok(())
290 }
291 SERVER_LIST => {
292 let endpoint = self.this_endpoint().ok_or(Status::UnsupportedEndpoint)?;
294 write_cluster_ids(w, tag, endpoint.clusters.iter().map(|c| c.id))
295 }
296 CLIENT_LIST => write_cluster_ids(w, tag, self.clients().iter().copied()),
297 PARTS_LIST => {
298 w.start_array(tag).map_err(|_| Status::ResourceExhausted)?;
299 for part in self.parts {
300 w.unsigned(Tag::Anonymous, u64::from(*part))
301 .map_err(|_| Status::ResourceExhausted)?;
302 }
303 w.end_container().map_err(|_| Status::ResourceExhausted)?;
304 Ok(())
305 }
306 TAG_LIST => {
307 w.start_array(tag).map_err(|_| Status::ResourceExhausted)?;
308 for semantic in self.tags {
309 w.start_structure(Tag::Anonymous)
310 .map_err(|_| Status::ResourceExhausted)?;
311 match semantic.mfg_code {
312 Some(vendor) => w.unsigned(Tag::Context(0), u64::from(vendor.0)),
313 None => w.null(Tag::Context(0)),
314 }
315 .map_err(|_| Status::ResourceExhausted)?;
316 w.unsigned(Tag::Context(1), u64::from(semantic.namespace_id))
317 .map_err(|_| Status::ResourceExhausted)?;
318 w.unsigned(Tag::Context(2), u64::from(semantic.tag))
319 .map_err(|_| Status::ResourceExhausted)?;
320 if let Some(label) = semantic.label {
321 w.utf8(Tag::Context(3), label)
322 .map_err(|_| Status::ResourceExhausted)?;
323 }
324 w.end_container().map_err(|_| Status::ResourceExhausted)?;
325 }
326 w.end_container().map_err(|_| Status::ResourceExhausted)?;
327 Ok(())
328 }
329 ENDPOINT_UNIQUE_ID => {
330 let unique_id = self.unique_id.ok_or(Status::UnsupportedAttribute)?;
331 w.utf8(tag, unique_id)
332 .map_err(|_| Status::ResourceExhausted)
333 }
334 _ => Err(Status::UnsupportedAttribute),
335 }
336 }
337}
338
339fn write_cluster_ids(
340 w: &mut TlvWriter<'_>,
341 tag: Tag,
342 ids: impl Iterator<Item = ClusterId>,
343) -> core::result::Result<(), Status> {
344 w.start_array(tag).map_err(|_| Status::ResourceExhausted)?;
345 for id in ids {
346 w.unsigned(Tag::Anonymous, u64::from(id))
347 .map_err(|_| Status::ResourceExhausted)?;
348 }
349 w.end_container().map_err(|_| Status::ResourceExhausted)
350}
351
352impl Cluster for Descriptor<'_> {
353 const ID: ClusterId = ID;
354}