examples/chip-tool/gen/CHIPClientCallbacks.cpp

   1 /*
   2  *
   3  *    Copyright (c) 2021 Project CHIP Authors
   4  *
   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
   8  *
   9  *        http://www.apache.org/licenses/LICENSE-2.0
  10  *
  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.
  16  */
  17
  18 // THIS FILE IS GENERATED BY ZAP
  19
  20 #include "gen/CHIPClientCallbacks.h"
  21
  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>
  30
  31 using namespace ::chip;
  32
  33 #define CHECK_MESSAGE_LENGTH(value)                                                                                                \
  34     if (!chip::CanCastTo<uint16_t>(value))                                                                                         \
  35     {                                                                                                                              \
  36         ChipLogError(Zcl, "CHECK_MESSAGE_LENGTH expects a uint16_t value, got: %d", value);                                        \
  37         if (onFailureCallback != nullptr)                                                                                          \
  38         {                                                                                                                          \
  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));                                         \
  42         }                                                                                                                          \
  43         return true;                                                                                                               \
  44     }                                                                                                                              \
  45                                                                                                                                    \
  46     if (messageLen < value)                                                                                                        \
  47     {                                                                                                                              \
  48         ChipLogError(Zcl, "Unexpected response length: %d", messageLen);                                                           \
  49         if (onFailureCallback != nullptr)                                                                                          \
  50         {                                                                                                                          \
  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));                                         \
  54         }                                                                                                                          \
  55         return true;                                                                                                               \
  56     }                                                                                                                              \
  57                                                                                                                                    \
  58     messageLen = static_cast<uint16_t>(messageLen - static_cast<uint16_t>(value));
  59
  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);             \
  66                                                                                                                                    \
  67     if (CHIP_NO_ERROR != err)                                                                                                      \
  68     {                                                                                                                              \
  69         if (onSuccessCallback == nullptr)                                                                                          \
  70         {                                                                                                                          \
  71             ChipLogDetail(Zcl, "%s: Missing success callback", name);                                                              \
  72         }                                                                                                                          \
  73                                                                                                                                    \
  74         if (onFailureCallback == nullptr)                                                                                          \
  75         {                                                                                                                          \
  76             ChipLogDetail(Zcl, "%s: Missing failure callback", name);                                                              \
  77         }                                                                                                                          \
  78                                                                                                                                    \
  79         return true;                                                                                                               \
  80     }
  81
  82 #define GET_REPORT_CALLBACK(name)                                                                                                  \
  83     Callback::Cancelable * onReportCallback = nullptr;                                                                             \
  84     CHIP_ERROR err = gCallbacks.GetReportCallback(sourceId, endpointId, clusterId, attributeId, &onReportCallback);                \
  85                                                                                                                                    \
  86     if (CHIP_NO_ERROR != err)                                                                                                      \
  87     {                                                                                                                              \
  88         if (onReportCallback == nullptr)                                                                                           \
  89         {                                                                                                                          \
  90             ChipLogDetail(Zcl, "%s: Missing report callback", name);                                                               \
  91         }                                                                                                                          \
  92                                                                                                                                    \
  93         return true;                                                                                                               \
  94     }
  95
  96 void LogStatus(uint8_t status)
  97 {
  98     switch (status)
  99     {
 100     case EMBER_ZCL_STATUS_SUCCESS:
 101         ChipLogProgress(Zcl, "  status: EMBER_ZCL_STATUS_SUCCESS (0x%02x)", status);
 102         break;
 103     case EMBER_ZCL_STATUS_FAILURE:
 104         ChipLogProgress(Zcl, "  status: EMBER_ZCL_STATUS_FAILURE (0x%02x)", status);
 105         break;
 106     case EMBER_ZCL_STATUS_NOT_AUTHORIZED:
 107         ChipLogProgress(Zcl, "  status: EMBER_ZCL_STATUS_NOT_AUTHORIZED (0x%02x)", status);
 108         break;
 109     case EMBER_ZCL_STATUS_MALFORMED_COMMAND:
 110         ChipLogProgress(Zcl, "  status: EMBER_ZCL_STATUS_MALFORMED_COMMAND (0x%02x)", status);
 111         break;
 112     case EMBER_ZCL_STATUS_UNSUP_COMMAND:
 113         ChipLogProgress(Zcl, "  status: EMBER_ZCL_STATUS_UNSUP_CLUSTER_COMMAND (0x%02x)", status);
 114         break;
 115     case EMBER_ZCL_STATUS_UNSUP_GENERAL_COMMAND:
 116         ChipLogProgress(Zcl, "  status: EMBER_ZCL_STATUS_UNSUP_GENERAL_COMMAND (0x%02x)", status);
 117         break;
 118     case EMBER_ZCL_STATUS_UNSUP_MANUF_CLUSTER_COMMAND:
 119         ChipLogProgress(Zcl, "  status: EMBER_ZCL_STATUS_UNSUP_MANUF_CLUSTER_COMMAND (0x%02x)", status);
 120         break;
 121     case EMBER_ZCL_STATUS_UNSUP_MANUF_GENERAL_COMMAND:
 122         ChipLogProgress(Zcl, "  status: EMBER_ZCL_STATUS_UNSUP_MANUF_GENERAL_COMMAND (0x%02x)", status);
 123         break;
 124     case EMBER_ZCL_STATUS_INVALID_FIELD:
 125         ChipLogProgress(Zcl, "  status: EMBER_ZCL_STATUS_INVALID_FIELD (0x%02x)", status);
 126         break;
 127     case EMBER_ZCL_STATUS_UNSUPPORTED_ATTRIBUTE:
 128         ChipLogProgress(Zcl, "  status: EMBER_ZCL_STATUS_UNSUPPORTED_ATTRIBUTE (0x%02x)", status);
 129         break;
 130     case EMBER_ZCL_STATUS_INVALID_VALUE:
 131         ChipLogProgress(Zcl, "  status: EMBER_ZCL_STATUS_INVALID_VALUE (0x%02x)", status);
 132         break;
 133     case EMBER_ZCL_STATUS_READ_ONLY:
 134         ChipLogProgress(Zcl, "  status: EMBER_ZCL_STATUS_READ_ONLY (0x%02x)", status);
 135         break;
 136     case EMBER_ZCL_STATUS_INSUFFICIENT_SPACE:
 137         ChipLogProgress(Zcl, "  status: EMBER_ZCL_STATUS_INSUFFICIENT_SPACE (0x%02x)", status);
 138         break;
 139     case EMBER_ZCL_STATUS_DUPLICATE_EXISTS:
 140         ChipLogProgress(Zcl, "  status: EMBER_ZCL_STATUS_DUPLICATE_EXISTS (0x%02x)", status);
 141         break;
 142     case EMBER_ZCL_STATUS_NOT_FOUND:
 143         ChipLogProgress(Zcl, "  status: EMBER_ZCL_STATUS_NOT_FOUND (0x%02x)", status);
 144         break;
 145     case EMBER_ZCL_STATUS_UNREPORTABLE_ATTRIBUTE:
 146         ChipLogProgress(Zcl, "  status: EMBER_ZCL_STATUS_UNREPORTABLE_ATTRIBUTE (0x%02x)", status);
 147         break;
 148     case EMBER_ZCL_STATUS_INVALID_DATA_TYPE:
 149         ChipLogProgress(Zcl, "  status: EMBER_ZCL_STATUS_INVALID_DATA_TYPE (0x%02x)", status);
 150         break;
 151     case EMBER_ZCL_STATUS_INVALID_SELECTOR:
 152         ChipLogProgress(Zcl, "  status: EMBER_ZCL_STATUS_INVALID_SELECTOR (0x%02x)", status);
 153         break;
 154     case EMBER_ZCL_STATUS_WRITE_ONLY:
 155         ChipLogProgress(Zcl, "  status: EMBER_ZCL_STATUS_WRITE_ONLY (0x%02x)", status);
 156         break;
 157     case EMBER_ZCL_STATUS_INCONSISTENT_STARTUP_STATE:
 158         ChipLogProgress(Zcl, "  status: EMBER_ZCL_STATUS_INCONSISTENT_STARTUP_STATE (0x%02x)", status);
 159         break;
 160     case EMBER_ZCL_STATUS_DEFINED_OUT_OF_BAND:
 161         ChipLogProgress(Zcl, "  status: EMBER_ZCL_STATUS_DEFINED_OUT_Of_BAND (0x%02x)", status);
 162         break;
 163     case EMBER_ZCL_STATUS_ACTION_DENIED:
 164         ChipLogProgress(Zcl, "  status: EMBER_ZCL_STATUS_ACTION_DENIED (0x%02x)", status);
 165         break;
 166     case EMBER_ZCL_STATUS_TIMEOUT:
 167         ChipLogProgress(Zcl, "  status: EMBER_ZCL_STATUS_TIMEOUT (0x%02x)", status);
 168         break;
 169     case EMBER_ZCL_STATUS_ABORT:
 170         ChipLogProgress(Zcl, "  status: EMBER_ZCL_STATUS_ABORT (0x%02x)", status);
 171         break;
 172     case EMBER_ZCL_STATUS_INVALID_IMAGE:
 173         ChipLogProgress(Zcl, "  status: EMBER_ZCL_STATUS_INVALID_IMAGE (0x%02x)", status);
 174         break;
 175     case EMBER_ZCL_STATUS_WAIT_FOR_DATA:
 176         ChipLogProgress(Zcl, "  status: EMBER_ZCL_STATUS_WAIT_FOR_DATA (0x%02x)", status);
 177         break;
 178     case EMBER_ZCL_STATUS_NO_IMAGE_AVAILABLE:
 179         ChipLogProgress(Zcl, "  status: EMBER_ZCL_STATUS_NO_IMAGE_AVAILABLE (0x%02x)", status);
 180         break;
 181     case EMBER_ZCL_STATUS_REQUIRE_MORE_IMAGE:
 182         ChipLogProgress(Zcl, "  status: EMBER_ZCL_STATUS_REQUIRE_MORE_IMAGE (0x%02x)", status);
 183         break;
 184     case EMBER_ZCL_STATUS_HARDWARE_FAILURE:
 185         ChipLogProgress(Zcl, "  status: EMBER_ZCL_STATUS_HARDWARE_FAILURE (0x%02x)", status);
 186         break;
 187     case EMBER_ZCL_STATUS_SOFTWARE_FAILURE:
 188         ChipLogProgress(Zcl, "  status: EMBER_ZCL_STATUS_SOFTWARE_FAILURE (0x%02x)", status);
 189         break;
 190     case EMBER_ZCL_STATUS_UNSUPPORTED_CLUSTER:
 191         ChipLogProgress(Zcl, "  status: EMBER_ZCL_STATUS_UNSUPPORTED_CLUSTER (0x%02x)", status);
 192         break;
 193     case EMBER_ZCL_STATUS_LIMIT_REACHED:
 194         ChipLogProgress(Zcl, "  status: EMBER_ZCL_STATUS_LIMIT_REACHED (0x%02x)", status);
 195         break;
 196     default:
 197         ChipLogError(Zcl, "Unknow status: 0x%02x", status);
 198         break;
 199     }
 200 }
 201
 202 // Singleton instance of the callbacks manager
 203 app::CHIPDeviceCallbacksMgr & gCallbacks = app::CHIPDeviceCallbacksMgr::GetInstance();
 204
 205 bool emberAfDefaultResponseCallback(ClusterId clusterId, CommandId commandId, EmberAfStatus status)
 206 {
 207     ChipLogProgress(Zcl, "DefaultResponse:");
 208     ChipLogProgress(Zcl, "  ClusterId: 0x%04x", clusterId);
 209     ChipLogProgress(Zcl, "  CommandId: 0x%02x", commandId);
 210     LogStatus(status);
 211
 212     GET_RESPONSE_CALLBACKS("emberAfDefaultResponseCallback");
 213     if (status == EMBER_ZCL_STATUS_SUCCESS)
 214     {
 215         Callback::Callback<DefaultSuccessCallback> * cb =
 216             Callback::Callback<DefaultSuccessCallback>::FromCancelable(onSuccessCallback);
 217         cb->mCall(cb->mContext);
 218     }
 219     else
 220     {
 221         Callback::Callback<DefaultFailureCallback> * cb =
 222             Callback::Callback<DefaultFailureCallback>::FromCancelable(onFailureCallback);
 223         cb->mCall(cb->mContext, static_cast<uint8_t>(status));
 224     }
 225
 226     return true;
 227 }
 228
 229 bool emberAfReadAttributesResponseCallback(ClusterId clusterId, uint8_t * message, uint16_t messageLen)
 230 {
 231     ChipLogProgress(Zcl, "ReadAttributesResponse:");
 232     ChipLogProgress(Zcl, "  ClusterId: 0x%04x", clusterId);
 233
 234     GET_RESPONSE_CALLBACKS("emberAfReadAttributesResponseCallback");
 235
 236     // struct readAttributeResponseRecord[]
 237     while (messageLen)
 238     {
 239         CHECK_MESSAGE_LENGTH(2);
 240         uint16_t attributeId = chip::Encoding::LittleEndian::Read16(message); // attribId
 241         ChipLogProgress(Zcl, "  attributeId: 0x%04x", attributeId);
 242
 243         CHECK_MESSAGE_LENGTH(1);
 244         uint8_t status = chip::Encoding::Read8(message); // zclStatus
 245         LogStatus(status);
 246
 247         if (status == EMBER_ZCL_STATUS_SUCCESS)
 248         {
 249             CHECK_MESSAGE_LENGTH(1);
 250             uint8_t attributeType = chip::Encoding::Read8(message);
 251             ChipLogProgress(Zcl, "  attributeType: 0x%02x", attributeType);
 252
 253             switch (attributeType)
 254             {
 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
 280             {
 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);
 285                 return true;
 286             }
 287
 288             case 0x41: // octstr / Octet string
 289             case 0x42: // string / Character string
 290             {
 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);
 295
 296                 // When the length is set to 0xFF, it represents a non-value. In this case the data field is zero length.
 297                 if (length == 0xFF)
 298                 {
 299                     length = 0;
 300                 }
 301
 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));
 306                 break;
 307             }
 308
 309             case 0x43: // octstr16 / Long octet string
 310             case 0x44: // string16 / Long character string
 311             {
 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);
 316
 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)
 319                 {
 320                     length = 0;
 321                 }
 322
 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));
 327                 break;
 328             }
 329
 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
 334             {
 335                 CHECK_MESSAGE_LENGTH(1);
 336                 uint8_t value = chip::Encoding::Read8(message);
 337                 ChipLogProgress(Zcl, "  value: 0x%02x", value);
 338
 339                 Callback::Callback<Int8uAttributeCallback> * cb =
 340                     Callback::Callback<Int8uAttributeCallback>::FromCancelable(onSuccessCallback);
 341                 cb->mCall(cb->mContext, value);
 342                 break;
 343             }
 344
 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
 354             {
 355                 CHECK_MESSAGE_LENGTH(2);
 356                 uint16_t value = chip::Encoding::LittleEndian::Read16(message);
 357                 ChipLogProgress(Zcl, "  value: 0x%04x", value);
 358
 359                 Callback::Callback<Int16uAttributeCallback> * cb =
 360                     Callback::Callback<Int16uAttributeCallback>::FromCancelable(onSuccessCallback);
 361                 cb->mCall(cb->mContext, value);
 362                 break;
 363             }
 364
 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
 370             {
 371                 CHECK_MESSAGE_LENGTH(4);
 372                 uint32_t value = chip::Encoding::LittleEndian::Read32(message);
 373                 ChipLogProgress(Zcl, "  value: 0x%08x", value);
 374
 375                 Callback::Callback<Int32uAttributeCallback> * cb =
 376                     Callback::Callback<Int32uAttributeCallback>::FromCancelable(onSuccessCallback);
 377                 cb->mCall(cb->mContext, value);
 378                 break;
 379             }
 380
 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
 385             {
 386                 CHECK_MESSAGE_LENGTH(8);
 387                 uint64_t value = chip::Encoding::LittleEndian::Read64(message);
 388                 ChipLogProgress(Zcl, "  value: 0x%16x", value);
 389
 390                 Callback::Callback<Int64uAttributeCallback> * cb =
 391                     Callback::Callback<Int64uAttributeCallback>::FromCancelable(onSuccessCallback);
 392                 cb->mCall(cb->mContext, value);
 393                 break;
 394             }
 395
 396             case 0x10: // bool / Boolean
 397             {
 398                 CHECK_MESSAGE_LENGTH(1);
 399                 uint8_t value = chip::Encoding::Read8(message);
 400                 ChipLogProgress(Zcl, "  value: %d", value);
 401
 402                 Callback::Callback<BooleanAttributeCallback> * cb =
 403                     Callback::Callback<BooleanAttributeCallback>::FromCancelable(onSuccessCallback);
 404                 cb->mCall(cb->mContext, value);
 405                 break;
 406             }
 407
 408             case 0x28: // int8 / Signed 8-bit integer
 409             {
 410                 CHECK_MESSAGE_LENGTH(1);
 411                 int8_t value = chip::CastToSigned(chip::Encoding::Read8(message));
 412                 ChipLogProgress(Zcl, "  value: %" PRId8, value);
 413
 414                 Callback::Callback<Int8sAttributeCallback> * cb =
 415                     Callback::Callback<Int8sAttributeCallback>::FromCancelable(onSuccessCallback);
 416                 cb->mCall(cb->mContext, value);
 417                 break;
 418             }
 419
 420             case 0x29: // int16 / Signed 16-bit integer
 421             {
 422                 CHECK_MESSAGE_LENGTH(2);
 423                 int16_t value = chip::CastToSigned(chip::Encoding::LittleEndian::Read16(message));
 424                 ChipLogProgress(Zcl, "  value: %" PRId16, value);
 425
 426                 Callback::Callback<Int16sAttributeCallback> * cb =
 427                     Callback::Callback<Int16sAttributeCallback>::FromCancelable(onSuccessCallback);
 428                 cb->mCall(cb->mContext, value);
 429                 break;
 430             }
 431
 432             case 0x2B: // int32 / Signed 32-bit integer
 433             {
 434                 CHECK_MESSAGE_LENGTH(4);
 435                 int32_t value = chip::CastToSigned(chip::Encoding::LittleEndian::Read32(message));
 436                 ChipLogProgress(Zcl, "  value: %" PRId32, value);
 437
 438                 Callback::Callback<Int32sAttributeCallback> * cb =
 439                     Callback::Callback<Int32sAttributeCallback>::FromCancelable(onSuccessCallback);
 440                 cb->mCall(cb->mContext, value);
 441                 break;
 442             }
 443
 444             case 0x2F: // int64 / Signed 64-bit integer
 445             {
 446                 CHECK_MESSAGE_LENGTH(8);
 447                 int64_t value = chip::CastToSigned(chip::Encoding::LittleEndian::Read64(message));
 448                 ChipLogProgress(Zcl, "  value: %" PRId64, value);
 449
 450                 Callback::Callback<Int64sAttributeCallback> * cb =
 451                     Callback::Callback<Int64sAttributeCallback>::FromCancelable(onSuccessCallback);
 452                 cb->mCall(cb->mContext, value);
 453                 break;
 454             }
 455             }
 456         }
 457         else
 458         {
 459             Callback::Callback<DefaultFailureCallback> * cb =
 460                 Callback::Callback<DefaultFailureCallback>::FromCancelable(onFailureCallback);
 461             cb->mCall(cb->mContext, status);
 462         }
 463
 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
 466         // somewhere.
 467         if (messageLen)
 468         {
 469             ChipLogError(Zcl, "Multiple attributes read at the same time. Something went wrong.");
 470             break;
 471         }
 472     }
 473
 474     return true;
 475 }
 476
 477 bool emberAfWriteAttributesResponseCallback(ClusterId clusterId, uint8_t * message, uint16_t messageLen)
 478 {
 479     ChipLogProgress(Zcl, "WriteAttributesResponse:");
 480     ChipLogProgress(Zcl, "  ClusterId: 0x%04x", clusterId);
 481
 482     GET_RESPONSE_CALLBACKS("emberAfWriteAttributesResponseCallback");
 483
 484     // struct writeAttributeResponseRecord[]
 485     while (messageLen)
 486     {
 487         CHECK_MESSAGE_LENGTH(1);
 488         uint8_t status = chip::Encoding::Read8(message); // zclStatus
 489         LogStatus(status);
 490
 491         if (status == EMBER_ZCL_STATUS_SUCCESS)
 492         {
 493             Callback::Callback<DefaultSuccessCallback> * cb =
 494                 Callback::Callback<DefaultSuccessCallback>::FromCancelable(onSuccessCallback);
 495             cb->mCall(cb->mContext);
 496         }
 497         else
 498         {
 499             CHECK_MESSAGE_LENGTH(2);
 500             uint16_t attributeId = chip::Encoding::LittleEndian::Read16(message); // attribId
 501             ChipLogProgress(Zcl, "  attributeId: 0x%04x", attributeId);
 502
 503             Callback::Callback<DefaultFailureCallback> * cb =
 504                 Callback::Callback<DefaultFailureCallback>::FromCancelable(onFailureCallback);
 505             cb->mCall(cb->mContext, status);
 506         }
 507
 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
 510         // somewhere.
 511         if (messageLen)
 512         {
 513             ChipLogError(Zcl, "Multiple attributes written at the same time. Something went wrong.");
 514             break;
 515         }
 516     }
 517
 518     return true;
 519 }
 520
 521 bool emberAfConfigureReportingResponseCallback(ClusterId clusterId, uint8_t * message, uint16_t messageLen)
 522 {
 523     ChipLogProgress(Zcl, "ConfigureReportingResponseCallback:");
 524     ChipLogProgress(Zcl, "  ClusterId: 0x%04x", clusterId);
 525
 526     GET_RESPONSE_CALLBACKS("emberAfConfigureReportingResponseCallback");
 527
 528     // struct configureReportingResponseRecord[]
 529     while (messageLen)
 530     {
 531         CHECK_MESSAGE_LENGTH(1);
 532         uint8_t status = chip::Encoding::Read8(message); // zclStatus
 533         LogStatus(status);
 534
 535         if (status == EMBER_ZCL_STATUS_SUCCESS)
 536         {
 537             Callback::Callback<DefaultSuccessCallback> * cb =
 538                 Callback::Callback<DefaultSuccessCallback>::FromCancelable(onSuccessCallback);
 539             cb->mCall(cb->mContext);
 540         }
 541         else
 542         {
 543             CHECK_MESSAGE_LENGTH(1);
 544             uint8_t direction = chip::Encoding::Read8(message); // reportingRole
 545             ChipLogProgress(Zcl, "  direction: 0x%02x", direction);
 546
 547             CHECK_MESSAGE_LENGTH(2);
 548             uint16_t attributeId = chip::Encoding::LittleEndian::Read16(message); // attribId
 549             ChipLogProgress(Zcl, "  attributeId: 0x%04x", attributeId);
 550
 551             Callback::Callback<DefaultFailureCallback> * cb =
 552                 Callback::Callback<DefaultFailureCallback>::FromCancelable(onFailureCallback);
 553             cb->mCall(cb->mContext, status);
 554         }
 555
 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
 558         // somewhere.
 559         if (messageLen)
 560         {
 561             ChipLogError(Zcl, "Multiple attributes reports configured at the same time. Something went wrong.");
 562             break;
 563         }
 564     }
 565
 566     return true;
 567 }
 568
 569 bool emberAfReadReportingConfigurationResponseCallback(chip::ClusterId clusterId, uint8_t * message, uint16_t messageLen)
 570 {
 571     ChipLogProgress(Zcl, "ReadReportingConfigurationResponse:");
 572     ChipLogProgress(Zcl, "  ClusterId: 0x%04x", clusterId);
 573
 574     GET_RESPONSE_CALLBACKS("emberAfReadReportingConfigurationResponseCallback");
 575
 576     // struct readReportingConfigurationResponseRecord[]
 577     while (messageLen)
 578     {
 579         CHECK_MESSAGE_LENGTH(1);
 580         uint8_t direction = chip::Encoding::Read8(message); // reportingRole
 581         ChipLogProgress(Zcl, "  direction: 0x%02x", direction);
 582
 583         CHECK_MESSAGE_LENGTH(2);
 584         uint16_t attributeId = chip::Encoding::LittleEndian::Read16(message); // attribId
 585         ChipLogProgress(Zcl, "  attributeId: 0x%04x", attributeId);
 586
 587         if (direction == EMBER_ZCL_REPORTING_DIRECTION_REPORTED)
 588         {
 589             CHECK_MESSAGE_LENGTH(1);
 590             uint8_t attributeType = chip::Encoding::Read8(message); // zclType
 591             ChipLogProgress(Zcl, "  attributeType: 0x%02x", attributeType);
 592
 593             CHECK_MESSAGE_LENGTH(2);
 594             uint16_t minimumReportingInterval = chip::Encoding::LittleEndian::Read16(message); // uint16
 595             ChipLogProgress(Zcl, "  minimumReportingInterval: %" PRIu16, minimumReportingInterval);
 596
 597             CHECK_MESSAGE_LENGTH(2);
 598             uint16_t maximumReportingInterval = chip::Encoding::LittleEndian::Read16(message); // uint16
 599             ChipLogProgress(Zcl, "  maximumReportingInterval: %" PRIu16, maximumReportingInterval);
 600
 601             // FIXME: unk is not supported yet.
 602
 603             Callback::Callback<ReadReportingConfigurationReportedCallback> * cb =
 604                 Callback::Callback<ReadReportingConfigurationReportedCallback>::FromCancelable(onSuccessCallback);
 605             cb->mCall(cb->mContext, minimumReportingInterval, maximumReportingInterval);
 606         }
 607         else
 608         {
 609             CHECK_MESSAGE_LENGTH(2);
 610             uint16_t timeout = chip::Encoding::LittleEndian::Read16(message); // uint16
 611             ChipLogProgress(Zcl, "  timeout: %" PRIu16, timeout);
 612
 613             Callback::Callback<ReadReportingConfigurationReceivedCallback> * cb =
 614                 Callback::Callback<ReadReportingConfigurationReceivedCallback>::FromCancelable(onSuccessCallback);
 615             cb->mCall(cb->mContext, timeout);
 616         }
 617     }
 618
 619     return true;
 620 }
 621
 622 bool emberAfDiscoverAttributesResponseCallback(ClusterId clusterId, bool discoveryComplete, uint8_t * message, uint16_t messageLen,
 623                                                bool extended)
 624 {
 625     ChipLogProgress(Zcl, "DiscoverAttributesResponse:");
 626     ChipLogProgress(Zcl, "  ClusterId: 0x%04x", clusterId);
 627     ChipLogProgress(Zcl, "  discoveryComplete: %d", discoveryComplete);
 628     ChipLogProgress(Zcl, "  extended: %d", extended);
 629
 630     GET_RESPONSE_CALLBACKS("emberAfDiscoverAttributesCallback");
 631
 632     // struct discoverAttributesResponseRecord[]
 633     while (messageLen)
 634     {
 635         CHECK_MESSAGE_LENGTH(2);
 636         uint16_t attributeId = chip::Encoding::LittleEndian::Read16(message); // attribId
 637         ChipLogProgress(Zcl, "  attributeId: 0x%04x", attributeId);
 638
 639         CHECK_MESSAGE_LENGTH(1);
 640         uint8_t attributeType = chip::Encoding::Read8(message); // zclType
 641         ChipLogProgress(Zcl, "  attributeType: 0x%02x", attributeType);
 642     }
 643
 644     Callback::Callback<DefaultSuccessCallback> * cb = Callback::Callback<DefaultSuccessCallback>::FromCancelable(onSuccessCallback);
 645     cb->mCall(cb->mContext);
 646     return true;
 647 }
 648
 649 bool emberAfDiscoverCommandsGeneratedResponseCallback(ClusterId clusterId, uint16_t manufacturerCode, bool discoveryComplete,
 650                                                       CommandId * commandIds, uint16_t commandIdCount)
 651 {
 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);
 657
 658     for (uint16_t i = 0; i < commandIdCount; i++)
 659     {
 660         ChipLogProgress(Zcl, "  commandId: 0x%02x", commandIds++);
 661     }
 662
 663     GET_RESPONSE_CALLBACKS("emberAfDiscoverCommandsGeneratedResponseCallback");
 664     Callback::Callback<DefaultSuccessCallback> * cb = Callback::Callback<DefaultSuccessCallback>::FromCancelable(onSuccessCallback);
 665     cb->mCall(cb->mContext);
 666     return true;
 667 }
 668
 669 bool emberAfDiscoverCommandsReceivedResponseCallback(ClusterId clusterId, uint16_t manufacturerCode, bool discoveryComplete,
 670                                                      CommandId * commandIds, uint16_t commandIdCount)
 671 {
 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);
 677
 678     for (uint16_t i = 0; i < commandIdCount; i++)
 679     {
 680         ChipLogProgress(Zcl, "  commandId: 0x%02x", commandIds++);
 681     }
 682
 683     GET_RESPONSE_CALLBACKS("emberAfDiscoverCommandsGeneratedResponseCallback");
 684     Callback::Callback<DefaultSuccessCallback> * cb = Callback::Callback<DefaultSuccessCallback>::FromCancelable(onSuccessCallback);
 685     cb->mCall(cb->mContext);
 686     return true;
 687 }
 688
 689 bool emberAfContentLaunchClusterLaunchContentResponseCallback(uint8_t contentLaunchStatus)
 690 {
 691     ChipLogProgress(Zcl, "LaunchContentResponse:");
 692     ChipLogProgress(Zcl, "  contentLaunchStatus: %" PRIu8 "", contentLaunchStatus);
 693
 694     GET_RESPONSE_CALLBACKS("ContentLaunchClusterLaunchContentResponseCallback");
 695
 696     Callback::Callback<ContentLaunchClusterLaunchContentResponseCallback> * cb =
 697         Callback::Callback<ContentLaunchClusterLaunchContentResponseCallback>::FromCancelable(onSuccessCallback);
 698     cb->mCall(cb->mContext, contentLaunchStatus);
 699     return true;
 700 }
 701
 702 bool emberAfContentLaunchClusterLaunchURLResponseCallback(uint8_t contentLaunchStatus)
 703 {
 704     ChipLogProgress(Zcl, "LaunchURLResponse:");
 705     ChipLogProgress(Zcl, "  contentLaunchStatus: %" PRIu8 "", contentLaunchStatus);
 706
 707     GET_RESPONSE_CALLBACKS("ContentLaunchClusterLaunchURLResponseCallback");
 708
 709     Callback::Callback<ContentLaunchClusterLaunchURLResponseCallback> * cb =
 710         Callback::Callback<ContentLaunchClusterLaunchURLResponseCallback>::FromCancelable(onSuccessCallback);
 711     cb->mCall(cb->mContext, contentLaunchStatus);
 712     return true;
 713 }
 714
 715 bool emberAfDoorLockClusterClearAllPinsResponseCallback(uint8_t status)
 716 {
 717     ChipLogProgress(Zcl, "ClearAllPinsResponse:");
 718     LogStatus(status);
 719
 720     GET_RESPONSE_CALLBACKS("DoorLockClusterClearAllPinsResponseCallback");
 721
 722     if (status != EMBER_ZCL_STATUS_SUCCESS)
 723     {
 724         Callback::Callback<DefaultFailureCallback> * cb =
 725             Callback::Callback<DefaultFailureCallback>::FromCancelable(onFailureCallback);
 726         cb->mCall(cb->mContext, status);
 727         return true;
 728     }
 729
 730     Callback::Callback<DoorLockClusterClearAllPinsResponseCallback> * cb =
 731         Callback::Callback<DoorLockClusterClearAllPinsResponseCallback>::FromCancelable(onSuccessCallback);
 732     cb->mCall(cb->mContext);
 733     return true;
 734 }
 735
 736 bool emberAfDoorLockClusterClearAllRfidsResponseCallback(uint8_t status)
 737 {
 738     ChipLogProgress(Zcl, "ClearAllRfidsResponse:");
 739     LogStatus(status);
 740
 741     GET_RESPONSE_CALLBACKS("DoorLockClusterClearAllRfidsResponseCallback");
 742
 743     if (status != EMBER_ZCL_STATUS_SUCCESS)
 744     {
 745         Callback::Callback<DefaultFailureCallback> * cb =
 746             Callback::Callback<DefaultFailureCallback>::FromCancelable(onFailureCallback);
 747         cb->mCall(cb->mContext, status);
 748         return true;
 749     }
 750
 751     Callback::Callback<DoorLockClusterClearAllRfidsResponseCallback> * cb =
 752         Callback::Callback<DoorLockClusterClearAllRfidsResponseCallback>::FromCancelable(onSuccessCallback);
 753     cb->mCall(cb->mContext);
 754     return true;
 755 }
 756
 757 bool emberAfDoorLockClusterClearHolidayScheduleResponseCallback(uint8_t status)
 758 {
 759     ChipLogProgress(Zcl, "ClearHolidayScheduleResponse:");
 760     LogStatus(status);
 761
 762     GET_RESPONSE_CALLBACKS("DoorLockClusterClearHolidayScheduleResponseCallback");
 763
 764     if (status != EMBER_ZCL_STATUS_SUCCESS)
 765     {
 766         Callback::Callback<DefaultFailureCallback> * cb =
 767             Callback::Callback<DefaultFailureCallback>::FromCancelable(onFailureCallback);
 768         cb->mCall(cb->mContext, status);
 769         return true;
 770     }
 771
 772     Callback::Callback<DoorLockClusterClearHolidayScheduleResponseCallback> * cb =
 773         Callback::Callback<DoorLockClusterClearHolidayScheduleResponseCallback>::FromCancelable(onSuccessCallback);
 774     cb->mCall(cb->mContext);
 775     return true;
 776 }
 777
 778 bool emberAfDoorLockClusterClearPinResponseCallback(uint8_t status)
 779 {
 780     ChipLogProgress(Zcl, "ClearPinResponse:");
 781     LogStatus(status);
 782
 783     GET_RESPONSE_CALLBACKS("DoorLockClusterClearPinResponseCallback");
 784
 785     if (status != EMBER_ZCL_STATUS_SUCCESS)
 786     {
 787         Callback::Callback<DefaultFailureCallback> * cb =
 788             Callback::Callback<DefaultFailureCallback>::FromCancelable(onFailureCallback);
 789         cb->mCall(cb->mContext, status);
 790         return true;
 791     }
 792
 793     Callback::Callback<DoorLockClusterClearPinResponseCallback> * cb =
 794         Callback::Callback<DoorLockClusterClearPinResponseCallback>::FromCancelable(onSuccessCallback);
 795     cb->mCall(cb->mContext);
 796     return true;
 797 }
 798
 799 bool emberAfDoorLockClusterClearRfidResponseCallback(uint8_t status)
 800 {
 801     ChipLogProgress(Zcl, "ClearRfidResponse:");
 802     LogStatus(status);
 803
 804     GET_RESPONSE_CALLBACKS("DoorLockClusterClearRfidResponseCallback");
 805
 806     if (status != EMBER_ZCL_STATUS_SUCCESS)
 807     {
 808         Callback::Callback<DefaultFailureCallback> * cb =
 809             Callback::Callback<DefaultFailureCallback>::FromCancelable(onFailureCallback);
 810         cb->mCall(cb->mContext, status);
 811         return true;
 812     }
 813
 814     Callback::Callback<DoorLockClusterClearRfidResponseCallback> * cb =
 815         Callback::Callback<DoorLockClusterClearRfidResponseCallback>::FromCancelable(onSuccessCallback);
 816     cb->mCall(cb->mContext);
 817     return true;
 818 }
 819
 820 bool emberAfDoorLockClusterClearWeekdayScheduleResponseCallback(uint8_t status)
 821 {
 822     ChipLogProgress(Zcl, "ClearWeekdayScheduleResponse:");
 823     LogStatus(status);
 824
 825     GET_RESPONSE_CALLBACKS("DoorLockClusterClearWeekdayScheduleResponseCallback");
 826
 827     if (status != EMBER_ZCL_STATUS_SUCCESS)
 828     {
 829         Callback::Callback<DefaultFailureCallback> * cb =
 830             Callback::Callback<DefaultFailureCallback>::FromCancelable(onFailureCallback);
 831         cb->mCall(cb->mContext, status);
 832         return true;
 833     }
 834
 835     Callback::Callback<DoorLockClusterClearWeekdayScheduleResponseCallback> * cb =
 836         Callback::Callback<DoorLockClusterClearWeekdayScheduleResponseCallback>::FromCancelable(onSuccessCallback);
 837     cb->mCall(cb->mContext);
 838     return true;
 839 }
 840
 841 bool emberAfDoorLockClusterClearYeardayScheduleResponseCallback(uint8_t status)
 842 {
 843     ChipLogProgress(Zcl, "ClearYeardayScheduleResponse:");
 844     LogStatus(status);
 845
 846     GET_RESPONSE_CALLBACKS("DoorLockClusterClearYeardayScheduleResponseCallback");
 847
 848     if (status != EMBER_ZCL_STATUS_SUCCESS)
 849     {
 850         Callback::Callback<DefaultFailureCallback> * cb =
 851             Callback::Callback<DefaultFailureCallback>::FromCancelable(onFailureCallback);
 852         cb->mCall(cb->mContext, status);
 853         return true;
 854     }
 855
 856     Callback::Callback<DoorLockClusterClearYeardayScheduleResponseCallback> * cb =
 857         Callback::Callback<DoorLockClusterClearYeardayScheduleResponseCallback>::FromCancelable(onSuccessCallback);
 858     cb->mCall(cb->mContext);
 859     return true;
 860 }
 861
 862 bool emberAfDoorLockClusterGetHolidayScheduleResponseCallback(uint8_t scheduleId, uint8_t status, uint32_t localStartTime,
 863                                                               uint32_t localEndTime, uint8_t operatingModeDuringHoliday)
 864 {
 865     ChipLogProgress(Zcl, "GetHolidayScheduleResponse:");
 866     ChipLogProgress(Zcl, "  scheduleId: %" PRIu8 "", scheduleId);
 867     LogStatus(status);
 868     ChipLogProgress(Zcl, "  localStartTime: %" PRIu32 "", localStartTime);
 869     ChipLogProgress(Zcl, "  localEndTime: %" PRIu32 "", localEndTime);
 870     ChipLogProgress(Zcl, "  operatingModeDuringHoliday: %" PRIu8 "", operatingModeDuringHoliday);
 871
 872     GET_RESPONSE_CALLBACKS("DoorLockClusterGetHolidayScheduleResponseCallback");
 873
 874     if (status != EMBER_ZCL_STATUS_SUCCESS)
 875     {
 876         Callback::Callback<DefaultFailureCallback> * cb =
 877             Callback::Callback<DefaultFailureCallback>::FromCancelable(onFailureCallback);
 878         cb->mCall(cb->mContext, status);
 879         return true;
 880     }
 881
 882     Callback::Callback<DoorLockClusterGetHolidayScheduleResponseCallback> * cb =
 883         Callback::Callback<DoorLockClusterGetHolidayScheduleResponseCallback>::FromCancelable(onSuccessCallback);
 884     cb->mCall(cb->mContext, scheduleId, localStartTime, localEndTime, operatingModeDuringHoliday);
 885     return true;
 886 }
 887
 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)
 890 {
 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);
 899
 900     GET_RESPONSE_CALLBACKS("DoorLockClusterGetLogRecordResponseCallback");
 901
 902     Callback::Callback<DoorLockClusterGetLogRecordResponseCallback> * cb =
 903         Callback::Callback<DoorLockClusterGetLogRecordResponseCallback>::FromCancelable(onSuccessCallback);
 904     cb->mCall(cb->mContext, logEntryId, timestamp, eventType, source, eventIdOrAlarmCode, userId, pin);
 905     return true;
 906 }
 907
 908 bool emberAfDoorLockClusterGetPinResponseCallback(uint16_t userId, uint8_t userStatus, uint8_t userType, uint8_t * pin)
 909 {
 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);
 915
 916     GET_RESPONSE_CALLBACKS("DoorLockClusterGetPinResponseCallback");
 917
 918     Callback::Callback<DoorLockClusterGetPinResponseCallback> * cb =
 919         Callback::Callback<DoorLockClusterGetPinResponseCallback>::FromCancelable(onSuccessCallback);
 920     cb->mCall(cb->mContext, userId, userStatus, userType, pin);
 921     return true;
 922 }
 923
 924 bool emberAfDoorLockClusterGetRfidResponseCallback(uint16_t userId, uint8_t userStatus, uint8_t userType, uint8_t * rfid)
 925 {
 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);
 931
 932     GET_RESPONSE_CALLBACKS("DoorLockClusterGetRfidResponseCallback");
 933
 934     Callback::Callback<DoorLockClusterGetRfidResponseCallback> * cb =
 935         Callback::Callback<DoorLockClusterGetRfidResponseCallback>::FromCancelable(onSuccessCallback);
 936     cb->mCall(cb->mContext, userId, userStatus, userType, rfid);
 937     return true;
 938 }
 939
 940 bool emberAfDoorLockClusterGetUserTypeResponseCallback(uint16_t userId, uint8_t userType)
 941 {
 942     ChipLogProgress(Zcl, "GetUserTypeResponse:");
 943     ChipLogProgress(Zcl, "  userId: %" PRIu16 "", userId);
 944     ChipLogProgress(Zcl, "  userType: %" PRIu8 "", userType);
 945
 946     GET_RESPONSE_CALLBACKS("DoorLockClusterGetUserTypeResponseCallback");
 947
 948     Callback::Callback<DoorLockClusterGetUserTypeResponseCallback> * cb =
 949         Callback::Callback<DoorLockClusterGetUserTypeResponseCallback>::FromCancelable(onSuccessCallback);
 950     cb->mCall(cb->mContext, userId, userType);
 951     return true;
 952 }
 953
 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,
 956                                                               uint8_t endMinute)
 957 {
 958     ChipLogProgress(Zcl, "GetWeekdayScheduleResponse:");
 959     ChipLogProgress(Zcl, "  scheduleId: %" PRIu8 "", scheduleId);
 960     ChipLogProgress(Zcl, "  userId: %" PRIu16 "", userId);
 961     LogStatus(status);
 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);
 967
 968     GET_RESPONSE_CALLBACKS("DoorLockClusterGetWeekdayScheduleResponseCallback");
 969
 970     if (status != EMBER_ZCL_STATUS_SUCCESS)
 971     {
 972         Callback::Callback<DefaultFailureCallback> * cb =
 973             Callback::Callback<DefaultFailureCallback>::FromCancelable(onFailureCallback);
 974         cb->mCall(cb->mContext, status);
 975         return true;
 976     }
 977
 978     Callback::Callback<DoorLockClusterGetWeekdayScheduleResponseCallback> * cb =
 979         Callback::Callback<DoorLockClusterGetWeekdayScheduleResponseCallback>::FromCancelable(onSuccessCallback);
 980     cb->mCall(cb->mContext, scheduleId, userId, daysMask, startHour, startMinute, endHour, endMinute);
 981     return true;
 982 }
 983
 984 bool emberAfDoorLockClusterGetYeardayScheduleResponseCallback(uint8_t scheduleId, uint16_t userId, uint8_t status,
 985                                                               uint32_t localStartTime, uint32_t localEndTime)
 986 {
 987     ChipLogProgress(Zcl, "GetYeardayScheduleResponse:");
 988     ChipLogProgress(Zcl, "  scheduleId: %" PRIu8 "", scheduleId);
 989     ChipLogProgress(Zcl, "  userId: %" PRIu16 "", userId);
 990     LogStatus(status);
 991     ChipLogProgress(Zcl, "  localStartTime: %" PRIu32 "", localStartTime);
 992     ChipLogProgress(Zcl, "  localEndTime: %" PRIu32 "", localEndTime);
 993
 994     GET_RESPONSE_CALLBACKS("DoorLockClusterGetYeardayScheduleResponseCallback");
 995
 996     if (status != EMBER_ZCL_STATUS_SUCCESS)
 997     {
 998         Callback::Callback<DefaultFailureCallback> * cb =
 999             Callback::Callback<DefaultFailureCallback>::FromCancelable(onFailureCallback);
1000         cb->mCall(cb->mContext, status);
1001         return true;
1002     }
1003
1004     Callback::Callback<DoorLockClusterGetYeardayScheduleResponseCallback> * cb =
1005         Callback::Callback<DoorLockClusterGetYeardayScheduleResponseCallback>::FromCancelable(onSuccessCallback);
1006     cb->mCall(cb->mContext, scheduleId, userId, localStartTime, localEndTime);
1007     return true;
1008 }
1009
1010 bool emberAfDoorLockClusterLockDoorResponseCallback(uint8_t status)
1011 {
1012     ChipLogProgress(Zcl, "LockDoorResponse:");
1013     LogStatus(status);
1014
1015     GET_RESPONSE_CALLBACKS("DoorLockClusterLockDoorResponseCallback");
1016
1017     if (status != EMBER_ZCL_STATUS_SUCCESS)
1018     {
1019         Callback::Callback<DefaultFailureCallback> * cb =
1020             Callback::Callback<DefaultFailureCallback>::FromCancelable(onFailureCallback);
1021         cb->mCall(cb->mContext, status);
1022         return true;
1023     }
1024
1025     Callback::Callback<DoorLockClusterLockDoorResponseCallback> * cb =
1026         Callback::Callback<DoorLockClusterLockDoorResponseCallback>::FromCancelable(onSuccessCallback);
1027     cb->mCall(cb->mContext);
1028     return true;
1029 }
1030
1031 bool emberAfDoorLockClusterSetHolidayScheduleResponseCallback(uint8_t status)
1032 {
1033     ChipLogProgress(Zcl, "SetHolidayScheduleResponse:");
1034     LogStatus(status);
1035
1036     GET_RESPONSE_CALLBACKS("DoorLockClusterSetHolidayScheduleResponseCallback");
1037
1038     if (status != EMBER_ZCL_STATUS_SUCCESS)
1039     {
1040         Callback::Callback<DefaultFailureCallback> * cb =
1041             Callback::Callback<DefaultFailureCallback>::FromCancelable(onFailureCallback);
1042         cb->mCall(cb->mContext, status);
1043         return true;
1044     }
1045
1046     Callback::Callback<DoorLockClusterSetHolidayScheduleResponseCallback> * cb =
1047         Callback::Callback<DoorLockClusterSetHolidayScheduleResponseCallback>::FromCancelable(onSuccessCallback);
1048     cb->mCall(cb->mContext);
1049     return true;
1050 }
1051
1052 bool emberAfDoorLockClusterSetPinResponseCallback(uint8_t status)
1053 {
1054     ChipLogProgress(Zcl, "SetPinResponse:");
1055     LogStatus(status);
1056
1057     GET_RESPONSE_CALLBACKS("DoorLockClusterSetPinResponseCallback");
1058
1059     if (status != EMBER_ZCL_STATUS_SUCCESS)
1060     {
1061         Callback::Callback<DefaultFailureCallback> * cb =
1062             Callback::Callback<DefaultFailureCallback>::FromCancelable(onFailureCallback);
1063         cb->mCall(cb->mContext, status);
1064         return true;
1065     }
1066
1067     Callback::Callback<DoorLockClusterSetPinResponseCallback> * cb =
1068         Callback::Callback<DoorLockClusterSetPinResponseCallback>::FromCancelable(onSuccessCallback);
1069     cb->mCall(cb->mContext);
1070     return true;
1071 }
1072
1073 bool emberAfDoorLockClusterSetRfidResponseCallback(uint8_t status)
1074 {
1075     ChipLogProgress(Zcl, "SetRfidResponse:");
1076     LogStatus(status);
1077
1078     GET_RESPONSE_CALLBACKS("DoorLockClusterSetRfidResponseCallback");
1079
1080     if (status != EMBER_ZCL_STATUS_SUCCESS)
1081     {
1082         Callback::Callback<DefaultFailureCallback> * cb =
1083             Callback::Callback<DefaultFailureCallback>::FromCancelable(onFailureCallback);
1084         cb->mCall(cb->mContext, status);
1085         return true;
1086     }
1087
1088     Callback::Callback<DoorLockClusterSetRfidResponseCallback> * cb =
1089         Callback::Callback<DoorLockClusterSetRfidResponseCallback>::FromCancelable(onSuccessCallback);
1090     cb->mCall(cb->mContext);
1091     return true;
1092 }
1093
1094 bool emberAfDoorLockClusterSetUserTypeResponseCallback(uint8_t status)
1095 {
1096     ChipLogProgress(Zcl, "SetUserTypeResponse:");
1097     LogStatus(status);
1098
1099     GET_RESPONSE_CALLBACKS("DoorLockClusterSetUserTypeResponseCallback");
1100
1101     if (status != EMBER_ZCL_STATUS_SUCCESS)
1102     {
1103         Callback::Callback<DefaultFailureCallback> * cb =
1104             Callback::Callback<DefaultFailureCallback>::FromCancelable(onFailureCallback);
1105         cb->mCall(cb->mContext, status);
1106         return true;
1107     }
1108
1109     Callback::Callback<DoorLockClusterSetUserTypeResponseCallback> * cb =
1110         Callback::Callback<DoorLockClusterSetUserTypeResponseCallback>::FromCancelable(onSuccessCallback);
1111     cb->mCall(cb->mContext);
1112     return true;
1113 }
1114
1115 bool emberAfDoorLockClusterSetWeekdayScheduleResponseCallback(uint8_t status)
1116 {
1117     ChipLogProgress(Zcl, "SetWeekdayScheduleResponse:");
1118     LogStatus(status);
1119
1120     GET_RESPONSE_CALLBACKS("DoorLockClusterSetWeekdayScheduleResponseCallback");
1121
1122     if (status != EMBER_ZCL_STATUS_SUCCESS)
1123     {
1124         Callback::Callback<DefaultFailureCallback> * cb =
1125             Callback::Callback<DefaultFailureCallback>::FromCancelable(onFailureCallback);
1126         cb->mCall(cb->mContext, status);
1127         return true;
1128     }
1129
1130     Callback::Callback<DoorLockClusterSetWeekdayScheduleResponseCallback> * cb =
1131         Callback::Callback<DoorLockClusterSetWeekdayScheduleResponseCallback>::FromCancelable(onSuccessCallback);
1132     cb->mCall(cb->mContext);
1133     return true;
1134 }
1135
1136 bool emberAfDoorLockClusterSetYeardayScheduleResponseCallback(uint8_t status)
1137 {
1138     ChipLogProgress(Zcl, "SetYeardayScheduleResponse:");
1139     LogStatus(status);
1140
1141     GET_RESPONSE_CALLBACKS("DoorLockClusterSetYeardayScheduleResponseCallback");
1142
1143     if (status != EMBER_ZCL_STATUS_SUCCESS)
1144     {
1145         Callback::Callback<DefaultFailureCallback> * cb =
1146             Callback::Callback<DefaultFailureCallback>::FromCancelable(onFailureCallback);
1147         cb->mCall(cb->mContext, status);
1148         return true;
1149     }
1150
1151     Callback::Callback<DoorLockClusterSetYeardayScheduleResponseCallback> * cb =
1152         Callback::Callback<DoorLockClusterSetYeardayScheduleResponseCallback>::FromCancelable(onSuccessCallback);
1153     cb->mCall(cb->mContext);
1154     return true;
1155 }
1156
1157 bool emberAfDoorLockClusterUnlockDoorResponseCallback(uint8_t status)
1158 {
1159     ChipLogProgress(Zcl, "UnlockDoorResponse:");
1160     LogStatus(status);
1161
1162     GET_RESPONSE_CALLBACKS("DoorLockClusterUnlockDoorResponseCallback");
1163
1164     if (status != EMBER_ZCL_STATUS_SUCCESS)
1165     {
1166         Callback::Callback<DefaultFailureCallback> * cb =
1167             Callback::Callback<DefaultFailureCallback>::FromCancelable(onFailureCallback);
1168         cb->mCall(cb->mContext, status);
1169         return true;
1170     }
1171
1172     Callback::Callback<DoorLockClusterUnlockDoorResponseCallback> * cb =
1173         Callback::Callback<DoorLockClusterUnlockDoorResponseCallback>::FromCancelable(onSuccessCallback);
1174     cb->mCall(cb->mContext);
1175     return true;
1176 }
1177
1178 bool emberAfDoorLockClusterUnlockWithTimeoutResponseCallback(uint8_t status)
1179 {
1180     ChipLogProgress(Zcl, "UnlockWithTimeoutResponse:");
1181     LogStatus(status);
1182
1183     GET_RESPONSE_CALLBACKS("DoorLockClusterUnlockWithTimeoutResponseCallback");
1184
1185     if (status != EMBER_ZCL_STATUS_SUCCESS)
1186     {
1187         Callback::Callback<DefaultFailureCallback> * cb =
1188             Callback::Callback<DefaultFailureCallback>::FromCancelable(onFailureCallback);
1189         cb->mCall(cb->mContext, status);
1190         return true;
1191     }
1192
1193     Callback::Callback<DoorLockClusterUnlockWithTimeoutResponseCallback> * cb =
1194         Callback::Callback<DoorLockClusterUnlockWithTimeoutResponseCallback>::FromCancelable(onSuccessCallback);
1195     cb->mCall(cb->mContext);
1196     return true;
1197 }
1198
1199 bool emberAfGeneralCommissioningClusterArmFailSafeResponseCallback(uint8_t errorCode, uint8_t * debugText)
1200 {
1201     ChipLogProgress(Zcl, "ArmFailSafeResponse:");
1202     ChipLogProgress(Zcl, "  errorCode: %" PRIu8 "", errorCode);
1203     ChipLogProgress(Zcl, "  debugText: %s", debugText);
1204
1205     GET_RESPONSE_CALLBACKS("GeneralCommissioningClusterArmFailSafeResponseCallback");
1206
1207     Callback::Callback<GeneralCommissioningClusterArmFailSafeResponseCallback> * cb =
1208         Callback::Callback<GeneralCommissioningClusterArmFailSafeResponseCallback>::FromCancelable(onSuccessCallback);
1209     cb->mCall(cb->mContext, errorCode, debugText);
1210     return true;
1211 }
1212
1213 bool emberAfGeneralCommissioningClusterCommissioningCompleteResponseCallback(uint8_t errorCode, uint8_t * debugText)
1214 {
1215     ChipLogProgress(Zcl, "CommissioningCompleteResponse:");
1216     ChipLogProgress(Zcl, "  errorCode: %" PRIu8 "", errorCode);
1217     ChipLogProgress(Zcl, "  debugText: %s", debugText);
1218
1219     GET_RESPONSE_CALLBACKS("GeneralCommissioningClusterCommissioningCompleteResponseCallback");
1220
1221     Callback::Callback<GeneralCommissioningClusterCommissioningCompleteResponseCallback> * cb =
1222         Callback::Callback<GeneralCommissioningClusterCommissioningCompleteResponseCallback>::FromCancelable(onSuccessCallback);
1223     cb->mCall(cb->mContext, errorCode, debugText);
1224     return true;
1225 }
1226
1227 bool emberAfGeneralCommissioningClusterSetFabricResponseCallback(uint8_t errorCode, uint8_t * debugText)
1228 {
1229     ChipLogProgress(Zcl, "SetFabricResponse:");
1230     ChipLogProgress(Zcl, "  errorCode: %" PRIu8 "", errorCode);
1231     ChipLogProgress(Zcl, "  debugText: %s", debugText);
1232
1233     GET_RESPONSE_CALLBACKS("GeneralCommissioningClusterSetFabricResponseCallback");
1234
1235     Callback::Callback<GeneralCommissioningClusterSetFabricResponseCallback> * cb =
1236         Callback::Callback<GeneralCommissioningClusterSetFabricResponseCallback>::FromCancelable(onSuccessCallback);
1237     cb->mCall(cb->mContext, errorCode, debugText);
1238     return true;
1239 }
1240
1241 bool emberAfGroupsClusterAddGroupResponseCallback(uint8_t status, uint16_t groupId)
1242 {
1243     ChipLogProgress(Zcl, "AddGroupResponse:");
1244     LogStatus(status);
1245     ChipLogProgress(Zcl, "  groupId: %" PRIu16 "", groupId);
1246
1247     GET_RESPONSE_CALLBACKS("GroupsClusterAddGroupResponseCallback");
1248
1249     if (status != EMBER_ZCL_STATUS_SUCCESS)
1250     {
1251         Callback::Callback<DefaultFailureCallback> * cb =
1252             Callback::Callback<DefaultFailureCallback>::FromCancelable(onFailureCallback);
1253         cb->mCall(cb->mContext, status);
1254         return true;
1255     }
1256
1257     Callback::Callback<GroupsClusterAddGroupResponseCallback> * cb =
1258         Callback::Callback<GroupsClusterAddGroupResponseCallback>::FromCancelable(onSuccessCallback);
1259     cb->mCall(cb->mContext, groupId);
1260     return true;
1261 }
1262
1263 bool emberAfGroupsClusterGetGroupMembershipResponseCallback(uint8_t capacity, uint8_t groupCount,
1264                                                             /* TYPE WARNING: array array defaults to */ uint8_t * groupList)
1265 {
1266     ChipLogProgress(Zcl, "GetGroupMembershipResponse:");
1267     ChipLogProgress(Zcl, "  capacity: %" PRIu8 "", capacity);
1268     ChipLogProgress(Zcl, "  groupCount: %" PRIu8 "", groupCount);
1269     ChipLogProgress(Zcl, "  groupList: %p", groupList);
1270
1271     GET_RESPONSE_CALLBACKS("GroupsClusterGetGroupMembershipResponseCallback");
1272
1273     Callback::Callback<GroupsClusterGetGroupMembershipResponseCallback> * cb =
1274         Callback::Callback<GroupsClusterGetGroupMembershipResponseCallback>::FromCancelable(onSuccessCallback);
1275     cb->mCall(cb->mContext, capacity, groupCount, groupList);
1276     return true;
1277 }
1278
1279 bool emberAfGroupsClusterRemoveGroupResponseCallback(uint8_t status, uint16_t groupId)
1280 {
1281     ChipLogProgress(Zcl, "RemoveGroupResponse:");
1282     LogStatus(status);
1283     ChipLogProgress(Zcl, "  groupId: %" PRIu16 "", groupId);
1284
1285     GET_RESPONSE_CALLBACKS("GroupsClusterRemoveGroupResponseCallback");
1286
1287     if (status != EMBER_ZCL_STATUS_SUCCESS)
1288     {
1289         Callback::Callback<DefaultFailureCallback> * cb =
1290             Callback::Callback<DefaultFailureCallback>::FromCancelable(onFailureCallback);
1291         cb->mCall(cb->mContext, status);
1292         return true;
1293     }
1294
1295     Callback::Callback<GroupsClusterRemoveGroupResponseCallback> * cb =
1296         Callback::Callback<GroupsClusterRemoveGroupResponseCallback>::FromCancelable(onSuccessCallback);
1297     cb->mCall(cb->mContext, groupId);
1298     return true;
1299 }
1300
1301 bool emberAfGroupsClusterViewGroupResponseCallback(uint8_t status, uint16_t groupId, uint8_t * groupName)
1302 {
1303     ChipLogProgress(Zcl, "ViewGroupResponse:");
1304     LogStatus(status);
1305     ChipLogProgress(Zcl, "  groupId: %" PRIu16 "", groupId);
1306     ChipLogProgress(Zcl, "  groupName: %s", groupName);
1307
1308     GET_RESPONSE_CALLBACKS("GroupsClusterViewGroupResponseCallback");
1309
1310     if (status != EMBER_ZCL_STATUS_SUCCESS)
1311     {
1312         Callback::Callback<DefaultFailureCallback> * cb =
1313             Callback::Callback<DefaultFailureCallback>::FromCancelable(onFailureCallback);
1314         cb->mCall(cb->mContext, status);
1315         return true;
1316     }
1317
1318     Callback::Callback<GroupsClusterViewGroupResponseCallback> * cb =
1319         Callback::Callback<GroupsClusterViewGroupResponseCallback>::FromCancelable(onSuccessCallback);
1320     cb->mCall(cb->mContext, groupId, groupName);
1321     return true;
1322 }
1323
1324 bool emberAfIdentifyClusterIdentifyQueryResponseCallback(uint16_t timeout)
1325 {
1326     ChipLogProgress(Zcl, "IdentifyQueryResponse:");
1327     ChipLogProgress(Zcl, "  timeout: %" PRIu16 "", timeout);
1328
1329     GET_RESPONSE_CALLBACKS("IdentifyClusterIdentifyQueryResponseCallback");
1330
1331     Callback::Callback<IdentifyClusterIdentifyQueryResponseCallback> * cb =
1332         Callback::Callback<IdentifyClusterIdentifyQueryResponseCallback>::FromCancelable(onSuccessCallback);
1333     cb->mCall(cb->mContext, timeout);
1334     return true;
1335 }
1336
1337 bool emberAfScenesClusterAddSceneResponseCallback(uint8_t status, uint16_t groupId, uint8_t sceneId)
1338 {
1339     ChipLogProgress(Zcl, "AddSceneResponse:");
1340     LogStatus(status);
1341     ChipLogProgress(Zcl, "  groupId: %" PRIu16 "", groupId);
1342     ChipLogProgress(Zcl, "  sceneId: %" PRIu8 "", sceneId);
1343
1344     GET_RESPONSE_CALLBACKS("ScenesClusterAddSceneResponseCallback");
1345
1346     if (status != EMBER_ZCL_STATUS_SUCCESS)
1347     {
1348         Callback::Callback<DefaultFailureCallback> * cb =
1349             Callback::Callback<DefaultFailureCallback>::FromCancelable(onFailureCallback);
1350         cb->mCall(cb->mContext, status);
1351         return true;
1352     }
1353
1354     Callback::Callback<ScenesClusterAddSceneResponseCallback> * cb =
1355         Callback::Callback<ScenesClusterAddSceneResponseCallback>::FromCancelable(onSuccessCallback);
1356     cb->mCall(cb->mContext, groupId, sceneId);
1357     return true;
1358 }
1359
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)
1362 {
1363     ChipLogProgress(Zcl, "GetSceneMembershipResponse:");
1364     LogStatus(status);
1365     ChipLogProgress(Zcl, "  capacity: %" PRIu8 "", capacity);
1366     ChipLogProgress(Zcl, "  groupId: %" PRIu16 "", groupId);
1367     ChipLogProgress(Zcl, "  sceneCount: %" PRIu8 "", sceneCount);
1368     ChipLogProgress(Zcl, "  sceneList: %p", sceneList);
1369
1370     GET_RESPONSE_CALLBACKS("ScenesClusterGetSceneMembershipResponseCallback");
1371
1372     if (status != EMBER_ZCL_STATUS_SUCCESS)
1373     {
1374         Callback::Callback<DefaultFailureCallback> * cb =
1375             Callback::Callback<DefaultFailureCallback>::FromCancelable(onFailureCallback);
1376         cb->mCall(cb->mContext, status);
1377         return true;
1378     }
1379
1380     Callback::Callback<ScenesClusterGetSceneMembershipResponseCallback> * cb =
1381         Callback::Callback<ScenesClusterGetSceneMembershipResponseCallback>::FromCancelable(onSuccessCallback);
1382     cb->mCall(cb->mContext, capacity, groupId, sceneCount, sceneList);
1383     return true;
1384 }
1385
1386 bool emberAfScenesClusterRemoveAllScenesResponseCallback(uint8_t status, uint16_t groupId)
1387 {
1388     ChipLogProgress(Zcl, "RemoveAllScenesResponse:");
1389     LogStatus(status);
1390     ChipLogProgress(Zcl, "  groupId: %" PRIu16 "", groupId);
1391
1392     GET_RESPONSE_CALLBACKS("ScenesClusterRemoveAllScenesResponseCallback");
1393
1394     if (status != EMBER_ZCL_STATUS_SUCCESS)
1395     {
1396         Callback::Callback<DefaultFailureCallback> * cb =
1397             Callback::Callback<DefaultFailureCallback>::FromCancelable(onFailureCallback);
1398         cb->mCall(cb->mContext, status);
1399         return true;
1400     }
1401
1402     Callback::Callback<ScenesClusterRemoveAllScenesResponseCallback> * cb =
1403         Callback::Callback<ScenesClusterRemoveAllScenesResponseCallback>::FromCancelable(onSuccessCallback);
1404     cb->mCall(cb->mContext, groupId);
1405     return true;
1406 }
1407
1408 bool emberAfScenesClusterRemoveSceneResponseCallback(uint8_t status, uint16_t groupId, uint8_t sceneId)
1409 {
1410     ChipLogProgress(Zcl, "RemoveSceneResponse:");
1411     LogStatus(status);
1412     ChipLogProgress(Zcl, "  groupId: %" PRIu16 "", groupId);
1413     ChipLogProgress(Zcl, "  sceneId: %" PRIu8 "", sceneId);
1414
1415     GET_RESPONSE_CALLBACKS("ScenesClusterRemoveSceneResponseCallback");
1416
1417     if (status != EMBER_ZCL_STATUS_SUCCESS)
1418     {
1419         Callback::Callback<DefaultFailureCallback> * cb =
1420             Callback::Callback<DefaultFailureCallback>::FromCancelable(onFailureCallback);
1421         cb->mCall(cb->mContext, status);
1422         return true;
1423     }
1424
1425     Callback::Callback<ScenesClusterRemoveSceneResponseCallback> * cb =
1426         Callback::Callback<ScenesClusterRemoveSceneResponseCallback>::FromCancelable(onSuccessCallback);
1427     cb->mCall(cb->mContext, groupId, sceneId);
1428     return true;
1429 }
1430
1431 bool emberAfScenesClusterStoreSceneResponseCallback(uint8_t status, uint16_t groupId, uint8_t sceneId)
1432 {
1433     ChipLogProgress(Zcl, "StoreSceneResponse:");
1434     LogStatus(status);
1435     ChipLogProgress(Zcl, "  groupId: %" PRIu16 "", groupId);
1436     ChipLogProgress(Zcl, "  sceneId: %" PRIu8 "", sceneId);
1437
1438     GET_RESPONSE_CALLBACKS("ScenesClusterStoreSceneResponseCallback");
1439
1440     if (status != EMBER_ZCL_STATUS_SUCCESS)
1441     {
1442         Callback::Callback<DefaultFailureCallback> * cb =
1443             Callback::Callback<DefaultFailureCallback>::FromCancelable(onFailureCallback);
1444         cb->mCall(cb->mContext, status);
1445         return true;
1446     }
1447
1448     Callback::Callback<ScenesClusterStoreSceneResponseCallback> * cb =
1449         Callback::Callback<ScenesClusterStoreSceneResponseCallback>::FromCancelable(onSuccessCallback);
1450     cb->mCall(cb->mContext, groupId, sceneId);
1451     return true;
1452 }
1453
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)
1457 {
1458     ChipLogProgress(Zcl, "ViewSceneResponse:");
1459     LogStatus(status);
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);
1465
1466     GET_RESPONSE_CALLBACKS("ScenesClusterViewSceneResponseCallback");
1467
1468     if (status != EMBER_ZCL_STATUS_SUCCESS)
1469     {
1470         Callback::Callback<DefaultFailureCallback> * cb =
1471             Callback::Callback<DefaultFailureCallback>::FromCancelable(onFailureCallback);
1472         cb->mCall(cb->mContext, status);
1473         return true;
1474     }
1475
1476     Callback::Callback<ScenesClusterViewSceneResponseCallback> * cb =
1477         Callback::Callback<ScenesClusterViewSceneResponseCallback>::FromCancelable(onSuccessCallback);
1478     cb->mCall(cb->mContext, groupId, sceneId, transitionTime, sceneName, extensionFieldSets);
1479     return true;
1480 }
1481
1482 bool emberAfReportAttributesCallback(ClusterId clusterId, uint8_t * message, uint16_t messageLen)
1483 {
1484     ChipLogProgress(Zcl, "emberAfReportAttributeCallback:");
1485     ChipLogProgress(Zcl, "  ClusterId: 0x%04x", clusterId);
1486
1487     NodeId sourceId = emberAfCurrentCommand()->source;
1488     ChipLogProgress(Zcl, "  Source NodeId: %" PRIu64, sourceId);
1489
1490     EndpointId endpointId = emberAfCurrentCommand()->apsFrame->sourceEndpoint;
1491     ChipLogProgress(Zcl, "  Source EndpointId: 0x%04x", endpointId);
1492
1493     // TODO onFailureCallback is just here because of the CHECK_MESSAGE_LENGTH macro. It needs to be removed.
1494     Callback::Cancelable * onFailureCallback = nullptr;
1495
1496     while (messageLen)
1497     {
1498         CHECK_MESSAGE_LENGTH(2);
1499         uint16_t attributeId = chip::Encoding::LittleEndian::Read16(message); // attribId
1500         ChipLogProgress(Zcl, "  attributeId: 0x%04x", attributeId);
1501
1502         GET_REPORT_CALLBACK("emberAfReportAttributesCallback");
1503
1504         CHECK_MESSAGE_LENGTH(1);
1505         uint8_t attributeType = chip::Encoding::Read8(message);
1506         ChipLogProgress(Zcl, "  attributeType: 0x%02x", attributeType);
1507
1508         switch (attributeType)
1509         {
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
1535         {
1536             ChipLogError(Zcl, "attributeType 0x%02x is not supported", attributeType);
1537             return true;
1538         }
1539
1540         case 0x41: // octstr / Octet string
1541         case 0x42: // string / Character string
1542         {
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);
1547
1548             // When the length is set to 0xFF, it represents a non-value. In this case the data field is zero length.
1549             if (length == 0xFF)
1550             {
1551                 length = 0;
1552             }
1553
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));
1558             break;
1559         }
1560
1561         case 0x43: // octstr16 / Long octet string
1562         case 0x44: // string16 / Long character string
1563         {
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);
1568
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)
1571             {
1572                 length = 0;
1573             }
1574
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));
1579             break;
1580         }
1581
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
1586         {
1587             CHECK_MESSAGE_LENGTH(1);
1588             uint8_t value = chip::Encoding::Read8(message);
1589             ChipLogProgress(Zcl, "  value: 0x%02x", value);
1590
1591             Callback::Callback<Int8uAttributeCallback> * cb =
1592                 Callback::Callback<Int8uAttributeCallback>::FromCancelable(onReportCallback);
1593             cb->mCall(cb->mContext, value);
1594             break;
1595         }
1596
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
1606         {
1607             CHECK_MESSAGE_LENGTH(2);
1608             uint16_t value = chip::Encoding::LittleEndian::Read16(message);
1609             ChipLogProgress(Zcl, "  value: 0x%04x", value);
1610
1611             Callback::Callback<Int16uAttributeCallback> * cb =
1612                 Callback::Callback<Int16uAttributeCallback>::FromCancelable(onReportCallback);
1613             cb->mCall(cb->mContext, value);
1614             break;
1615         }
1616
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
1622         {
1623             CHECK_MESSAGE_LENGTH(4);
1624             uint32_t value = chip::Encoding::LittleEndian::Read32(message);
1625             ChipLogProgress(Zcl, "  value: 0x%08x", value);
1626
1627             Callback::Callback<Int32uAttributeCallback> * cb =
1628                 Callback::Callback<Int32uAttributeCallback>::FromCancelable(onReportCallback);
1629             cb->mCall(cb->mContext, value);
1630             break;
1631         }
1632
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
1637         {
1638             CHECK_MESSAGE_LENGTH(8);
1639             uint64_t value = chip::Encoding::LittleEndian::Read64(message);
1640             ChipLogProgress(Zcl, "  value: 0x%16x", value);
1641
1642             Callback::Callback<Int64uAttributeCallback> * cb =
1643                 Callback::Callback<Int64uAttributeCallback>::FromCancelable(onReportCallback);
1644             cb->mCall(cb->mContext, value);
1645             break;
1646         }
1647
1648         case 0x10: // bool / Boolean
1649         {
1650             CHECK_MESSAGE_LENGTH(1);
1651             uint8_t value = chip::Encoding::Read8(message);
1652             ChipLogProgress(Zcl, "  value: %d", value);
1653
1654             Callback::Callback<BooleanAttributeCallback> * cb =
1655                 Callback::Callback<BooleanAttributeCallback>::FromCancelable(onReportCallback);
1656             cb->mCall(cb->mContext, value);
1657             break;
1658         }
1659
1660         case 0x28: // int8 / Signed 8-bit integer
1661         {
1662             CHECK_MESSAGE_LENGTH(1);
1663             int8_t value = chip::CastToSigned(chip::Encoding::Read8(message));
1664             ChipLogProgress(Zcl, "  value: %" PRId8, value);
1665
1666             Callback::Callback<Int8sAttributeCallback> * cb =
1667                 Callback::Callback<Int8sAttributeCallback>::FromCancelable(onReportCallback);
1668             cb->mCall(cb->mContext, value);
1669             break;
1670         }
1671
1672         case 0x29: // int16 / Signed 16-bit integer
1673         {
1674             CHECK_MESSAGE_LENGTH(2);
1675             int16_t value = chip::CastToSigned(chip::Encoding::LittleEndian::Read16(message));
1676             ChipLogProgress(Zcl, "  value: %" PRId16, value);
1677
1678             Callback::Callback<Int16sAttributeCallback> * cb =
1679                 Callback::Callback<Int16sAttributeCallback>::FromCancelable(onReportCallback);
1680             cb->mCall(cb->mContext, value);
1681             break;
1682         }
1683
1684         case 0x2B: // int32 / Signed 32-bit integer
1685         {
1686             CHECK_MESSAGE_LENGTH(4);
1687             int32_t value = chip::CastToSigned(chip::Encoding::LittleEndian::Read32(message));
1688             ChipLogProgress(Zcl, "  value: %" PRId32, value);
1689
1690             Callback::Callback<Int32sAttributeCallback> * cb =
1691                 Callback::Callback<Int32sAttributeCallback>::FromCancelable(onReportCallback);
1692             cb->mCall(cb->mContext, value);
1693             break;
1694         }
1695
1696         case 0x2F: // int64 / Signed 64-bit integer
1697         {
1698             CHECK_MESSAGE_LENGTH(8);
1699             int64_t value = chip::CastToSigned(chip::Encoding::LittleEndian::Read64(message));
1700             ChipLogProgress(Zcl, "  value: %" PRId64, value);
1701
1702             Callback::Callback<Int64sAttributeCallback> * cb =
1703                 Callback::Callback<Int64sAttributeCallback>::FromCancelable(onReportCallback);
1704             cb->mCall(cb->mContext, value);
1705             break;
1706         }
1707         }
1708     }
1709
1710     return true;
1711 }