3 * Copyright (c) 2021 Project CHIP Authors
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at
9 * http://www.apache.org/licenses/LICENSE-2.0
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
18 // THIS FILE IS GENERATED BY ZAP
20 #include "gen/CHIPClientCallbacks.h"
22 #include "gen/enums.h"
23 #include <app/util/CHIPDeviceCallbacksMgr.h>
24 #include <app/util/af-enums.h>
25 #include <app/util/af.h>
26 #include <app/util/basic-types.h>
27 #include <core/CHIPEncoding.h>
28 #include <support/SafeInt.h>
29 #include <support/logging/CHIPLogging.h>
31 using namespace ::chip;
33 #define CHECK_MESSAGE_LENGTH(value) \
34 if (!chip::CanCastTo<uint16_t>(value)) \
36 ChipLogError(Zcl, "CHECK_MESSAGE_LENGTH expects a uint16_t value, got: %d", value); \
37 if (onFailureCallback != nullptr) \
39 Callback::Callback<DefaultFailureCallback> * cb = \
40 Callback::Callback<DefaultFailureCallback>::FromCancelable(onFailureCallback); \
41 cb->mCall(cb->mContext, static_cast<uint8_t>(EMBER_ZCL_STATUS_INVALID_VALUE)); \
46 if (messageLen < value) \
48 ChipLogError(Zcl, "Unexpected response length: %d", messageLen); \
49 if (onFailureCallback != nullptr) \
51 Callback::Callback<DefaultFailureCallback> * cb = \
52 Callback::Callback<DefaultFailureCallback>::FromCancelable(onFailureCallback); \
53 cb->mCall(cb->mContext, static_cast<uint8_t>(EMBER_ZCL_STATUS_INVALID_VALUE)); \
58 messageLen = static_cast<uint16_t>(messageLen - static_cast<uint16_t>(value));
60 #define GET_RESPONSE_CALLBACKS(name) \
61 Callback::Cancelable * onSuccessCallback = nullptr; \
62 Callback::Cancelable * onFailureCallback = nullptr; \
63 NodeId sourceId = emberAfCurrentCommand()->source; \
64 uint8_t sequenceNumber = emberAfCurrentCommand()->seqNum; \
65 CHIP_ERROR err = gCallbacks.GetResponseCallback(sourceId, sequenceNumber, &onSuccessCallback, &onFailureCallback); \
67 if (CHIP_NO_ERROR != err) \
69 if (onSuccessCallback == nullptr) \
71 ChipLogDetail(Zcl, "%s: Missing success callback", name); \
74 if (onFailureCallback == nullptr) \
76 ChipLogDetail(Zcl, "%s: Missing failure callback", name); \
82 #define GET_REPORT_CALLBACK(name) \
83 Callback::Cancelable * onReportCallback = nullptr; \
84 CHIP_ERROR err = gCallbacks.GetReportCallback(sourceId, endpointId, clusterId, attributeId, &onReportCallback); \
86 if (CHIP_NO_ERROR != err) \
88 if (onReportCallback == nullptr) \
90 ChipLogDetail(Zcl, "%s: Missing report callback", name); \
96 void LogStatus(uint8_t status)
100 case EMBER_ZCL_STATUS_SUCCESS:
101 ChipLogProgress(Zcl, " status: EMBER_ZCL_STATUS_SUCCESS (0x%02x)", status);
103 case EMBER_ZCL_STATUS_FAILURE:
104 ChipLogProgress(Zcl, " status: EMBER_ZCL_STATUS_FAILURE (0x%02x)", status);
106 case EMBER_ZCL_STATUS_NOT_AUTHORIZED:
107 ChipLogProgress(Zcl, " status: EMBER_ZCL_STATUS_NOT_AUTHORIZED (0x%02x)", status);
109 case EMBER_ZCL_STATUS_MALFORMED_COMMAND:
110 ChipLogProgress(Zcl, " status: EMBER_ZCL_STATUS_MALFORMED_COMMAND (0x%02x)", status);
112 case EMBER_ZCL_STATUS_UNSUP_COMMAND:
113 ChipLogProgress(Zcl, " status: EMBER_ZCL_STATUS_UNSUP_CLUSTER_COMMAND (0x%02x)", status);
115 case EMBER_ZCL_STATUS_UNSUP_GENERAL_COMMAND:
116 ChipLogProgress(Zcl, " status: EMBER_ZCL_STATUS_UNSUP_GENERAL_COMMAND (0x%02x)", status);
118 case EMBER_ZCL_STATUS_UNSUP_MANUF_CLUSTER_COMMAND:
119 ChipLogProgress(Zcl, " status: EMBER_ZCL_STATUS_UNSUP_MANUF_CLUSTER_COMMAND (0x%02x)", status);
121 case EMBER_ZCL_STATUS_UNSUP_MANUF_GENERAL_COMMAND:
122 ChipLogProgress(Zcl, " status: EMBER_ZCL_STATUS_UNSUP_MANUF_GENERAL_COMMAND (0x%02x)", status);
124 case EMBER_ZCL_STATUS_INVALID_FIELD:
125 ChipLogProgress(Zcl, " status: EMBER_ZCL_STATUS_INVALID_FIELD (0x%02x)", status);
127 case EMBER_ZCL_STATUS_UNSUPPORTED_ATTRIBUTE:
128 ChipLogProgress(Zcl, " status: EMBER_ZCL_STATUS_UNSUPPORTED_ATTRIBUTE (0x%02x)", status);
130 case EMBER_ZCL_STATUS_INVALID_VALUE:
131 ChipLogProgress(Zcl, " status: EMBER_ZCL_STATUS_INVALID_VALUE (0x%02x)", status);
133 case EMBER_ZCL_STATUS_READ_ONLY:
134 ChipLogProgress(Zcl, " status: EMBER_ZCL_STATUS_READ_ONLY (0x%02x)", status);
136 case EMBER_ZCL_STATUS_INSUFFICIENT_SPACE:
137 ChipLogProgress(Zcl, " status: EMBER_ZCL_STATUS_INSUFFICIENT_SPACE (0x%02x)", status);
139 case EMBER_ZCL_STATUS_DUPLICATE_EXISTS:
140 ChipLogProgress(Zcl, " status: EMBER_ZCL_STATUS_DUPLICATE_EXISTS (0x%02x)", status);
142 case EMBER_ZCL_STATUS_NOT_FOUND:
143 ChipLogProgress(Zcl, " status: EMBER_ZCL_STATUS_NOT_FOUND (0x%02x)", status);
145 case EMBER_ZCL_STATUS_UNREPORTABLE_ATTRIBUTE:
146 ChipLogProgress(Zcl, " status: EMBER_ZCL_STATUS_UNREPORTABLE_ATTRIBUTE (0x%02x)", status);
148 case EMBER_ZCL_STATUS_INVALID_DATA_TYPE:
149 ChipLogProgress(Zcl, " status: EMBER_ZCL_STATUS_INVALID_DATA_TYPE (0x%02x)", status);
151 case EMBER_ZCL_STATUS_INVALID_SELECTOR:
152 ChipLogProgress(Zcl, " status: EMBER_ZCL_STATUS_INVALID_SELECTOR (0x%02x)", status);
154 case EMBER_ZCL_STATUS_WRITE_ONLY:
155 ChipLogProgress(Zcl, " status: EMBER_ZCL_STATUS_WRITE_ONLY (0x%02x)", status);
157 case EMBER_ZCL_STATUS_INCONSISTENT_STARTUP_STATE:
158 ChipLogProgress(Zcl, " status: EMBER_ZCL_STATUS_INCONSISTENT_STARTUP_STATE (0x%02x)", status);
160 case EMBER_ZCL_STATUS_DEFINED_OUT_OF_BAND:
161 ChipLogProgress(Zcl, " status: EMBER_ZCL_STATUS_DEFINED_OUT_Of_BAND (0x%02x)", status);
163 case EMBER_ZCL_STATUS_ACTION_DENIED:
164 ChipLogProgress(Zcl, " status: EMBER_ZCL_STATUS_ACTION_DENIED (0x%02x)", status);
166 case EMBER_ZCL_STATUS_TIMEOUT:
167 ChipLogProgress(Zcl, " status: EMBER_ZCL_STATUS_TIMEOUT (0x%02x)", status);
169 case EMBER_ZCL_STATUS_ABORT:
170 ChipLogProgress(Zcl, " status: EMBER_ZCL_STATUS_ABORT (0x%02x)", status);
172 case EMBER_ZCL_STATUS_INVALID_IMAGE:
173 ChipLogProgress(Zcl, " status: EMBER_ZCL_STATUS_INVALID_IMAGE (0x%02x)", status);
175 case EMBER_ZCL_STATUS_WAIT_FOR_DATA:
176 ChipLogProgress(Zcl, " status: EMBER_ZCL_STATUS_WAIT_FOR_DATA (0x%02x)", status);
178 case EMBER_ZCL_STATUS_NO_IMAGE_AVAILABLE:
179 ChipLogProgress(Zcl, " status: EMBER_ZCL_STATUS_NO_IMAGE_AVAILABLE (0x%02x)", status);
181 case EMBER_ZCL_STATUS_REQUIRE_MORE_IMAGE:
182 ChipLogProgress(Zcl, " status: EMBER_ZCL_STATUS_REQUIRE_MORE_IMAGE (0x%02x)", status);
184 case EMBER_ZCL_STATUS_HARDWARE_FAILURE:
185 ChipLogProgress(Zcl, " status: EMBER_ZCL_STATUS_HARDWARE_FAILURE (0x%02x)", status);
187 case EMBER_ZCL_STATUS_SOFTWARE_FAILURE:
188 ChipLogProgress(Zcl, " status: EMBER_ZCL_STATUS_SOFTWARE_FAILURE (0x%02x)", status);
190 case EMBER_ZCL_STATUS_UNSUPPORTED_CLUSTER:
191 ChipLogProgress(Zcl, " status: EMBER_ZCL_STATUS_UNSUPPORTED_CLUSTER (0x%02x)", status);
193 case EMBER_ZCL_STATUS_LIMIT_REACHED:
194 ChipLogProgress(Zcl, " status: EMBER_ZCL_STATUS_LIMIT_REACHED (0x%02x)", status);
197 ChipLogError(Zcl, "Unknow status: 0x%02x", status);
202 // Singleton instance of the callbacks manager
203 app::CHIPDeviceCallbacksMgr & gCallbacks = app::CHIPDeviceCallbacksMgr::GetInstance();
205 bool emberAfDefaultResponseCallback(ClusterId clusterId, CommandId commandId, EmberAfStatus status)
207 ChipLogProgress(Zcl, "DefaultResponse:");
208 ChipLogProgress(Zcl, " ClusterId: 0x%04x", clusterId);
209 ChipLogProgress(Zcl, " CommandId: 0x%02x", commandId);
212 GET_RESPONSE_CALLBACKS("emberAfDefaultResponseCallback");
213 if (status == EMBER_ZCL_STATUS_SUCCESS)
215 Callback::Callback<DefaultSuccessCallback> * cb =
216 Callback::Callback<DefaultSuccessCallback>::FromCancelable(onSuccessCallback);
217 cb->mCall(cb->mContext);
221 Callback::Callback<DefaultFailureCallback> * cb =
222 Callback::Callback<DefaultFailureCallback>::FromCancelable(onFailureCallback);
223 cb->mCall(cb->mContext, static_cast<uint8_t>(status));
229 bool emberAfReadAttributesResponseCallback(ClusterId clusterId, uint8_t * message, uint16_t messageLen)
231 ChipLogProgress(Zcl, "ReadAttributesResponse:");
232 ChipLogProgress(Zcl, " ClusterId: 0x%04x", clusterId);
234 GET_RESPONSE_CALLBACKS("emberAfReadAttributesResponseCallback");
236 // struct readAttributeResponseRecord[]
239 CHECK_MESSAGE_LENGTH(2);
240 uint16_t attributeId = chip::Encoding::LittleEndian::Read16(message); // attribId
241 ChipLogProgress(Zcl, " attributeId: 0x%04x", attributeId);
243 CHECK_MESSAGE_LENGTH(1);
244 uint8_t status = chip::Encoding::Read8(message); // zclStatus
247 if (status == EMBER_ZCL_STATUS_SUCCESS)
249 CHECK_MESSAGE_LENGTH(1);
250 uint8_t attributeType = chip::Encoding::Read8(message);
251 ChipLogProgress(Zcl, " attributeType: 0x%02x", attributeType);
253 switch (attributeType)
255 case 0x00: // nodata / No data
256 case 0x0A: // data24 / 24-bit data
257 case 0x0C: // data40 / 40-bit data
258 case 0x0D: // data48 / 48-bit data
259 case 0x0E: // data56 / 56-bit data
260 case 0x1A: // map24 / 24-bit bitmap
261 case 0x1C: // map40 / 40-bit bitmap
262 case 0x1D: // map48 / 48-bit bitmap
263 case 0x1E: // map56 / 56-bit bitmap
264 case 0x22: // uint24 / Unsigned 24-bit integer
265 case 0x24: // uint40 / Unsigned 40-bit integer
266 case 0x25: // uint48 / Unsigned 48-bit integer
267 case 0x26: // uint56 / Unsigned 56-bit integer
268 case 0x2A: // int24 / Signed 24-bit integer
269 case 0x2C: // int40 / Signed 40-bit integer
270 case 0x2D: // int48 / Signed 48-bit integer
271 case 0x2E: // int56 / Signed 56-bit integer
272 case 0x38: // semi / Semi-precision
273 case 0x39: // single / Single precision
274 case 0x3A: // double / Double precision
275 case 0x48: // array / Array
276 case 0x49: // struct / Structure
277 case 0x50: // set / Set
278 case 0x51: // bag / Bag
279 case 0xE0: // ToD / Time of day
281 ChipLogError(Zcl, "attributeType 0x%02x is not supported", attributeType);
282 Callback::Callback<DefaultFailureCallback> * cb =
283 Callback::Callback<DefaultFailureCallback>::FromCancelable(onFailureCallback);
284 cb->mCall(cb->mContext, EMBER_ZCL_STATUS_INVALID_VALUE);
288 case 0x41: // octstr / Octet string
289 case 0x42: // string / Character string
291 // Short Strings must contains at least one byte for the length
292 CHECK_MESSAGE_LENGTH(1);
293 uint8_t length = chip::Encoding::Read8(message);
294 ChipLogProgress(Zcl, " length: 0x%02x", length);
296 // When the length is set to 0xFF, it represents a non-value. In this case the data field is zero length.
302 CHECK_MESSAGE_LENGTH(length);
303 Callback::Callback<StringAttributeCallback> * cb =
304 Callback::Callback<StringAttributeCallback>::FromCancelable(onSuccessCallback);
305 cb->mCall(cb->mContext, chip::ByteSpan(message, length));
309 case 0x43: // octstr16 / Long octet string
310 case 0x44: // string16 / Long character string
312 // Long Strings must contains at least two bytes for the length
313 CHECK_MESSAGE_LENGTH(2);
314 uint16_t length = chip::Encoding::LittleEndian::Read16(message);
315 ChipLogProgress(Zcl, " length: 0x%02x", length);
317 // When the length is set to 0xFFFF, it represents a non-value. In this case the data field is zero length.
318 if (length == 0xFFFF)
323 CHECK_MESSAGE_LENGTH(length);
324 Callback::Callback<StringAttributeCallback> * cb =
325 Callback::Callback<StringAttributeCallback>::FromCancelable(onSuccessCallback);
326 cb->mCall(cb->mContext, chip::ByteSpan(message, length));
330 case 0x08: // data8 / 8-bit data
331 case 0x18: // map8 / 8-bit bitmap
332 case 0x20: // uint8 / Unsigned 8-bit integer
333 case 0x30: // enum8 / 8-bit enumeration
335 CHECK_MESSAGE_LENGTH(1);
336 uint8_t value = chip::Encoding::Read8(message);
337 ChipLogProgress(Zcl, " value: 0x%02x", value);
339 Callback::Callback<Int8uAttributeCallback> * cb =
340 Callback::Callback<Int8uAttributeCallback>::FromCancelable(onSuccessCallback);
341 cb->mCall(cb->mContext, value);
345 case 0x09: // data16 / 16-bit data
346 case 0x19: // map16 / 16-bit bitmap
347 case 0x21: // uint16 / Unsigned 16-bit integer
348 case 0x31: // enum16 / 16-bit enumeration
349 case 0xE8: // clusterId / Cluster ID
350 case 0xE9: // attribId / Attribute ID
351 case 0xEA: // bacOID / BACnet OID
352 case 0xF1: // key128 / 128-bit security key
353 case 0xFF: // unk / Unknown
355 CHECK_MESSAGE_LENGTH(2);
356 uint16_t value = chip::Encoding::LittleEndian::Read16(message);
357 ChipLogProgress(Zcl, " value: 0x%04x", value);
359 Callback::Callback<Int16uAttributeCallback> * cb =
360 Callback::Callback<Int16uAttributeCallback>::FromCancelable(onSuccessCallback);
361 cb->mCall(cb->mContext, value);
365 case 0x0B: // data32 / 32-bit data
366 case 0x1B: // map32 / 32-bit bitmap
367 case 0x23: // uint32 / Unsigned 32-bit integer
368 case 0xE1: // date / Date
369 case 0xE2: // UTC / UTCTime
371 CHECK_MESSAGE_LENGTH(4);
372 uint32_t value = chip::Encoding::LittleEndian::Read32(message);
373 ChipLogProgress(Zcl, " value: 0x%08x", value);
375 Callback::Callback<Int32uAttributeCallback> * cb =
376 Callback::Callback<Int32uAttributeCallback>::FromCancelable(onSuccessCallback);
377 cb->mCall(cb->mContext, value);
381 case 0x0F: // data64 / 64-bit data
382 case 0x1F: // map64 / 64-bit bitmap
383 case 0x27: // uint64 / Unsigned 64-bit integer
384 case 0xF0: // EUI64 / IEEE address
386 CHECK_MESSAGE_LENGTH(8);
387 uint64_t value = chip::Encoding::LittleEndian::Read64(message);
388 ChipLogProgress(Zcl, " value: 0x%16x", value);
390 Callback::Callback<Int64uAttributeCallback> * cb =
391 Callback::Callback<Int64uAttributeCallback>::FromCancelable(onSuccessCallback);
392 cb->mCall(cb->mContext, value);
396 case 0x10: // bool / Boolean
398 CHECK_MESSAGE_LENGTH(1);
399 uint8_t value = chip::Encoding::Read8(message);
400 ChipLogProgress(Zcl, " value: %d", value);
402 Callback::Callback<BooleanAttributeCallback> * cb =
403 Callback::Callback<BooleanAttributeCallback>::FromCancelable(onSuccessCallback);
404 cb->mCall(cb->mContext, value);
408 case 0x28: // int8 / Signed 8-bit integer
410 CHECK_MESSAGE_LENGTH(1);
411 int8_t value = chip::CastToSigned(chip::Encoding::Read8(message));
412 ChipLogProgress(Zcl, " value: %" PRId8, value);
414 Callback::Callback<Int8sAttributeCallback> * cb =
415 Callback::Callback<Int8sAttributeCallback>::FromCancelable(onSuccessCallback);
416 cb->mCall(cb->mContext, value);
420 case 0x29: // int16 / Signed 16-bit integer
422 CHECK_MESSAGE_LENGTH(2);
423 int16_t value = chip::CastToSigned(chip::Encoding::LittleEndian::Read16(message));
424 ChipLogProgress(Zcl, " value: %" PRId16, value);
426 Callback::Callback<Int16sAttributeCallback> * cb =
427 Callback::Callback<Int16sAttributeCallback>::FromCancelable(onSuccessCallback);
428 cb->mCall(cb->mContext, value);
432 case 0x2B: // int32 / Signed 32-bit integer
434 CHECK_MESSAGE_LENGTH(4);
435 int32_t value = chip::CastToSigned(chip::Encoding::LittleEndian::Read32(message));
436 ChipLogProgress(Zcl, " value: %" PRId32, value);
438 Callback::Callback<Int32sAttributeCallback> * cb =
439 Callback::Callback<Int32sAttributeCallback>::FromCancelable(onSuccessCallback);
440 cb->mCall(cb->mContext, value);
444 case 0x2F: // int64 / Signed 64-bit integer
446 CHECK_MESSAGE_LENGTH(8);
447 int64_t value = chip::CastToSigned(chip::Encoding::LittleEndian::Read64(message));
448 ChipLogProgress(Zcl, " value: %" PRId64, value);
450 Callback::Callback<Int64sAttributeCallback> * cb =
451 Callback::Callback<Int64sAttributeCallback>::FromCancelable(onSuccessCallback);
452 cb->mCall(cb->mContext, value);
459 Callback::Callback<DefaultFailureCallback> * cb =
460 Callback::Callback<DefaultFailureCallback>::FromCancelable(onFailureCallback);
461 cb->mCall(cb->mContext, status);
464 // The current code is written matching the current API where there is a single attribute read
465 // per read command. So if multiple attributes are read at the same time, something is wrong
469 ChipLogError(Zcl, "Multiple attributes read at the same time. Something went wrong.");
477 bool emberAfWriteAttributesResponseCallback(ClusterId clusterId, uint8_t * message, uint16_t messageLen)
479 ChipLogProgress(Zcl, "WriteAttributesResponse:");
480 ChipLogProgress(Zcl, " ClusterId: 0x%04x", clusterId);
482 GET_RESPONSE_CALLBACKS("emberAfWriteAttributesResponseCallback");
484 // struct writeAttributeResponseRecord[]
487 CHECK_MESSAGE_LENGTH(1);
488 uint8_t status = chip::Encoding::Read8(message); // zclStatus
491 if (status == EMBER_ZCL_STATUS_SUCCESS)
493 Callback::Callback<DefaultSuccessCallback> * cb =
494 Callback::Callback<DefaultSuccessCallback>::FromCancelable(onSuccessCallback);
495 cb->mCall(cb->mContext);
499 CHECK_MESSAGE_LENGTH(2);
500 uint16_t attributeId = chip::Encoding::LittleEndian::Read16(message); // attribId
501 ChipLogProgress(Zcl, " attributeId: 0x%04x", attributeId);
503 Callback::Callback<DefaultFailureCallback> * cb =
504 Callback::Callback<DefaultFailureCallback>::FromCancelable(onFailureCallback);
505 cb->mCall(cb->mContext, status);
508 // The current code is written matching the current API where there is a single attribute written
509 // per write command. So if multiple attributes are written at the same time, something is wrong
513 ChipLogError(Zcl, "Multiple attributes written at the same time. Something went wrong.");
521 bool emberAfConfigureReportingResponseCallback(ClusterId clusterId, uint8_t * message, uint16_t messageLen)
523 ChipLogProgress(Zcl, "ConfigureReportingResponseCallback:");
524 ChipLogProgress(Zcl, " ClusterId: 0x%04x", clusterId);
526 GET_RESPONSE_CALLBACKS("emberAfConfigureReportingResponseCallback");
528 // struct configureReportingResponseRecord[]
531 CHECK_MESSAGE_LENGTH(1);
532 uint8_t status = chip::Encoding::Read8(message); // zclStatus
535 if (status == EMBER_ZCL_STATUS_SUCCESS)
537 Callback::Callback<DefaultSuccessCallback> * cb =
538 Callback::Callback<DefaultSuccessCallback>::FromCancelable(onSuccessCallback);
539 cb->mCall(cb->mContext);
543 CHECK_MESSAGE_LENGTH(1);
544 uint8_t direction = chip::Encoding::Read8(message); // reportingRole
545 ChipLogProgress(Zcl, " direction: 0x%02x", direction);
547 CHECK_MESSAGE_LENGTH(2);
548 uint16_t attributeId = chip::Encoding::LittleEndian::Read16(message); // attribId
549 ChipLogProgress(Zcl, " attributeId: 0x%04x", attributeId);
551 Callback::Callback<DefaultFailureCallback> * cb =
552 Callback::Callback<DefaultFailureCallback>::FromCancelable(onFailureCallback);
553 cb->mCall(cb->mContext, status);
556 // The current code is written matching the current API where there is a single attribute report
557 // per configure command. So if multiple attributes are configured at the same time, something is wrong
561 ChipLogError(Zcl, "Multiple attributes reports configured at the same time. Something went wrong.");
569 bool emberAfReadReportingConfigurationResponseCallback(chip::ClusterId clusterId, uint8_t * message, uint16_t messageLen)
571 ChipLogProgress(Zcl, "ReadReportingConfigurationResponse:");
572 ChipLogProgress(Zcl, " ClusterId: 0x%04x", clusterId);
574 GET_RESPONSE_CALLBACKS("emberAfReadReportingConfigurationResponseCallback");
576 // struct readReportingConfigurationResponseRecord[]
579 CHECK_MESSAGE_LENGTH(1);
580 uint8_t direction = chip::Encoding::Read8(message); // reportingRole
581 ChipLogProgress(Zcl, " direction: 0x%02x", direction);
583 CHECK_MESSAGE_LENGTH(2);
584 uint16_t attributeId = chip::Encoding::LittleEndian::Read16(message); // attribId
585 ChipLogProgress(Zcl, " attributeId: 0x%04x", attributeId);
587 if (direction == EMBER_ZCL_REPORTING_DIRECTION_REPORTED)
589 CHECK_MESSAGE_LENGTH(1);
590 uint8_t attributeType = chip::Encoding::Read8(message); // zclType
591 ChipLogProgress(Zcl, " attributeType: 0x%02x", attributeType);
593 CHECK_MESSAGE_LENGTH(2);
594 uint16_t minimumReportingInterval = chip::Encoding::LittleEndian::Read16(message); // uint16
595 ChipLogProgress(Zcl, " minimumReportingInterval: %" PRIu16, minimumReportingInterval);
597 CHECK_MESSAGE_LENGTH(2);
598 uint16_t maximumReportingInterval = chip::Encoding::LittleEndian::Read16(message); // uint16
599 ChipLogProgress(Zcl, " maximumReportingInterval: %" PRIu16, maximumReportingInterval);
601 // FIXME: unk is not supported yet.
603 Callback::Callback<ReadReportingConfigurationReportedCallback> * cb =
604 Callback::Callback<ReadReportingConfigurationReportedCallback>::FromCancelable(onSuccessCallback);
605 cb->mCall(cb->mContext, minimumReportingInterval, maximumReportingInterval);
609 CHECK_MESSAGE_LENGTH(2);
610 uint16_t timeout = chip::Encoding::LittleEndian::Read16(message); // uint16
611 ChipLogProgress(Zcl, " timeout: %" PRIu16, timeout);
613 Callback::Callback<ReadReportingConfigurationReceivedCallback> * cb =
614 Callback::Callback<ReadReportingConfigurationReceivedCallback>::FromCancelable(onSuccessCallback);
615 cb->mCall(cb->mContext, timeout);
622 bool emberAfDiscoverAttributesResponseCallback(ClusterId clusterId, bool discoveryComplete, uint8_t * message, uint16_t messageLen,
625 ChipLogProgress(Zcl, "DiscoverAttributesResponse:");
626 ChipLogProgress(Zcl, " ClusterId: 0x%04x", clusterId);
627 ChipLogProgress(Zcl, " discoveryComplete: %d", discoveryComplete);
628 ChipLogProgress(Zcl, " extended: %d", extended);
630 GET_RESPONSE_CALLBACKS("emberAfDiscoverAttributesCallback");
632 // struct discoverAttributesResponseRecord[]
635 CHECK_MESSAGE_LENGTH(2);
636 uint16_t attributeId = chip::Encoding::LittleEndian::Read16(message); // attribId
637 ChipLogProgress(Zcl, " attributeId: 0x%04x", attributeId);
639 CHECK_MESSAGE_LENGTH(1);
640 uint8_t attributeType = chip::Encoding::Read8(message); // zclType
641 ChipLogProgress(Zcl, " attributeType: 0x%02x", attributeType);
644 Callback::Callback<DefaultSuccessCallback> * cb = Callback::Callback<DefaultSuccessCallback>::FromCancelable(onSuccessCallback);
645 cb->mCall(cb->mContext);
649 bool emberAfDiscoverCommandsGeneratedResponseCallback(ClusterId clusterId, uint16_t manufacturerCode, bool discoveryComplete,
650 CommandId * commandIds, uint16_t commandIdCount)
652 ChipLogProgress(Zcl, "DiscoverCommandsGeneratedResponse:");
653 ChipLogProgress(Zcl, " ClusterId: 0x%04x", clusterId);
654 ChipLogProgress(Zcl, " manufacturerCode: 0x%04x", manufacturerCode);
655 ChipLogProgress(Zcl, " discoveryComplete: %d", discoveryComplete);
656 ChipLogProgress(Zcl, " commandIdCount: %" PRIu16, commandIdCount);
658 for (uint16_t i = 0; i < commandIdCount; i++)
660 ChipLogProgress(Zcl, " commandId: 0x%02x", commandIds++);
663 GET_RESPONSE_CALLBACKS("emberAfDiscoverCommandsGeneratedResponseCallback");
664 Callback::Callback<DefaultSuccessCallback> * cb = Callback::Callback<DefaultSuccessCallback>::FromCancelable(onSuccessCallback);
665 cb->mCall(cb->mContext);
669 bool emberAfDiscoverCommandsReceivedResponseCallback(ClusterId clusterId, uint16_t manufacturerCode, bool discoveryComplete,
670 CommandId * commandIds, uint16_t commandIdCount)
672 ChipLogProgress(Zcl, "DiscoverCommandsReceivedResponse:");
673 ChipLogProgress(Zcl, " ClusterId: 0x%04x", clusterId);
674 ChipLogProgress(Zcl, " manufacturerCode: 0x%04x", manufacturerCode);
675 ChipLogProgress(Zcl, " discoveryComplete: %d", discoveryComplete);
676 ChipLogProgress(Zcl, " commandIdCount: %" PRIu16, commandIdCount);
678 for (uint16_t i = 0; i < commandIdCount; i++)
680 ChipLogProgress(Zcl, " commandId: 0x%02x", commandIds++);
683 GET_RESPONSE_CALLBACKS("emberAfDiscoverCommandsGeneratedResponseCallback");
684 Callback::Callback<DefaultSuccessCallback> * cb = Callback::Callback<DefaultSuccessCallback>::FromCancelable(onSuccessCallback);
685 cb->mCall(cb->mContext);
689 bool emberAfContentLaunchClusterLaunchContentResponseCallback(uint8_t contentLaunchStatus)
691 ChipLogProgress(Zcl, "LaunchContentResponse:");
692 ChipLogProgress(Zcl, " contentLaunchStatus: %" PRIu8 "", contentLaunchStatus);
694 GET_RESPONSE_CALLBACKS("ContentLaunchClusterLaunchContentResponseCallback");
696 Callback::Callback<ContentLaunchClusterLaunchContentResponseCallback> * cb =
697 Callback::Callback<ContentLaunchClusterLaunchContentResponseCallback>::FromCancelable(onSuccessCallback);
698 cb->mCall(cb->mContext, contentLaunchStatus);
702 bool emberAfContentLaunchClusterLaunchURLResponseCallback(uint8_t contentLaunchStatus)
704 ChipLogProgress(Zcl, "LaunchURLResponse:");
705 ChipLogProgress(Zcl, " contentLaunchStatus: %" PRIu8 "", contentLaunchStatus);
707 GET_RESPONSE_CALLBACKS("ContentLaunchClusterLaunchURLResponseCallback");
709 Callback::Callback<ContentLaunchClusterLaunchURLResponseCallback> * cb =
710 Callback::Callback<ContentLaunchClusterLaunchURLResponseCallback>::FromCancelable(onSuccessCallback);
711 cb->mCall(cb->mContext, contentLaunchStatus);
715 bool emberAfDoorLockClusterClearAllPinsResponseCallback(uint8_t status)
717 ChipLogProgress(Zcl, "ClearAllPinsResponse:");
720 GET_RESPONSE_CALLBACKS("DoorLockClusterClearAllPinsResponseCallback");
722 if (status != EMBER_ZCL_STATUS_SUCCESS)
724 Callback::Callback<DefaultFailureCallback> * cb =
725 Callback::Callback<DefaultFailureCallback>::FromCancelable(onFailureCallback);
726 cb->mCall(cb->mContext, status);
730 Callback::Callback<DoorLockClusterClearAllPinsResponseCallback> * cb =
731 Callback::Callback<DoorLockClusterClearAllPinsResponseCallback>::FromCancelable(onSuccessCallback);
732 cb->mCall(cb->mContext);
736 bool emberAfDoorLockClusterClearAllRfidsResponseCallback(uint8_t status)
738 ChipLogProgress(Zcl, "ClearAllRfidsResponse:");
741 GET_RESPONSE_CALLBACKS("DoorLockClusterClearAllRfidsResponseCallback");
743 if (status != EMBER_ZCL_STATUS_SUCCESS)
745 Callback::Callback<DefaultFailureCallback> * cb =
746 Callback::Callback<DefaultFailureCallback>::FromCancelable(onFailureCallback);
747 cb->mCall(cb->mContext, status);
751 Callback::Callback<DoorLockClusterClearAllRfidsResponseCallback> * cb =
752 Callback::Callback<DoorLockClusterClearAllRfidsResponseCallback>::FromCancelable(onSuccessCallback);
753 cb->mCall(cb->mContext);
757 bool emberAfDoorLockClusterClearHolidayScheduleResponseCallback(uint8_t status)
759 ChipLogProgress(Zcl, "ClearHolidayScheduleResponse:");
762 GET_RESPONSE_CALLBACKS("DoorLockClusterClearHolidayScheduleResponseCallback");
764 if (status != EMBER_ZCL_STATUS_SUCCESS)
766 Callback::Callback<DefaultFailureCallback> * cb =
767 Callback::Callback<DefaultFailureCallback>::FromCancelable(onFailureCallback);
768 cb->mCall(cb->mContext, status);
772 Callback::Callback<DoorLockClusterClearHolidayScheduleResponseCallback> * cb =
773 Callback::Callback<DoorLockClusterClearHolidayScheduleResponseCallback>::FromCancelable(onSuccessCallback);
774 cb->mCall(cb->mContext);
778 bool emberAfDoorLockClusterClearPinResponseCallback(uint8_t status)
780 ChipLogProgress(Zcl, "ClearPinResponse:");
783 GET_RESPONSE_CALLBACKS("DoorLockClusterClearPinResponseCallback");
785 if (status != EMBER_ZCL_STATUS_SUCCESS)
787 Callback::Callback<DefaultFailureCallback> * cb =
788 Callback::Callback<DefaultFailureCallback>::FromCancelable(onFailureCallback);
789 cb->mCall(cb->mContext, status);
793 Callback::Callback<DoorLockClusterClearPinResponseCallback> * cb =
794 Callback::Callback<DoorLockClusterClearPinResponseCallback>::FromCancelable(onSuccessCallback);
795 cb->mCall(cb->mContext);
799 bool emberAfDoorLockClusterClearRfidResponseCallback(uint8_t status)
801 ChipLogProgress(Zcl, "ClearRfidResponse:");
804 GET_RESPONSE_CALLBACKS("DoorLockClusterClearRfidResponseCallback");
806 if (status != EMBER_ZCL_STATUS_SUCCESS)
808 Callback::Callback<DefaultFailureCallback> * cb =
809 Callback::Callback<DefaultFailureCallback>::FromCancelable(onFailureCallback);
810 cb->mCall(cb->mContext, status);
814 Callback::Callback<DoorLockClusterClearRfidResponseCallback> * cb =
815 Callback::Callback<DoorLockClusterClearRfidResponseCallback>::FromCancelable(onSuccessCallback);
816 cb->mCall(cb->mContext);
820 bool emberAfDoorLockClusterClearWeekdayScheduleResponseCallback(uint8_t status)
822 ChipLogProgress(Zcl, "ClearWeekdayScheduleResponse:");
825 GET_RESPONSE_CALLBACKS("DoorLockClusterClearWeekdayScheduleResponseCallback");
827 if (status != EMBER_ZCL_STATUS_SUCCESS)
829 Callback::Callback<DefaultFailureCallback> * cb =
830 Callback::Callback<DefaultFailureCallback>::FromCancelable(onFailureCallback);
831 cb->mCall(cb->mContext, status);
835 Callback::Callback<DoorLockClusterClearWeekdayScheduleResponseCallback> * cb =
836 Callback::Callback<DoorLockClusterClearWeekdayScheduleResponseCallback>::FromCancelable(onSuccessCallback);
837 cb->mCall(cb->mContext);
841 bool emberAfDoorLockClusterClearYeardayScheduleResponseCallback(uint8_t status)
843 ChipLogProgress(Zcl, "ClearYeardayScheduleResponse:");
846 GET_RESPONSE_CALLBACKS("DoorLockClusterClearYeardayScheduleResponseCallback");
848 if (status != EMBER_ZCL_STATUS_SUCCESS)
850 Callback::Callback<DefaultFailureCallback> * cb =
851 Callback::Callback<DefaultFailureCallback>::FromCancelable(onFailureCallback);
852 cb->mCall(cb->mContext, status);
856 Callback::Callback<DoorLockClusterClearYeardayScheduleResponseCallback> * cb =
857 Callback::Callback<DoorLockClusterClearYeardayScheduleResponseCallback>::FromCancelable(onSuccessCallback);
858 cb->mCall(cb->mContext);
862 bool emberAfDoorLockClusterGetHolidayScheduleResponseCallback(uint8_t scheduleId, uint8_t status, uint32_t localStartTime,
863 uint32_t localEndTime, uint8_t operatingModeDuringHoliday)
865 ChipLogProgress(Zcl, "GetHolidayScheduleResponse:");
866 ChipLogProgress(Zcl, " scheduleId: %" PRIu8 "", scheduleId);
868 ChipLogProgress(Zcl, " localStartTime: %" PRIu32 "", localStartTime);
869 ChipLogProgress(Zcl, " localEndTime: %" PRIu32 "", localEndTime);
870 ChipLogProgress(Zcl, " operatingModeDuringHoliday: %" PRIu8 "", operatingModeDuringHoliday);
872 GET_RESPONSE_CALLBACKS("DoorLockClusterGetHolidayScheduleResponseCallback");
874 if (status != EMBER_ZCL_STATUS_SUCCESS)
876 Callback::Callback<DefaultFailureCallback> * cb =
877 Callback::Callback<DefaultFailureCallback>::FromCancelable(onFailureCallback);
878 cb->mCall(cb->mContext, status);
882 Callback::Callback<DoorLockClusterGetHolidayScheduleResponseCallback> * cb =
883 Callback::Callback<DoorLockClusterGetHolidayScheduleResponseCallback>::FromCancelable(onSuccessCallback);
884 cb->mCall(cb->mContext, scheduleId, localStartTime, localEndTime, operatingModeDuringHoliday);
888 bool emberAfDoorLockClusterGetLogRecordResponseCallback(uint16_t logEntryId, uint32_t timestamp, uint8_t eventType, uint8_t source,
889 uint8_t eventIdOrAlarmCode, uint16_t userId, uint8_t * pin)
891 ChipLogProgress(Zcl, "GetLogRecordResponse:");
892 ChipLogProgress(Zcl, " logEntryId: %" PRIu16 "", logEntryId);
893 ChipLogProgress(Zcl, " timestamp: %" PRIu32 "", timestamp);
894 ChipLogProgress(Zcl, " eventType: %" PRIu8 "", eventType);
895 ChipLogProgress(Zcl, " source: %" PRIu8 "", source);
896 ChipLogProgress(Zcl, " eventIdOrAlarmCode: %" PRIu8 "", eventIdOrAlarmCode);
897 ChipLogProgress(Zcl, " userId: %" PRIu16 "", userId);
898 ChipLogProgress(Zcl, " pin: %s", pin);
900 GET_RESPONSE_CALLBACKS("DoorLockClusterGetLogRecordResponseCallback");
902 Callback::Callback<DoorLockClusterGetLogRecordResponseCallback> * cb =
903 Callback::Callback<DoorLockClusterGetLogRecordResponseCallback>::FromCancelable(onSuccessCallback);
904 cb->mCall(cb->mContext, logEntryId, timestamp, eventType, source, eventIdOrAlarmCode, userId, pin);
908 bool emberAfDoorLockClusterGetPinResponseCallback(uint16_t userId, uint8_t userStatus, uint8_t userType, uint8_t * pin)
910 ChipLogProgress(Zcl, "GetPinResponse:");
911 ChipLogProgress(Zcl, " userId: %" PRIu16 "", userId);
912 ChipLogProgress(Zcl, " userStatus: %" PRIu8 "", userStatus);
913 ChipLogProgress(Zcl, " userType: %" PRIu8 "", userType);
914 ChipLogProgress(Zcl, " pin: %s", pin);
916 GET_RESPONSE_CALLBACKS("DoorLockClusterGetPinResponseCallback");
918 Callback::Callback<DoorLockClusterGetPinResponseCallback> * cb =
919 Callback::Callback<DoorLockClusterGetPinResponseCallback>::FromCancelable(onSuccessCallback);
920 cb->mCall(cb->mContext, userId, userStatus, userType, pin);
924 bool emberAfDoorLockClusterGetRfidResponseCallback(uint16_t userId, uint8_t userStatus, uint8_t userType, uint8_t * rfid)
926 ChipLogProgress(Zcl, "GetRfidResponse:");
927 ChipLogProgress(Zcl, " userId: %" PRIu16 "", userId);
928 ChipLogProgress(Zcl, " userStatus: %" PRIu8 "", userStatus);
929 ChipLogProgress(Zcl, " userType: %" PRIu8 "", userType);
930 ChipLogProgress(Zcl, " rfid: %s", rfid);
932 GET_RESPONSE_CALLBACKS("DoorLockClusterGetRfidResponseCallback");
934 Callback::Callback<DoorLockClusterGetRfidResponseCallback> * cb =
935 Callback::Callback<DoorLockClusterGetRfidResponseCallback>::FromCancelable(onSuccessCallback);
936 cb->mCall(cb->mContext, userId, userStatus, userType, rfid);
940 bool emberAfDoorLockClusterGetUserTypeResponseCallback(uint16_t userId, uint8_t userType)
942 ChipLogProgress(Zcl, "GetUserTypeResponse:");
943 ChipLogProgress(Zcl, " userId: %" PRIu16 "", userId);
944 ChipLogProgress(Zcl, " userType: %" PRIu8 "", userType);
946 GET_RESPONSE_CALLBACKS("DoorLockClusterGetUserTypeResponseCallback");
948 Callback::Callback<DoorLockClusterGetUserTypeResponseCallback> * cb =
949 Callback::Callback<DoorLockClusterGetUserTypeResponseCallback>::FromCancelable(onSuccessCallback);
950 cb->mCall(cb->mContext, userId, userType);
954 bool emberAfDoorLockClusterGetWeekdayScheduleResponseCallback(uint8_t scheduleId, uint16_t userId, uint8_t status, uint8_t daysMask,
955 uint8_t startHour, uint8_t startMinute, uint8_t endHour,
958 ChipLogProgress(Zcl, "GetWeekdayScheduleResponse:");
959 ChipLogProgress(Zcl, " scheduleId: %" PRIu8 "", scheduleId);
960 ChipLogProgress(Zcl, " userId: %" PRIu16 "", userId);
962 ChipLogProgress(Zcl, " daysMask: %" PRIu8 "", daysMask);
963 ChipLogProgress(Zcl, " startHour: %" PRIu8 "", startHour);
964 ChipLogProgress(Zcl, " startMinute: %" PRIu8 "", startMinute);
965 ChipLogProgress(Zcl, " endHour: %" PRIu8 "", endHour);
966 ChipLogProgress(Zcl, " endMinute: %" PRIu8 "", endMinute);
968 GET_RESPONSE_CALLBACKS("DoorLockClusterGetWeekdayScheduleResponseCallback");
970 if (status != EMBER_ZCL_STATUS_SUCCESS)
972 Callback::Callback<DefaultFailureCallback> * cb =
973 Callback::Callback<DefaultFailureCallback>::FromCancelable(onFailureCallback);
974 cb->mCall(cb->mContext, status);
978 Callback::Callback<DoorLockClusterGetWeekdayScheduleResponseCallback> * cb =
979 Callback::Callback<DoorLockClusterGetWeekdayScheduleResponseCallback>::FromCancelable(onSuccessCallback);
980 cb->mCall(cb->mContext, scheduleId, userId, daysMask, startHour, startMinute, endHour, endMinute);
984 bool emberAfDoorLockClusterGetYeardayScheduleResponseCallback(uint8_t scheduleId, uint16_t userId, uint8_t status,
985 uint32_t localStartTime, uint32_t localEndTime)
987 ChipLogProgress(Zcl, "GetYeardayScheduleResponse:");
988 ChipLogProgress(Zcl, " scheduleId: %" PRIu8 "", scheduleId);
989 ChipLogProgress(Zcl, " userId: %" PRIu16 "", userId);
991 ChipLogProgress(Zcl, " localStartTime: %" PRIu32 "", localStartTime);
992 ChipLogProgress(Zcl, " localEndTime: %" PRIu32 "", localEndTime);
994 GET_RESPONSE_CALLBACKS("DoorLockClusterGetYeardayScheduleResponseCallback");
996 if (status != EMBER_ZCL_STATUS_SUCCESS)
998 Callback::Callback<DefaultFailureCallback> * cb =
999 Callback::Callback<DefaultFailureCallback>::FromCancelable(onFailureCallback);
1000 cb->mCall(cb->mContext, status);
1004 Callback::Callback<DoorLockClusterGetYeardayScheduleResponseCallback> * cb =
1005 Callback::Callback<DoorLockClusterGetYeardayScheduleResponseCallback>::FromCancelable(onSuccessCallback);
1006 cb->mCall(cb->mContext, scheduleId, userId, localStartTime, localEndTime);
1010 bool emberAfDoorLockClusterLockDoorResponseCallback(uint8_t status)
1012 ChipLogProgress(Zcl, "LockDoorResponse:");
1015 GET_RESPONSE_CALLBACKS("DoorLockClusterLockDoorResponseCallback");
1017 if (status != EMBER_ZCL_STATUS_SUCCESS)
1019 Callback::Callback<DefaultFailureCallback> * cb =
1020 Callback::Callback<DefaultFailureCallback>::FromCancelable(onFailureCallback);
1021 cb->mCall(cb->mContext, status);
1025 Callback::Callback<DoorLockClusterLockDoorResponseCallback> * cb =
1026 Callback::Callback<DoorLockClusterLockDoorResponseCallback>::FromCancelable(onSuccessCallback);
1027 cb->mCall(cb->mContext);
1031 bool emberAfDoorLockClusterSetHolidayScheduleResponseCallback(uint8_t status)
1033 ChipLogProgress(Zcl, "SetHolidayScheduleResponse:");
1036 GET_RESPONSE_CALLBACKS("DoorLockClusterSetHolidayScheduleResponseCallback");
1038 if (status != EMBER_ZCL_STATUS_SUCCESS)
1040 Callback::Callback<DefaultFailureCallback> * cb =
1041 Callback::Callback<DefaultFailureCallback>::FromCancelable(onFailureCallback);
1042 cb->mCall(cb->mContext, status);
1046 Callback::Callback<DoorLockClusterSetHolidayScheduleResponseCallback> * cb =
1047 Callback::Callback<DoorLockClusterSetHolidayScheduleResponseCallback>::FromCancelable(onSuccessCallback);
1048 cb->mCall(cb->mContext);
1052 bool emberAfDoorLockClusterSetPinResponseCallback(uint8_t status)
1054 ChipLogProgress(Zcl, "SetPinResponse:");
1057 GET_RESPONSE_CALLBACKS("DoorLockClusterSetPinResponseCallback");
1059 if (status != EMBER_ZCL_STATUS_SUCCESS)
1061 Callback::Callback<DefaultFailureCallback> * cb =
1062 Callback::Callback<DefaultFailureCallback>::FromCancelable(onFailureCallback);
1063 cb->mCall(cb->mContext, status);
1067 Callback::Callback<DoorLockClusterSetPinResponseCallback> * cb =
1068 Callback::Callback<DoorLockClusterSetPinResponseCallback>::FromCancelable(onSuccessCallback);
1069 cb->mCall(cb->mContext);
1073 bool emberAfDoorLockClusterSetRfidResponseCallback(uint8_t status)
1075 ChipLogProgress(Zcl, "SetRfidResponse:");
1078 GET_RESPONSE_CALLBACKS("DoorLockClusterSetRfidResponseCallback");
1080 if (status != EMBER_ZCL_STATUS_SUCCESS)
1082 Callback::Callback<DefaultFailureCallback> * cb =
1083 Callback::Callback<DefaultFailureCallback>::FromCancelable(onFailureCallback);
1084 cb->mCall(cb->mContext, status);
1088 Callback::Callback<DoorLockClusterSetRfidResponseCallback> * cb =
1089 Callback::Callback<DoorLockClusterSetRfidResponseCallback>::FromCancelable(onSuccessCallback);
1090 cb->mCall(cb->mContext);
1094 bool emberAfDoorLockClusterSetUserTypeResponseCallback(uint8_t status)
1096 ChipLogProgress(Zcl, "SetUserTypeResponse:");
1099 GET_RESPONSE_CALLBACKS("DoorLockClusterSetUserTypeResponseCallback");
1101 if (status != EMBER_ZCL_STATUS_SUCCESS)
1103 Callback::Callback<DefaultFailureCallback> * cb =
1104 Callback::Callback<DefaultFailureCallback>::FromCancelable(onFailureCallback);
1105 cb->mCall(cb->mContext, status);
1109 Callback::Callback<DoorLockClusterSetUserTypeResponseCallback> * cb =
1110 Callback::Callback<DoorLockClusterSetUserTypeResponseCallback>::FromCancelable(onSuccessCallback);
1111 cb->mCall(cb->mContext);
1115 bool emberAfDoorLockClusterSetWeekdayScheduleResponseCallback(uint8_t status)
1117 ChipLogProgress(Zcl, "SetWeekdayScheduleResponse:");
1120 GET_RESPONSE_CALLBACKS("DoorLockClusterSetWeekdayScheduleResponseCallback");
1122 if (status != EMBER_ZCL_STATUS_SUCCESS)
1124 Callback::Callback<DefaultFailureCallback> * cb =
1125 Callback::Callback<DefaultFailureCallback>::FromCancelable(onFailureCallback);
1126 cb->mCall(cb->mContext, status);
1130 Callback::Callback<DoorLockClusterSetWeekdayScheduleResponseCallback> * cb =
1131 Callback::Callback<DoorLockClusterSetWeekdayScheduleResponseCallback>::FromCancelable(onSuccessCallback);
1132 cb->mCall(cb->mContext);
1136 bool emberAfDoorLockClusterSetYeardayScheduleResponseCallback(uint8_t status)
1138 ChipLogProgress(Zcl, "SetYeardayScheduleResponse:");
1141 GET_RESPONSE_CALLBACKS("DoorLockClusterSetYeardayScheduleResponseCallback");
1143 if (status != EMBER_ZCL_STATUS_SUCCESS)
1145 Callback::Callback<DefaultFailureCallback> * cb =
1146 Callback::Callback<DefaultFailureCallback>::FromCancelable(onFailureCallback);
1147 cb->mCall(cb->mContext, status);
1151 Callback::Callback<DoorLockClusterSetYeardayScheduleResponseCallback> * cb =
1152 Callback::Callback<DoorLockClusterSetYeardayScheduleResponseCallback>::FromCancelable(onSuccessCallback);
1153 cb->mCall(cb->mContext);
1157 bool emberAfDoorLockClusterUnlockDoorResponseCallback(uint8_t status)
1159 ChipLogProgress(Zcl, "UnlockDoorResponse:");
1162 GET_RESPONSE_CALLBACKS("DoorLockClusterUnlockDoorResponseCallback");
1164 if (status != EMBER_ZCL_STATUS_SUCCESS)
1166 Callback::Callback<DefaultFailureCallback> * cb =
1167 Callback::Callback<DefaultFailureCallback>::FromCancelable(onFailureCallback);
1168 cb->mCall(cb->mContext, status);
1172 Callback::Callback<DoorLockClusterUnlockDoorResponseCallback> * cb =
1173 Callback::Callback<DoorLockClusterUnlockDoorResponseCallback>::FromCancelable(onSuccessCallback);
1174 cb->mCall(cb->mContext);
1178 bool emberAfDoorLockClusterUnlockWithTimeoutResponseCallback(uint8_t status)
1180 ChipLogProgress(Zcl, "UnlockWithTimeoutResponse:");
1183 GET_RESPONSE_CALLBACKS("DoorLockClusterUnlockWithTimeoutResponseCallback");
1185 if (status != EMBER_ZCL_STATUS_SUCCESS)
1187 Callback::Callback<DefaultFailureCallback> * cb =
1188 Callback::Callback<DefaultFailureCallback>::FromCancelable(onFailureCallback);
1189 cb->mCall(cb->mContext, status);
1193 Callback::Callback<DoorLockClusterUnlockWithTimeoutResponseCallback> * cb =
1194 Callback::Callback<DoorLockClusterUnlockWithTimeoutResponseCallback>::FromCancelable(onSuccessCallback);
1195 cb->mCall(cb->mContext);
1199 bool emberAfGeneralCommissioningClusterArmFailSafeResponseCallback(uint8_t errorCode, uint8_t * debugText)
1201 ChipLogProgress(Zcl, "ArmFailSafeResponse:");
1202 ChipLogProgress(Zcl, " errorCode: %" PRIu8 "", errorCode);
1203 ChipLogProgress(Zcl, " debugText: %s", debugText);
1205 GET_RESPONSE_CALLBACKS("GeneralCommissioningClusterArmFailSafeResponseCallback");
1207 Callback::Callback<GeneralCommissioningClusterArmFailSafeResponseCallback> * cb =
1208 Callback::Callback<GeneralCommissioningClusterArmFailSafeResponseCallback>::FromCancelable(onSuccessCallback);
1209 cb->mCall(cb->mContext, errorCode, debugText);
1213 bool emberAfGeneralCommissioningClusterCommissioningCompleteResponseCallback(uint8_t errorCode, uint8_t * debugText)
1215 ChipLogProgress(Zcl, "CommissioningCompleteResponse:");
1216 ChipLogProgress(Zcl, " errorCode: %" PRIu8 "", errorCode);
1217 ChipLogProgress(Zcl, " debugText: %s", debugText);
1219 GET_RESPONSE_CALLBACKS("GeneralCommissioningClusterCommissioningCompleteResponseCallback");
1221 Callback::Callback<GeneralCommissioningClusterCommissioningCompleteResponseCallback> * cb =
1222 Callback::Callback<GeneralCommissioningClusterCommissioningCompleteResponseCallback>::FromCancelable(onSuccessCallback);
1223 cb->mCall(cb->mContext, errorCode, debugText);
1227 bool emberAfGeneralCommissioningClusterSetFabricResponseCallback(uint8_t errorCode, uint8_t * debugText)
1229 ChipLogProgress(Zcl, "SetFabricResponse:");
1230 ChipLogProgress(Zcl, " errorCode: %" PRIu8 "", errorCode);
1231 ChipLogProgress(Zcl, " debugText: %s", debugText);
1233 GET_RESPONSE_CALLBACKS("GeneralCommissioningClusterSetFabricResponseCallback");
1235 Callback::Callback<GeneralCommissioningClusterSetFabricResponseCallback> * cb =
1236 Callback::Callback<GeneralCommissioningClusterSetFabricResponseCallback>::FromCancelable(onSuccessCallback);
1237 cb->mCall(cb->mContext, errorCode, debugText);
1241 bool emberAfGroupsClusterAddGroupResponseCallback(uint8_t status, uint16_t groupId)
1243 ChipLogProgress(Zcl, "AddGroupResponse:");
1245 ChipLogProgress(Zcl, " groupId: %" PRIu16 "", groupId);
1247 GET_RESPONSE_CALLBACKS("GroupsClusterAddGroupResponseCallback");
1249 if (status != EMBER_ZCL_STATUS_SUCCESS)
1251 Callback::Callback<DefaultFailureCallback> * cb =
1252 Callback::Callback<DefaultFailureCallback>::FromCancelable(onFailureCallback);
1253 cb->mCall(cb->mContext, status);
1257 Callback::Callback<GroupsClusterAddGroupResponseCallback> * cb =
1258 Callback::Callback<GroupsClusterAddGroupResponseCallback>::FromCancelable(onSuccessCallback);
1259 cb->mCall(cb->mContext, groupId);
1263 bool emberAfGroupsClusterGetGroupMembershipResponseCallback(uint8_t capacity, uint8_t groupCount,
1264 /* TYPE WARNING: array array defaults to */ uint8_t * groupList)
1266 ChipLogProgress(Zcl, "GetGroupMembershipResponse:");
1267 ChipLogProgress(Zcl, " capacity: %" PRIu8 "", capacity);
1268 ChipLogProgress(Zcl, " groupCount: %" PRIu8 "", groupCount);
1269 ChipLogProgress(Zcl, " groupList: %p", groupList);
1271 GET_RESPONSE_CALLBACKS("GroupsClusterGetGroupMembershipResponseCallback");
1273 Callback::Callback<GroupsClusterGetGroupMembershipResponseCallback> * cb =
1274 Callback::Callback<GroupsClusterGetGroupMembershipResponseCallback>::FromCancelable(onSuccessCallback);
1275 cb->mCall(cb->mContext, capacity, groupCount, groupList);
1279 bool emberAfGroupsClusterRemoveGroupResponseCallback(uint8_t status, uint16_t groupId)
1281 ChipLogProgress(Zcl, "RemoveGroupResponse:");
1283 ChipLogProgress(Zcl, " groupId: %" PRIu16 "", groupId);
1285 GET_RESPONSE_CALLBACKS("GroupsClusterRemoveGroupResponseCallback");
1287 if (status != EMBER_ZCL_STATUS_SUCCESS)
1289 Callback::Callback<DefaultFailureCallback> * cb =
1290 Callback::Callback<DefaultFailureCallback>::FromCancelable(onFailureCallback);
1291 cb->mCall(cb->mContext, status);
1295 Callback::Callback<GroupsClusterRemoveGroupResponseCallback> * cb =
1296 Callback::Callback<GroupsClusterRemoveGroupResponseCallback>::FromCancelable(onSuccessCallback);
1297 cb->mCall(cb->mContext, groupId);
1301 bool emberAfGroupsClusterViewGroupResponseCallback(uint8_t status, uint16_t groupId, uint8_t * groupName)
1303 ChipLogProgress(Zcl, "ViewGroupResponse:");
1305 ChipLogProgress(Zcl, " groupId: %" PRIu16 "", groupId);
1306 ChipLogProgress(Zcl, " groupName: %s", groupName);
1308 GET_RESPONSE_CALLBACKS("GroupsClusterViewGroupResponseCallback");
1310 if (status != EMBER_ZCL_STATUS_SUCCESS)
1312 Callback::Callback<DefaultFailureCallback> * cb =
1313 Callback::Callback<DefaultFailureCallback>::FromCancelable(onFailureCallback);
1314 cb->mCall(cb->mContext, status);
1318 Callback::Callback<GroupsClusterViewGroupResponseCallback> * cb =
1319 Callback::Callback<GroupsClusterViewGroupResponseCallback>::FromCancelable(onSuccessCallback);
1320 cb->mCall(cb->mContext, groupId, groupName);
1324 bool emberAfIdentifyClusterIdentifyQueryResponseCallback(uint16_t timeout)
1326 ChipLogProgress(Zcl, "IdentifyQueryResponse:");
1327 ChipLogProgress(Zcl, " timeout: %" PRIu16 "", timeout);
1329 GET_RESPONSE_CALLBACKS("IdentifyClusterIdentifyQueryResponseCallback");
1331 Callback::Callback<IdentifyClusterIdentifyQueryResponseCallback> * cb =
1332 Callback::Callback<IdentifyClusterIdentifyQueryResponseCallback>::FromCancelable(onSuccessCallback);
1333 cb->mCall(cb->mContext, timeout);
1337 bool emberAfScenesClusterAddSceneResponseCallback(uint8_t status, uint16_t groupId, uint8_t sceneId)
1339 ChipLogProgress(Zcl, "AddSceneResponse:");
1341 ChipLogProgress(Zcl, " groupId: %" PRIu16 "", groupId);
1342 ChipLogProgress(Zcl, " sceneId: %" PRIu8 "", sceneId);
1344 GET_RESPONSE_CALLBACKS("ScenesClusterAddSceneResponseCallback");
1346 if (status != EMBER_ZCL_STATUS_SUCCESS)
1348 Callback::Callback<DefaultFailureCallback> * cb =
1349 Callback::Callback<DefaultFailureCallback>::FromCancelable(onFailureCallback);
1350 cb->mCall(cb->mContext, status);
1354 Callback::Callback<ScenesClusterAddSceneResponseCallback> * cb =
1355 Callback::Callback<ScenesClusterAddSceneResponseCallback>::FromCancelable(onSuccessCallback);
1356 cb->mCall(cb->mContext, groupId, sceneId);
1360 bool emberAfScenesClusterGetSceneMembershipResponseCallback(uint8_t status, uint8_t capacity, uint16_t groupId, uint8_t sceneCount,
1361 /* TYPE WARNING: array array defaults to */ uint8_t * sceneList)
1363 ChipLogProgress(Zcl, "GetSceneMembershipResponse:");
1365 ChipLogProgress(Zcl, " capacity: %" PRIu8 "", capacity);
1366 ChipLogProgress(Zcl, " groupId: %" PRIu16 "", groupId);
1367 ChipLogProgress(Zcl, " sceneCount: %" PRIu8 "", sceneCount);
1368 ChipLogProgress(Zcl, " sceneList: %p", sceneList);
1370 GET_RESPONSE_CALLBACKS("ScenesClusterGetSceneMembershipResponseCallback");
1372 if (status != EMBER_ZCL_STATUS_SUCCESS)
1374 Callback::Callback<DefaultFailureCallback> * cb =
1375 Callback::Callback<DefaultFailureCallback>::FromCancelable(onFailureCallback);
1376 cb->mCall(cb->mContext, status);
1380 Callback::Callback<ScenesClusterGetSceneMembershipResponseCallback> * cb =
1381 Callback::Callback<ScenesClusterGetSceneMembershipResponseCallback>::FromCancelable(onSuccessCallback);
1382 cb->mCall(cb->mContext, capacity, groupId, sceneCount, sceneList);
1386 bool emberAfScenesClusterRemoveAllScenesResponseCallback(uint8_t status, uint16_t groupId)
1388 ChipLogProgress(Zcl, "RemoveAllScenesResponse:");
1390 ChipLogProgress(Zcl, " groupId: %" PRIu16 "", groupId);
1392 GET_RESPONSE_CALLBACKS("ScenesClusterRemoveAllScenesResponseCallback");
1394 if (status != EMBER_ZCL_STATUS_SUCCESS)
1396 Callback::Callback<DefaultFailureCallback> * cb =
1397 Callback::Callback<DefaultFailureCallback>::FromCancelable(onFailureCallback);
1398 cb->mCall(cb->mContext, status);
1402 Callback::Callback<ScenesClusterRemoveAllScenesResponseCallback> * cb =
1403 Callback::Callback<ScenesClusterRemoveAllScenesResponseCallback>::FromCancelable(onSuccessCallback);
1404 cb->mCall(cb->mContext, groupId);
1408 bool emberAfScenesClusterRemoveSceneResponseCallback(uint8_t status, uint16_t groupId, uint8_t sceneId)
1410 ChipLogProgress(Zcl, "RemoveSceneResponse:");
1412 ChipLogProgress(Zcl, " groupId: %" PRIu16 "", groupId);
1413 ChipLogProgress(Zcl, " sceneId: %" PRIu8 "", sceneId);
1415 GET_RESPONSE_CALLBACKS("ScenesClusterRemoveSceneResponseCallback");
1417 if (status != EMBER_ZCL_STATUS_SUCCESS)
1419 Callback::Callback<DefaultFailureCallback> * cb =
1420 Callback::Callback<DefaultFailureCallback>::FromCancelable(onFailureCallback);
1421 cb->mCall(cb->mContext, status);
1425 Callback::Callback<ScenesClusterRemoveSceneResponseCallback> * cb =
1426 Callback::Callback<ScenesClusterRemoveSceneResponseCallback>::FromCancelable(onSuccessCallback);
1427 cb->mCall(cb->mContext, groupId, sceneId);
1431 bool emberAfScenesClusterStoreSceneResponseCallback(uint8_t status, uint16_t groupId, uint8_t sceneId)
1433 ChipLogProgress(Zcl, "StoreSceneResponse:");
1435 ChipLogProgress(Zcl, " groupId: %" PRIu16 "", groupId);
1436 ChipLogProgress(Zcl, " sceneId: %" PRIu8 "", sceneId);
1438 GET_RESPONSE_CALLBACKS("ScenesClusterStoreSceneResponseCallback");
1440 if (status != EMBER_ZCL_STATUS_SUCCESS)
1442 Callback::Callback<DefaultFailureCallback> * cb =
1443 Callback::Callback<DefaultFailureCallback>::FromCancelable(onFailureCallback);
1444 cb->mCall(cb->mContext, status);
1448 Callback::Callback<ScenesClusterStoreSceneResponseCallback> * cb =
1449 Callback::Callback<ScenesClusterStoreSceneResponseCallback>::FromCancelable(onSuccessCallback);
1450 cb->mCall(cb->mContext, groupId, sceneId);
1454 bool emberAfScenesClusterViewSceneResponseCallback(uint8_t status, uint16_t groupId, uint8_t sceneId, uint16_t transitionTime,
1455 uint8_t * sceneName,
1456 /* TYPE WARNING: array array defaults to */ uint8_t * extensionFieldSets)
1458 ChipLogProgress(Zcl, "ViewSceneResponse:");
1460 ChipLogProgress(Zcl, " groupId: %" PRIu16 "", groupId);
1461 ChipLogProgress(Zcl, " sceneId: %" PRIu8 "", sceneId);
1462 ChipLogProgress(Zcl, " transitionTime: %" PRIu16 "", transitionTime);
1463 ChipLogProgress(Zcl, " sceneName: %s", sceneName);
1464 ChipLogProgress(Zcl, " extensionFieldSets: %p", extensionFieldSets);
1466 GET_RESPONSE_CALLBACKS("ScenesClusterViewSceneResponseCallback");
1468 if (status != EMBER_ZCL_STATUS_SUCCESS)
1470 Callback::Callback<DefaultFailureCallback> * cb =
1471 Callback::Callback<DefaultFailureCallback>::FromCancelable(onFailureCallback);
1472 cb->mCall(cb->mContext, status);
1476 Callback::Callback<ScenesClusterViewSceneResponseCallback> * cb =
1477 Callback::Callback<ScenesClusterViewSceneResponseCallback>::FromCancelable(onSuccessCallback);
1478 cb->mCall(cb->mContext, groupId, sceneId, transitionTime, sceneName, extensionFieldSets);
1482 bool emberAfReportAttributesCallback(ClusterId clusterId, uint8_t * message, uint16_t messageLen)
1484 ChipLogProgress(Zcl, "emberAfReportAttributeCallback:");
1485 ChipLogProgress(Zcl, " ClusterId: 0x%04x", clusterId);
1487 NodeId sourceId = emberAfCurrentCommand()->source;
1488 ChipLogProgress(Zcl, " Source NodeId: %" PRIu64, sourceId);
1490 EndpointId endpointId = emberAfCurrentCommand()->apsFrame->sourceEndpoint;
1491 ChipLogProgress(Zcl, " Source EndpointId: 0x%04x", endpointId);
1493 // TODO onFailureCallback is just here because of the CHECK_MESSAGE_LENGTH macro. It needs to be removed.
1494 Callback::Cancelable * onFailureCallback = nullptr;
1498 CHECK_MESSAGE_LENGTH(2);
1499 uint16_t attributeId = chip::Encoding::LittleEndian::Read16(message); // attribId
1500 ChipLogProgress(Zcl, " attributeId: 0x%04x", attributeId);
1502 GET_REPORT_CALLBACK("emberAfReportAttributesCallback");
1504 CHECK_MESSAGE_LENGTH(1);
1505 uint8_t attributeType = chip::Encoding::Read8(message);
1506 ChipLogProgress(Zcl, " attributeType: 0x%02x", attributeType);
1508 switch (attributeType)
1510 case 0x00: // nodata / No data
1511 case 0x0A: // data24 / 24-bit data
1512 case 0x0C: // data40 / 40-bit data
1513 case 0x0D: // data48 / 48-bit data
1514 case 0x0E: // data56 / 56-bit data
1515 case 0x1A: // map24 / 24-bit bitmap
1516 case 0x1C: // map40 / 40-bit bitmap
1517 case 0x1D: // map48 / 48-bit bitmap
1518 case 0x1E: // map56 / 56-bit bitmap
1519 case 0x22: // uint24 / Unsigned 24-bit integer
1520 case 0x24: // uint40 / Unsigned 40-bit integer
1521 case 0x25: // uint48 / Unsigned 48-bit integer
1522 case 0x26: // uint56 / Unsigned 56-bit integer
1523 case 0x2A: // int24 / Signed 24-bit integer
1524 case 0x2C: // int40 / Signed 40-bit integer
1525 case 0x2D: // int48 / Signed 48-bit integer
1526 case 0x2E: // int56 / Signed 56-bit integer
1527 case 0x38: // semi / Semi-precision
1528 case 0x39: // single / Single precision
1529 case 0x3A: // double / Double precision
1530 case 0x48: // array / Array
1531 case 0x49: // struct / Structure
1532 case 0x50: // set / Set
1533 case 0x51: // bag / Bag
1534 case 0xE0: // ToD / Time of day
1536 ChipLogError(Zcl, "attributeType 0x%02x is not supported", attributeType);
1540 case 0x41: // octstr / Octet string
1541 case 0x42: // string / Character string
1543 // Short Strings must contains at least one byte for the length
1544 CHECK_MESSAGE_LENGTH(1);
1545 uint8_t length = chip::Encoding::Read8(message);
1546 ChipLogProgress(Zcl, " length: 0x%02x", length);
1548 // When the length is set to 0xFF, it represents a non-value. In this case the data field is zero length.
1554 CHECK_MESSAGE_LENGTH(length);
1555 Callback::Callback<StringAttributeCallback> * cb =
1556 Callback::Callback<StringAttributeCallback>::FromCancelable(onReportCallback);
1557 cb->mCall(cb->mContext, chip::ByteSpan(message, length));
1561 case 0x43: // octstr16 / Long octet string
1562 case 0x44: // string16 / Long character string
1564 // Long Strings must contains at least two bytes for the length
1565 CHECK_MESSAGE_LENGTH(2);
1566 uint16_t length = chip::Encoding::LittleEndian::Read16(message);
1567 ChipLogProgress(Zcl, " length: 0x%02x", length);
1569 // When the length is set to 0xFFFF, it represents a non-value. In this case the data field is zero length.
1570 if (length == 0xFFFF)
1575 CHECK_MESSAGE_LENGTH(length);
1576 Callback::Callback<StringAttributeCallback> * cb =
1577 Callback::Callback<StringAttributeCallback>::FromCancelable(onReportCallback);
1578 cb->mCall(cb->mContext, chip::ByteSpan(message, length));
1582 case 0x08: // data8 / 8-bit data
1583 case 0x18: // map8 / 8-bit bitmap
1584 case 0x20: // uint8 / Unsigned 8-bit integer
1585 case 0x30: // enum8 / 8-bit enumeration
1587 CHECK_MESSAGE_LENGTH(1);
1588 uint8_t value = chip::Encoding::Read8(message);
1589 ChipLogProgress(Zcl, " value: 0x%02x", value);
1591 Callback::Callback<Int8uAttributeCallback> * cb =
1592 Callback::Callback<Int8uAttributeCallback>::FromCancelable(onReportCallback);
1593 cb->mCall(cb->mContext, value);
1597 case 0x09: // data16 / 16-bit data
1598 case 0x19: // map16 / 16-bit bitmap
1599 case 0x21: // uint16 / Unsigned 16-bit integer
1600 case 0x31: // enum16 / 16-bit enumeration
1601 case 0xE8: // clusterId / Cluster ID
1602 case 0xE9: // attribId / Attribute ID
1603 case 0xEA: // bacOID / BACnet OID
1604 case 0xF1: // key128 / 128-bit security key
1605 case 0xFF: // unk / Unknown
1607 CHECK_MESSAGE_LENGTH(2);
1608 uint16_t value = chip::Encoding::LittleEndian::Read16(message);
1609 ChipLogProgress(Zcl, " value: 0x%04x", value);
1611 Callback::Callback<Int16uAttributeCallback> * cb =
1612 Callback::Callback<Int16uAttributeCallback>::FromCancelable(onReportCallback);
1613 cb->mCall(cb->mContext, value);
1617 case 0x0B: // data32 / 32-bit data
1618 case 0x1B: // map32 / 32-bit bitmap
1619 case 0x23: // uint32 / Unsigned 32-bit integer
1620 case 0xE1: // date / Date
1621 case 0xE2: // UTC / UTCTime
1623 CHECK_MESSAGE_LENGTH(4);
1624 uint32_t value = chip::Encoding::LittleEndian::Read32(message);
1625 ChipLogProgress(Zcl, " value: 0x%08x", value);
1627 Callback::Callback<Int32uAttributeCallback> * cb =
1628 Callback::Callback<Int32uAttributeCallback>::FromCancelable(onReportCallback);
1629 cb->mCall(cb->mContext, value);
1633 case 0x0F: // data64 / 64-bit data
1634 case 0x1F: // map64 / 64-bit bitmap
1635 case 0x27: // uint64 / Unsigned 64-bit integer
1636 case 0xF0: // EUI64 / IEEE address
1638 CHECK_MESSAGE_LENGTH(8);
1639 uint64_t value = chip::Encoding::LittleEndian::Read64(message);
1640 ChipLogProgress(Zcl, " value: 0x%16x", value);
1642 Callback::Callback<Int64uAttributeCallback> * cb =
1643 Callback::Callback<Int64uAttributeCallback>::FromCancelable(onReportCallback);
1644 cb->mCall(cb->mContext, value);
1648 case 0x10: // bool / Boolean
1650 CHECK_MESSAGE_LENGTH(1);
1651 uint8_t value = chip::Encoding::Read8(message);
1652 ChipLogProgress(Zcl, " value: %d", value);
1654 Callback::Callback<BooleanAttributeCallback> * cb =
1655 Callback::Callback<BooleanAttributeCallback>::FromCancelable(onReportCallback);
1656 cb->mCall(cb->mContext, value);
1660 case 0x28: // int8 / Signed 8-bit integer
1662 CHECK_MESSAGE_LENGTH(1);
1663 int8_t value = chip::CastToSigned(chip::Encoding::Read8(message));
1664 ChipLogProgress(Zcl, " value: %" PRId8, value);
1666 Callback::Callback<Int8sAttributeCallback> * cb =
1667 Callback::Callback<Int8sAttributeCallback>::FromCancelable(onReportCallback);
1668 cb->mCall(cb->mContext, value);
1672 case 0x29: // int16 / Signed 16-bit integer
1674 CHECK_MESSAGE_LENGTH(2);
1675 int16_t value = chip::CastToSigned(chip::Encoding::LittleEndian::Read16(message));
1676 ChipLogProgress(Zcl, " value: %" PRId16, value);
1678 Callback::Callback<Int16sAttributeCallback> * cb =
1679 Callback::Callback<Int16sAttributeCallback>::FromCancelable(onReportCallback);
1680 cb->mCall(cb->mContext, value);
1684 case 0x2B: // int32 / Signed 32-bit integer
1686 CHECK_MESSAGE_LENGTH(4);
1687 int32_t value = chip::CastToSigned(chip::Encoding::LittleEndian::Read32(message));
1688 ChipLogProgress(Zcl, " value: %" PRId32, value);
1690 Callback::Callback<Int32sAttributeCallback> * cb =
1691 Callback::Callback<Int32sAttributeCallback>::FromCancelable(onReportCallback);
1692 cb->mCall(cb->mContext, value);
1696 case 0x2F: // int64 / Signed 64-bit integer
1698 CHECK_MESSAGE_LENGTH(8);
1699 int64_t value = chip::CastToSigned(chip::Encoding::LittleEndian::Read64(message));
1700 ChipLogProgress(Zcl, " value: %" PRId64, value);
1702 Callback::Callback<Int64sAttributeCallback> * cb =
1703 Callback::Callback<Int64sAttributeCallback>::FromCancelable(onReportCallback);
1704 cb->mCall(cb->mContext, value);