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 0x41: // octstr / Octet string
 276             case 0x42: // string / Character string
 277             case 0x43: // octstr16 / Long octet string
 278             case 0x44: // string16 / Long character string
 279             case 0x48: // array / Array
 280             case 0x49: // struct / Structure
 281             case 0x50: // set / Set
 282             case 0x51: // bag / Bag
 283             case 0xE0: // ToD / Time of day
 284             {
 285                 ChipLogError(Zcl, "attributeType 0x%02x is not supported", attributeType);
 286                 Callback::Callback<DefaultFailureCallback> * cb =
 287                     Callback::Callback<DefaultFailureCallback>::FromCancelable(onFailureCallback);
 288                 cb->mCall(cb->mContext, EMBER_ZCL_STATUS_INVALID_VALUE);
 289                 return true;
 290             }
 291
 292             case 0x08: // data8 / 8-bit data
 293             case 0x18: // map8 / 8-bit bitmap
 294             case 0x20: // uint8 / Unsigned  8-bit integer
 295             case 0x30: // enum8 / 8-bit enumeration
 296             {
 297                 CHECK_MESSAGE_LENGTH(1);
 298                 uint8_t value = chip::Encoding::Read8(message);
 299                 ChipLogProgress(Zcl, "  value: 0x%02x", value);
 300
 301                 Callback::Callback<Int8uAttributeCallback> * cb =
 302                     Callback::Callback<Int8uAttributeCallback>::FromCancelable(onSuccessCallback);
 303                 cb->mCall(cb->mContext, value);
 304                 break;
 305             }
 306
 307             case 0x09: // data16 / 16-bit data
 308             case 0x19: // map16 / 16-bit bitmap
 309             case 0x21: // uint16 / Unsigned 16-bit integer
 310             case 0x31: // enum16 / 16-bit enumeration
 311             case 0xE8: // clusterId / Cluster ID
 312             case 0xE9: // attribId / Attribute ID
 313             case 0xEA: // bacOID / BACnet OID
 314             case 0xF1: // key128 / 128-bit security key
 315             case 0xFF: // unk / Unknown
 316             {
 317                 CHECK_MESSAGE_LENGTH(2);
 318                 uint16_t value = chip::Encoding::LittleEndian::Read16(message);
 319                 ChipLogProgress(Zcl, "  value: 0x%04x", value);
 320
 321                 Callback::Callback<Int16uAttributeCallback> * cb =
 322                     Callback::Callback<Int16uAttributeCallback>::FromCancelable(onSuccessCallback);
 323                 cb->mCall(cb->mContext, value);
 324                 break;
 325             }
 326
 327             case 0x0B: // data32 / 32-bit data
 328             case 0x1B: // map32 / 32-bit bitmap
 329             case 0x23: // uint32 / Unsigned 32-bit integer
 330             case 0xE1: // date / Date
 331             case 0xE2: // UTC / UTCTime
 332             {
 333                 CHECK_MESSAGE_LENGTH(4);
 334                 uint32_t value = chip::Encoding::LittleEndian::Read32(message);
 335                 ChipLogProgress(Zcl, "  value: 0x%08x", value);
 336
 337                 Callback::Callback<Int32uAttributeCallback> * cb =
 338                     Callback::Callback<Int32uAttributeCallback>::FromCancelable(onSuccessCallback);
 339                 cb->mCall(cb->mContext, value);
 340                 break;
 341             }
 342
 343             case 0x0F: // data64 / 64-bit data
 344             case 0x1F: // map64 / 64-bit bitmap
 345             case 0x27: // uint64 / Unsigned 64-bit integer
 346             case 0xF0: // EUI64 / IEEE address
 347             {
 348                 CHECK_MESSAGE_LENGTH(8);
 349                 uint64_t value = chip::Encoding::LittleEndian::Read64(message);
 350                 ChipLogProgress(Zcl, "  value: 0x%16x", value);
 351
 352                 Callback::Callback<Int64uAttributeCallback> * cb =
 353                     Callback::Callback<Int64uAttributeCallback>::FromCancelable(onSuccessCallback);
 354                 cb->mCall(cb->mContext, value);
 355                 break;
 356             }
 357
 358             case 0x10: // bool / Boolean
 359             {
 360                 CHECK_MESSAGE_LENGTH(1);
 361                 uint8_t value = chip::Encoding::Read8(message);
 362                 ChipLogProgress(Zcl, "  value: %d", value);
 363
 364                 Callback::Callback<BooleanAttributeCallback> * cb =
 365                     Callback::Callback<BooleanAttributeCallback>::FromCancelable(onSuccessCallback);
 366                 cb->mCall(cb->mContext, value);
 367                 break;
 368             }
 369
 370             case 0x28: // int8 / Signed 8-bit integer
 371             {
 372                 CHECK_MESSAGE_LENGTH(1);
 373                 int8_t value = chip::CastToSigned(chip::Encoding::Read8(message));
 374                 ChipLogProgress(Zcl, "  value: %" PRId8, value);
 375
 376                 Callback::Callback<Int8sAttributeCallback> * cb =
 377                     Callback::Callback<Int8sAttributeCallback>::FromCancelable(onSuccessCallback);
 378                 cb->mCall(cb->mContext, value);
 379                 break;
 380             }
 381
 382             case 0x29: // int16 / Signed 16-bit integer
 383             {
 384                 CHECK_MESSAGE_LENGTH(2);
 385                 int16_t value = chip::CastToSigned(chip::Encoding::LittleEndian::Read16(message));
 386                 ChipLogProgress(Zcl, "  value: %" PRId16, value);
 387
 388                 Callback::Callback<Int16sAttributeCallback> * cb =
 389                     Callback::Callback<Int16sAttributeCallback>::FromCancelable(onSuccessCallback);
 390                 cb->mCall(cb->mContext, value);
 391                 break;
 392             }
 393
 394             case 0x2B: // int32 / Signed 32-bit integer
 395             {
 396                 CHECK_MESSAGE_LENGTH(4);
 397                 int32_t value = chip::CastToSigned(chip::Encoding::LittleEndian::Read32(message));
 398                 ChipLogProgress(Zcl, "  value: %" PRId32, value);
 399
 400                 Callback::Callback<Int32sAttributeCallback> * cb =
 401                     Callback::Callback<Int32sAttributeCallback>::FromCancelable(onSuccessCallback);
 402                 cb->mCall(cb->mContext, value);
 403                 break;
 404             }
 405
 406             case 0x2F: // int64 / Signed 64-bit integer
 407             {
 408                 CHECK_MESSAGE_LENGTH(8);
 409                 int64_t value = chip::CastToSigned(chip::Encoding::LittleEndian::Read64(message));
 410                 ChipLogProgress(Zcl, "  value: %" PRId64, value);
 411
 412                 Callback::Callback<Int64sAttributeCallback> * cb =
 413                     Callback::Callback<Int64sAttributeCallback>::FromCancelable(onSuccessCallback);
 414                 cb->mCall(cb->mContext, value);
 415                 break;
 416             }
 417             }
 418         }
 419         else
 420         {
 421             Callback::Callback<DefaultFailureCallback> * cb =
 422                 Callback::Callback<DefaultFailureCallback>::FromCancelable(onFailureCallback);
 423             cb->mCall(cb->mContext, status);
 424         }
 425
 426         // The current code is written matching the current API where there is a single attribute read
 427         // per read command. So if multiple attributes are read at the same time, something is wrong
 428         // somewhere.
 429         if (messageLen)
 430         {
 431             ChipLogError(Zcl, "Multiple attributes read at the same time. Something went wrong.");
 432             break;
 433         }
 434     }
 435
 436     return true;
 437 }
 438
 439 bool emberAfWriteAttributesResponseCallback(ClusterId clusterId, uint8_t * message, uint16_t messageLen)
 440 {
 441     ChipLogProgress(Zcl, "WriteAttributesResponse:");
 442     ChipLogProgress(Zcl, "  ClusterId: 0x%04x", clusterId);
 443
 444     GET_RESPONSE_CALLBACKS("emberAfWriteAttributesResponseCallback");
 445
 446     // struct writeAttributeResponseRecord[]
 447     while (messageLen)
 448     {
 449         CHECK_MESSAGE_LENGTH(1);
 450         uint8_t status = chip::Encoding::Read8(message); // zclStatus
 451         LogStatus(status);
 452
 453         if (status == EMBER_ZCL_STATUS_SUCCESS)
 454         {
 455             Callback::Callback<DefaultSuccessCallback> * cb =
 456                 Callback::Callback<DefaultSuccessCallback>::FromCancelable(onSuccessCallback);
 457             cb->mCall(cb->mContext);
 458         }
 459         else
 460         {
 461             CHECK_MESSAGE_LENGTH(2);
 462             uint16_t attributeId = chip::Encoding::LittleEndian::Read16(message); // attribId
 463             ChipLogProgress(Zcl, "  attributeId: 0x%04x", attributeId);
 464
 465             Callback::Callback<DefaultFailureCallback> * cb =
 466                 Callback::Callback<DefaultFailureCallback>::FromCancelable(onFailureCallback);
 467             cb->mCall(cb->mContext, status);
 468         }
 469
 470         // The current code is written matching the current API where there is a single attribute written
 471         // per write command. So if multiple attributes are written at the same time, something is wrong
 472         // somewhere.
 473         if (messageLen)
 474         {
 475             ChipLogError(Zcl, "Multiple attributes written at the same time. Something went wrong.");
 476             break;
 477         }
 478     }
 479
 480     return true;
 481 }
 482
 483 bool emberAfConfigureReportingResponseCallback(ClusterId clusterId, uint8_t * message, uint16_t messageLen)
 484 {
 485     ChipLogProgress(Zcl, "ConfigureReportingResponseCallback:");
 486     ChipLogProgress(Zcl, "  ClusterId: 0x%04x", clusterId);
 487
 488     GET_RESPONSE_CALLBACKS("emberAfConfigureReportingResponseCallback");
 489
 490     // struct configureReportingResponseRecord[]
 491     while (messageLen)
 492     {
 493         CHECK_MESSAGE_LENGTH(1);
 494         uint8_t status = chip::Encoding::Read8(message); // zclStatus
 495         LogStatus(status);
 496
 497         if (status == EMBER_ZCL_STATUS_SUCCESS)
 498         {
 499             Callback::Callback<DefaultSuccessCallback> * cb =
 500                 Callback::Callback<DefaultSuccessCallback>::FromCancelable(onSuccessCallback);
 501             cb->mCall(cb->mContext);
 502         }
 503         else
 504         {
 505             CHECK_MESSAGE_LENGTH(1);
 506             uint8_t direction = chip::Encoding::Read8(message); // reportingRole
 507             ChipLogProgress(Zcl, "  direction: 0x%02x", direction);
 508
 509             CHECK_MESSAGE_LENGTH(2);
 510             uint16_t attributeId = chip::Encoding::LittleEndian::Read16(message); // attribId
 511             ChipLogProgress(Zcl, "  attributeId: 0x%04x", attributeId);
 512
 513             Callback::Callback<DefaultFailureCallback> * cb =
 514                 Callback::Callback<DefaultFailureCallback>::FromCancelable(onFailureCallback);
 515             cb->mCall(cb->mContext, status);
 516         }
 517
 518         // The current code is written matching the current API where there is a single attribute report
 519         // per configure command. So if multiple attributes are configured at the same time, something is wrong
 520         // somewhere.
 521         if (messageLen)
 522         {
 523             ChipLogError(Zcl, "Multiple attributes reports configured at the same time. Something went wrong.");
 524             break;
 525         }
 526     }
 527
 528     return true;
 529 }
 530
 531 bool emberAfReadReportingConfigurationResponseCallback(chip::ClusterId clusterId, uint8_t * message, uint16_t messageLen)
 532 {
 533     ChipLogProgress(Zcl, "ReadReportingConfigurationResponse:");
 534     ChipLogProgress(Zcl, "  ClusterId: 0x%04x", clusterId);
 535
 536     GET_RESPONSE_CALLBACKS("emberAfReadReportingConfigurationResponseCallback");
 537
 538     // struct readReportingConfigurationResponseRecord[]
 539     while (messageLen)
 540     {
 541         CHECK_MESSAGE_LENGTH(1);
 542         uint8_t direction = chip::Encoding::Read8(message); // reportingRole
 543         ChipLogProgress(Zcl, "  direction: 0x%02x", direction);
 544
 545         CHECK_MESSAGE_LENGTH(2);
 546         uint16_t attributeId = chip::Encoding::LittleEndian::Read16(message); // attribId
 547         ChipLogProgress(Zcl, "  attributeId: 0x%04x", attributeId);
 548
 549         if (direction == EMBER_ZCL_REPORTING_DIRECTION_REPORTED)
 550         {
 551             CHECK_MESSAGE_LENGTH(1);
 552             uint8_t attributeType = chip::Encoding::Read8(message); // zclType
 553             ChipLogProgress(Zcl, "  attributeType: 0x%02x", attributeType);
 554
 555             CHECK_MESSAGE_LENGTH(2);
 556             uint16_t minimumReportingInterval = chip::Encoding::LittleEndian::Read16(message); // uint16
 557             ChipLogProgress(Zcl, "  minimumReportingInterval: %" PRIu16, minimumReportingInterval);
 558
 559             CHECK_MESSAGE_LENGTH(2);
 560             uint16_t maximumReportingInterval = chip::Encoding::LittleEndian::Read16(message); // uint16
 561             ChipLogProgress(Zcl, "  maximumReportingInterval: %" PRIu16, maximumReportingInterval);
 562
 563             // FIXME: unk is not supported yet.
 564
 565             Callback::Callback<ReadReportingConfigurationReportedCallback> * cb =
 566                 Callback::Callback<ReadReportingConfigurationReportedCallback>::FromCancelable(onSuccessCallback);
 567             cb->mCall(cb->mContext, minimumReportingInterval, maximumReportingInterval);
 568         }
 569         else
 570         {
 571             CHECK_MESSAGE_LENGTH(2);
 572             uint16_t timeout = chip::Encoding::LittleEndian::Read16(message); // uint16
 573             ChipLogProgress(Zcl, "  timeout: %" PRIu16, timeout);
 574
 575             Callback::Callback<ReadReportingConfigurationReceivedCallback> * cb =
 576                 Callback::Callback<ReadReportingConfigurationReceivedCallback>::FromCancelable(onSuccessCallback);
 577             cb->mCall(cb->mContext, timeout);
 578         }
 579     }
 580
 581     return true;
 582 }
 583
 584 bool emberAfDiscoverAttributesResponseCallback(ClusterId clusterId, bool discoveryComplete, uint8_t * message, uint16_t messageLen,
 585                                                bool extended)
 586 {
 587     ChipLogProgress(Zcl, "DiscoverAttributesResponse:");
 588     ChipLogProgress(Zcl, "  ClusterId: 0x%04x", clusterId);
 589     ChipLogProgress(Zcl, "  discoveryComplete: %d", discoveryComplete);
 590     ChipLogProgress(Zcl, "  extended: %d", extended);
 591
 592     GET_RESPONSE_CALLBACKS("emberAfDiscoverAttributesCallback");
 593
 594     // struct discoverAttributesResponseRecord[]
 595     while (messageLen)
 596     {
 597         CHECK_MESSAGE_LENGTH(2);
 598         uint16_t attributeId = chip::Encoding::LittleEndian::Read16(message); // attribId
 599         ChipLogProgress(Zcl, "  attributeId: 0x%04x", attributeId);
 600
 601         CHECK_MESSAGE_LENGTH(1);
 602         uint8_t attributeType = chip::Encoding::Read8(message); // zclType
 603         ChipLogProgress(Zcl, "  attributeType: 0x%02x", attributeType);
 604     }
 605
 606     Callback::Callback<DefaultSuccessCallback> * cb = Callback::Callback<DefaultSuccessCallback>::FromCancelable(onSuccessCallback);
 607     cb->mCall(cb->mContext);
 608     return true;
 609 }
 610
 611 bool emberAfDiscoverCommandsGeneratedResponseCallback(ClusterId clusterId, uint16_t manufacturerCode, bool discoveryComplete,
 612                                                       CommandId * commandIds, uint16_t commandIdCount)
 613 {
 614     ChipLogProgress(Zcl, "DiscoverCommandsGeneratedResponse:");
 615     ChipLogProgress(Zcl, "  ClusterId: 0x%04x", clusterId);
 616     ChipLogProgress(Zcl, "  manufacturerCode: 0x%04x", manufacturerCode);
 617     ChipLogProgress(Zcl, "  discoveryComplete: %d", discoveryComplete);
 618     ChipLogProgress(Zcl, "  commandIdCount: %" PRIu16, commandIdCount);
 619
 620     for (uint16_t i = 0; i < commandIdCount; i++)
 621     {
 622         ChipLogProgress(Zcl, "  commandId: 0x%02x", commandIds++);
 623     }
 624
 625     GET_RESPONSE_CALLBACKS("emberAfDiscoverCommandsGeneratedResponseCallback");
 626     Callback::Callback<DefaultSuccessCallback> * cb = Callback::Callback<DefaultSuccessCallback>::FromCancelable(onSuccessCallback);
 627     cb->mCall(cb->mContext);
 628     return true;
 629 }
 630
 631 bool emberAfDiscoverCommandsReceivedResponseCallback(ClusterId clusterId, uint16_t manufacturerCode, bool discoveryComplete,
 632                                                      CommandId * commandIds, uint16_t commandIdCount)
 633 {
 634     ChipLogProgress(Zcl, "DiscoverCommandsReceivedResponse:");
 635     ChipLogProgress(Zcl, "  ClusterId: 0x%04x", clusterId);
 636     ChipLogProgress(Zcl, "  manufacturerCode: 0x%04x", manufacturerCode);
 637     ChipLogProgress(Zcl, "  discoveryComplete: %d", discoveryComplete);
 638     ChipLogProgress(Zcl, "  commandIdCount: %" PRIu16, commandIdCount);
 639
 640     for (uint16_t i = 0; i < commandIdCount; i++)
 641     {
 642         ChipLogProgress(Zcl, "  commandId: 0x%02x", commandIds++);
 643     }
 644
 645     GET_RESPONSE_CALLBACKS("emberAfDiscoverCommandsGeneratedResponseCallback");
 646     Callback::Callback<DefaultSuccessCallback> * cb = Callback::Callback<DefaultSuccessCallback>::FromCancelable(onSuccessCallback);
 647     cb->mCall(cb->mContext);
 648     return true;
 649 }
 650
 651 bool emberAfContentLaunchClusterLaunchContentResponseCallback(uint8_t contentLaunchStatus)
 652 {
 653     ChipLogProgress(Zcl, "LaunchContentResponse:");
 654     ChipLogProgress(Zcl, "  contentLaunchStatus: %" PRIu8 "", contentLaunchStatus);
 655
 656     GET_RESPONSE_CALLBACKS("ContentLaunchClusterLaunchContentResponseCallback");
 657
 658     Callback::Callback<ContentLaunchClusterLaunchContentResponseCallback> * cb =
 659         Callback::Callback<ContentLaunchClusterLaunchContentResponseCallback>::FromCancelable(onSuccessCallback);
 660     cb->mCall(cb->mContext, contentLaunchStatus);
 661     return true;
 662 }
 663
 664 bool emberAfContentLaunchClusterLaunchURLResponseCallback(uint8_t contentLaunchStatus)
 665 {
 666     ChipLogProgress(Zcl, "LaunchURLResponse:");
 667     ChipLogProgress(Zcl, "  contentLaunchStatus: %" PRIu8 "", contentLaunchStatus);
 668
 669     GET_RESPONSE_CALLBACKS("ContentLaunchClusterLaunchURLResponseCallback");
 670
 671     Callback::Callback<ContentLaunchClusterLaunchURLResponseCallback> * cb =
 672         Callback::Callback<ContentLaunchClusterLaunchURLResponseCallback>::FromCancelable(onSuccessCallback);
 673     cb->mCall(cb->mContext, contentLaunchStatus);
 674     return true;
 675 }
 676
 677 bool emberAfDoorLockClusterClearAllPinsResponseCallback(uint8_t status)
 678 {
 679     ChipLogProgress(Zcl, "ClearAllPinsResponse:");
 680     LogStatus(status);
 681
 682     GET_RESPONSE_CALLBACKS("DoorLockClusterClearAllPinsResponseCallback");
 683
 684     if (status != EMBER_ZCL_STATUS_SUCCESS)
 685     {
 686         Callback::Callback<DefaultFailureCallback> * cb =
 687             Callback::Callback<DefaultFailureCallback>::FromCancelable(onFailureCallback);
 688         cb->mCall(cb->mContext, status);
 689         return true;
 690     }
 691
 692     Callback::Callback<DoorLockClusterClearAllPinsResponseCallback> * cb =
 693         Callback::Callback<DoorLockClusterClearAllPinsResponseCallback>::FromCancelable(onSuccessCallback);
 694     cb->mCall(cb->mContext);
 695     return true;
 696 }
 697
 698 bool emberAfDoorLockClusterClearAllRfidsResponseCallback(uint8_t status)
 699 {
 700     ChipLogProgress(Zcl, "ClearAllRfidsResponse:");
 701     LogStatus(status);
 702
 703     GET_RESPONSE_CALLBACKS("DoorLockClusterClearAllRfidsResponseCallback");
 704
 705     if (status != EMBER_ZCL_STATUS_SUCCESS)
 706     {
 707         Callback::Callback<DefaultFailureCallback> * cb =
 708             Callback::Callback<DefaultFailureCallback>::FromCancelable(onFailureCallback);
 709         cb->mCall(cb->mContext, status);
 710         return true;
 711     }
 712
 713     Callback::Callback<DoorLockClusterClearAllRfidsResponseCallback> * cb =
 714         Callback::Callback<DoorLockClusterClearAllRfidsResponseCallback>::FromCancelable(onSuccessCallback);
 715     cb->mCall(cb->mContext);
 716     return true;
 717 }
 718
 719 bool emberAfDoorLockClusterClearHolidayScheduleResponseCallback(uint8_t status)
 720 {
 721     ChipLogProgress(Zcl, "ClearHolidayScheduleResponse:");
 722     LogStatus(status);
 723
 724     GET_RESPONSE_CALLBACKS("DoorLockClusterClearHolidayScheduleResponseCallback");
 725
 726     if (status != EMBER_ZCL_STATUS_SUCCESS)
 727     {
 728         Callback::Callback<DefaultFailureCallback> * cb =
 729             Callback::Callback<DefaultFailureCallback>::FromCancelable(onFailureCallback);
 730         cb->mCall(cb->mContext, status);
 731         return true;
 732     }
 733
 734     Callback::Callback<DoorLockClusterClearHolidayScheduleResponseCallback> * cb =
 735         Callback::Callback<DoorLockClusterClearHolidayScheduleResponseCallback>::FromCancelable(onSuccessCallback);
 736     cb->mCall(cb->mContext);
 737     return true;
 738 }
 739
 740 bool emberAfDoorLockClusterClearPinResponseCallback(uint8_t status)
 741 {
 742     ChipLogProgress(Zcl, "ClearPinResponse:");
 743     LogStatus(status);
 744
 745     GET_RESPONSE_CALLBACKS("DoorLockClusterClearPinResponseCallback");
 746
 747     if (status != EMBER_ZCL_STATUS_SUCCESS)
 748     {
 749         Callback::Callback<DefaultFailureCallback> * cb =
 750             Callback::Callback<DefaultFailureCallback>::FromCancelable(onFailureCallback);
 751         cb->mCall(cb->mContext, status);
 752         return true;
 753     }
 754
 755     Callback::Callback<DoorLockClusterClearPinResponseCallback> * cb =
 756         Callback::Callback<DoorLockClusterClearPinResponseCallback>::FromCancelable(onSuccessCallback);
 757     cb->mCall(cb->mContext);
 758     return true;
 759 }
 760
 761 bool emberAfDoorLockClusterClearRfidResponseCallback(uint8_t status)
 762 {
 763     ChipLogProgress(Zcl, "ClearRfidResponse:");
 764     LogStatus(status);
 765
 766     GET_RESPONSE_CALLBACKS("DoorLockClusterClearRfidResponseCallback");
 767
 768     if (status != EMBER_ZCL_STATUS_SUCCESS)
 769     {
 770         Callback::Callback<DefaultFailureCallback> * cb =
 771             Callback::Callback<DefaultFailureCallback>::FromCancelable(onFailureCallback);
 772         cb->mCall(cb->mContext, status);
 773         return true;
 774     }
 775
 776     Callback::Callback<DoorLockClusterClearRfidResponseCallback> * cb =
 777         Callback::Callback<DoorLockClusterClearRfidResponseCallback>::FromCancelable(onSuccessCallback);
 778     cb->mCall(cb->mContext);
 779     return true;
 780 }
 781
 782 bool emberAfDoorLockClusterClearWeekdayScheduleResponseCallback(uint8_t status)
 783 {
 784     ChipLogProgress(Zcl, "ClearWeekdayScheduleResponse:");
 785     LogStatus(status);
 786
 787     GET_RESPONSE_CALLBACKS("DoorLockClusterClearWeekdayScheduleResponseCallback");
 788
 789     if (status != EMBER_ZCL_STATUS_SUCCESS)
 790     {
 791         Callback::Callback<DefaultFailureCallback> * cb =
 792             Callback::Callback<DefaultFailureCallback>::FromCancelable(onFailureCallback);
 793         cb->mCall(cb->mContext, status);
 794         return true;
 795     }
 796
 797     Callback::Callback<DoorLockClusterClearWeekdayScheduleResponseCallback> * cb =
 798         Callback::Callback<DoorLockClusterClearWeekdayScheduleResponseCallback>::FromCancelable(onSuccessCallback);
 799     cb->mCall(cb->mContext);
 800     return true;
 801 }
 802
 803 bool emberAfDoorLockClusterClearYeardayScheduleResponseCallback(uint8_t status)
 804 {
 805     ChipLogProgress(Zcl, "ClearYeardayScheduleResponse:");
 806     LogStatus(status);
 807
 808     GET_RESPONSE_CALLBACKS("DoorLockClusterClearYeardayScheduleResponseCallback");
 809
 810     if (status != EMBER_ZCL_STATUS_SUCCESS)
 811     {
 812         Callback::Callback<DefaultFailureCallback> * cb =
 813             Callback::Callback<DefaultFailureCallback>::FromCancelable(onFailureCallback);
 814         cb->mCall(cb->mContext, status);
 815         return true;
 816     }
 817
 818     Callback::Callback<DoorLockClusterClearYeardayScheduleResponseCallback> * cb =
 819         Callback::Callback<DoorLockClusterClearYeardayScheduleResponseCallback>::FromCancelable(onSuccessCallback);
 820     cb->mCall(cb->mContext);
 821     return true;
 822 }
 823
 824 bool emberAfDoorLockClusterGetHolidayScheduleResponseCallback(uint8_t scheduleId, uint8_t status, uint32_t localStartTime,
 825                                                               uint32_t localEndTime, uint8_t operatingModeDuringHoliday)
 826 {
 827     ChipLogProgress(Zcl, "GetHolidayScheduleResponse:");
 828     ChipLogProgress(Zcl, "  scheduleId: %" PRIu8 "", scheduleId);
 829     LogStatus(status);
 830     ChipLogProgress(Zcl, "  localStartTime: %" PRIu32 "", localStartTime);
 831     ChipLogProgress(Zcl, "  localEndTime: %" PRIu32 "", localEndTime);
 832     ChipLogProgress(Zcl, "  operatingModeDuringHoliday: %" PRIu8 "", operatingModeDuringHoliday);
 833
 834     GET_RESPONSE_CALLBACKS("DoorLockClusterGetHolidayScheduleResponseCallback");
 835
 836     if (status != EMBER_ZCL_STATUS_SUCCESS)
 837     {
 838         Callback::Callback<DefaultFailureCallback> * cb =
 839             Callback::Callback<DefaultFailureCallback>::FromCancelable(onFailureCallback);
 840         cb->mCall(cb->mContext, status);
 841         return true;
 842     }
 843
 844     Callback::Callback<DoorLockClusterGetHolidayScheduleResponseCallback> * cb =
 845         Callback::Callback<DoorLockClusterGetHolidayScheduleResponseCallback>::FromCancelable(onSuccessCallback);
 846     cb->mCall(cb->mContext, scheduleId, localStartTime, localEndTime, operatingModeDuringHoliday);
 847     return true;
 848 }
 849
 850 bool emberAfDoorLockClusterGetLogRecordResponseCallback(uint16_t logEntryId, uint32_t timestamp, uint8_t eventType, uint8_t source,
 851                                                         uint8_t eventIdOrAlarmCode, uint16_t userId, uint8_t * pin)
 852 {
 853     ChipLogProgress(Zcl, "GetLogRecordResponse:");
 854     ChipLogProgress(Zcl, "  logEntryId: %" PRIu16 "", logEntryId);
 855     ChipLogProgress(Zcl, "  timestamp: %" PRIu32 "", timestamp);
 856     ChipLogProgress(Zcl, "  eventType: %" PRIu8 "", eventType);
 857     ChipLogProgress(Zcl, "  source: %" PRIu8 "", source);
 858     ChipLogProgress(Zcl, "  eventIdOrAlarmCode: %" PRIu8 "", eventIdOrAlarmCode);
 859     ChipLogProgress(Zcl, "  userId: %" PRIu16 "", userId);
 860     ChipLogProgress(Zcl, "  pin: %s", pin);
 861
 862     GET_RESPONSE_CALLBACKS("DoorLockClusterGetLogRecordResponseCallback");
 863
 864     Callback::Callback<DoorLockClusterGetLogRecordResponseCallback> * cb =
 865         Callback::Callback<DoorLockClusterGetLogRecordResponseCallback>::FromCancelable(onSuccessCallback);
 866     cb->mCall(cb->mContext, logEntryId, timestamp, eventType, source, eventIdOrAlarmCode, userId, pin);
 867     return true;
 868 }
 869
 870 bool emberAfDoorLockClusterGetPinResponseCallback(uint16_t userId, uint8_t userStatus, uint8_t userType, uint8_t * pin)
 871 {
 872     ChipLogProgress(Zcl, "GetPinResponse:");
 873     ChipLogProgress(Zcl, "  userId: %" PRIu16 "", userId);
 874     ChipLogProgress(Zcl, "  userStatus: %" PRIu8 "", userStatus);
 875     ChipLogProgress(Zcl, "  userType: %" PRIu8 "", userType);
 876     ChipLogProgress(Zcl, "  pin: %s", pin);
 877
 878     GET_RESPONSE_CALLBACKS("DoorLockClusterGetPinResponseCallback");
 879
 880     Callback::Callback<DoorLockClusterGetPinResponseCallback> * cb =
 881         Callback::Callback<DoorLockClusterGetPinResponseCallback>::FromCancelable(onSuccessCallback);
 882     cb->mCall(cb->mContext, userId, userStatus, userType, pin);
 883     return true;
 884 }
 885
 886 bool emberAfDoorLockClusterGetRfidResponseCallback(uint16_t userId, uint8_t userStatus, uint8_t userType, uint8_t * rfid)
 887 {
 888     ChipLogProgress(Zcl, "GetRfidResponse:");
 889     ChipLogProgress(Zcl, "  userId: %" PRIu16 "", userId);
 890     ChipLogProgress(Zcl, "  userStatus: %" PRIu8 "", userStatus);
 891     ChipLogProgress(Zcl, "  userType: %" PRIu8 "", userType);
 892     ChipLogProgress(Zcl, "  rfid: %s", rfid);
 893
 894     GET_RESPONSE_CALLBACKS("DoorLockClusterGetRfidResponseCallback");
 895
 896     Callback::Callback<DoorLockClusterGetRfidResponseCallback> * cb =
 897         Callback::Callback<DoorLockClusterGetRfidResponseCallback>::FromCancelable(onSuccessCallback);
 898     cb->mCall(cb->mContext, userId, userStatus, userType, rfid);
 899     return true;
 900 }
 901
 902 bool emberAfDoorLockClusterGetUserTypeResponseCallback(uint16_t userId, uint8_t userType)
 903 {
 904     ChipLogProgress(Zcl, "GetUserTypeResponse:");
 905     ChipLogProgress(Zcl, "  userId: %" PRIu16 "", userId);
 906     ChipLogProgress(Zcl, "  userType: %" PRIu8 "", userType);
 907
 908     GET_RESPONSE_CALLBACKS("DoorLockClusterGetUserTypeResponseCallback");
 909
 910     Callback::Callback<DoorLockClusterGetUserTypeResponseCallback> * cb =
 911         Callback::Callback<DoorLockClusterGetUserTypeResponseCallback>::FromCancelable(onSuccessCallback);
 912     cb->mCall(cb->mContext, userId, userType);
 913     return true;
 914 }
 915
 916 bool emberAfDoorLockClusterGetWeekdayScheduleResponseCallback(uint8_t scheduleId, uint16_t userId, uint8_t status, uint8_t daysMask,
 917                                                               uint8_t startHour, uint8_t startMinute, uint8_t endHour,
 918                                                               uint8_t endMinute)
 919 {
 920     ChipLogProgress(Zcl, "GetWeekdayScheduleResponse:");
 921     ChipLogProgress(Zcl, "  scheduleId: %" PRIu8 "", scheduleId);
 922     ChipLogProgress(Zcl, "  userId: %" PRIu16 "", userId);
 923     LogStatus(status);
 924     ChipLogProgress(Zcl, "  daysMask: %" PRIu8 "", daysMask);
 925     ChipLogProgress(Zcl, "  startHour: %" PRIu8 "", startHour);
 926     ChipLogProgress(Zcl, "  startMinute: %" PRIu8 "", startMinute);
 927     ChipLogProgress(Zcl, "  endHour: %" PRIu8 "", endHour);
 928     ChipLogProgress(Zcl, "  endMinute: %" PRIu8 "", endMinute);
 929
 930     GET_RESPONSE_CALLBACKS("DoorLockClusterGetWeekdayScheduleResponseCallback");
 931
 932     if (status != EMBER_ZCL_STATUS_SUCCESS)
 933     {
 934         Callback::Callback<DefaultFailureCallback> * cb =
 935             Callback::Callback<DefaultFailureCallback>::FromCancelable(onFailureCallback);
 936         cb->mCall(cb->mContext, status);
 937         return true;
 938     }
 939
 940     Callback::Callback<DoorLockClusterGetWeekdayScheduleResponseCallback> * cb =
 941         Callback::Callback<DoorLockClusterGetWeekdayScheduleResponseCallback>::FromCancelable(onSuccessCallback);
 942     cb->mCall(cb->mContext, scheduleId, userId, daysMask, startHour, startMinute, endHour, endMinute);
 943     return true;
 944 }
 945
 946 bool emberAfDoorLockClusterGetYeardayScheduleResponseCallback(uint8_t scheduleId, uint16_t userId, uint8_t status,
 947                                                               uint32_t localStartTime, uint32_t localEndTime)
 948 {
 949     ChipLogProgress(Zcl, "GetYeardayScheduleResponse:");
 950     ChipLogProgress(Zcl, "  scheduleId: %" PRIu8 "", scheduleId);
 951     ChipLogProgress(Zcl, "  userId: %" PRIu16 "", userId);
 952     LogStatus(status);
 953     ChipLogProgress(Zcl, "  localStartTime: %" PRIu32 "", localStartTime);
 954     ChipLogProgress(Zcl, "  localEndTime: %" PRIu32 "", localEndTime);
 955
 956     GET_RESPONSE_CALLBACKS("DoorLockClusterGetYeardayScheduleResponseCallback");
 957
 958     if (status != EMBER_ZCL_STATUS_SUCCESS)
 959     {
 960         Callback::Callback<DefaultFailureCallback> * cb =
 961             Callback::Callback<DefaultFailureCallback>::FromCancelable(onFailureCallback);
 962         cb->mCall(cb->mContext, status);
 963         return true;
 964     }
 965
 966     Callback::Callback<DoorLockClusterGetYeardayScheduleResponseCallback> * cb =
 967         Callback::Callback<DoorLockClusterGetYeardayScheduleResponseCallback>::FromCancelable(onSuccessCallback);
 968     cb->mCall(cb->mContext, scheduleId, userId, localStartTime, localEndTime);
 969     return true;
 970 }
 971
 972 bool emberAfDoorLockClusterLockDoorResponseCallback(uint8_t status)
 973 {
 974     ChipLogProgress(Zcl, "LockDoorResponse:");
 975     LogStatus(status);
 976
 977     GET_RESPONSE_CALLBACKS("DoorLockClusterLockDoorResponseCallback");
 978
 979     if (status != EMBER_ZCL_STATUS_SUCCESS)
 980     {
 981         Callback::Callback<DefaultFailureCallback> * cb =
 982             Callback::Callback<DefaultFailureCallback>::FromCancelable(onFailureCallback);
 983         cb->mCall(cb->mContext, status);
 984         return true;
 985     }
 986
 987     Callback::Callback<DoorLockClusterLockDoorResponseCallback> * cb =
 988         Callback::Callback<DoorLockClusterLockDoorResponseCallback>::FromCancelable(onSuccessCallback);
 989     cb->mCall(cb->mContext);
 990     return true;
 991 }
 992
 993 bool emberAfDoorLockClusterSetHolidayScheduleResponseCallback(uint8_t status)
 994 {
 995     ChipLogProgress(Zcl, "SetHolidayScheduleResponse:");
 996     LogStatus(status);
 997
 998     GET_RESPONSE_CALLBACKS("DoorLockClusterSetHolidayScheduleResponseCallback");
 999
1000     if (status != EMBER_ZCL_STATUS_SUCCESS)
1001     {
1002         Callback::Callback<DefaultFailureCallback> * cb =
1003             Callback::Callback<DefaultFailureCallback>::FromCancelable(onFailureCallback);
1004         cb->mCall(cb->mContext, status);
1005         return true;
1006     }
1007
1008     Callback::Callback<DoorLockClusterSetHolidayScheduleResponseCallback> * cb =
1009         Callback::Callback<DoorLockClusterSetHolidayScheduleResponseCallback>::FromCancelable(onSuccessCallback);
1010     cb->mCall(cb->mContext);
1011     return true;
1012 }
1013
1014 bool emberAfDoorLockClusterSetPinResponseCallback(uint8_t status)
1015 {
1016     ChipLogProgress(Zcl, "SetPinResponse:");
1017     LogStatus(status);
1018
1019     GET_RESPONSE_CALLBACKS("DoorLockClusterSetPinResponseCallback");
1020
1021     if (status != EMBER_ZCL_STATUS_SUCCESS)
1022     {
1023         Callback::Callback<DefaultFailureCallback> * cb =
1024             Callback::Callback<DefaultFailureCallback>::FromCancelable(onFailureCallback);
1025         cb->mCall(cb->mContext, status);
1026         return true;
1027     }
1028
1029     Callback::Callback<DoorLockClusterSetPinResponseCallback> * cb =
1030         Callback::Callback<DoorLockClusterSetPinResponseCallback>::FromCancelable(onSuccessCallback);
1031     cb->mCall(cb->mContext);
1032     return true;
1033 }
1034
1035 bool emberAfDoorLockClusterSetRfidResponseCallback(uint8_t status)
1036 {
1037     ChipLogProgress(Zcl, "SetRfidResponse:");
1038     LogStatus(status);
1039
1040     GET_RESPONSE_CALLBACKS("DoorLockClusterSetRfidResponseCallback");
1041
1042     if (status != EMBER_ZCL_STATUS_SUCCESS)
1043     {
1044         Callback::Callback<DefaultFailureCallback> * cb =
1045             Callback::Callback<DefaultFailureCallback>::FromCancelable(onFailureCallback);
1046         cb->mCall(cb->mContext, status);
1047         return true;
1048     }
1049
1050     Callback::Callback<DoorLockClusterSetRfidResponseCallback> * cb =
1051         Callback::Callback<DoorLockClusterSetRfidResponseCallback>::FromCancelable(onSuccessCallback);
1052     cb->mCall(cb->mContext);
1053     return true;
1054 }
1055
1056 bool emberAfDoorLockClusterSetUserTypeResponseCallback(uint8_t status)
1057 {
1058     ChipLogProgress(Zcl, "SetUserTypeResponse:");
1059     LogStatus(status);
1060
1061     GET_RESPONSE_CALLBACKS("DoorLockClusterSetUserTypeResponseCallback");
1062
1063     if (status != EMBER_ZCL_STATUS_SUCCESS)
1064     {
1065         Callback::Callback<DefaultFailureCallback> * cb =
1066             Callback::Callback<DefaultFailureCallback>::FromCancelable(onFailureCallback);
1067         cb->mCall(cb->mContext, status);
1068         return true;
1069     }
1070
1071     Callback::Callback<DoorLockClusterSetUserTypeResponseCallback> * cb =
1072         Callback::Callback<DoorLockClusterSetUserTypeResponseCallback>::FromCancelable(onSuccessCallback);
1073     cb->mCall(cb->mContext);
1074     return true;
1075 }
1076
1077 bool emberAfDoorLockClusterSetWeekdayScheduleResponseCallback(uint8_t status)
1078 {
1079     ChipLogProgress(Zcl, "SetWeekdayScheduleResponse:");
1080     LogStatus(status);
1081
1082     GET_RESPONSE_CALLBACKS("DoorLockClusterSetWeekdayScheduleResponseCallback");
1083
1084     if (status != EMBER_ZCL_STATUS_SUCCESS)
1085     {
1086         Callback::Callback<DefaultFailureCallback> * cb =
1087             Callback::Callback<DefaultFailureCallback>::FromCancelable(onFailureCallback);
1088         cb->mCall(cb->mContext, status);
1089         return true;
1090     }
1091
1092     Callback::Callback<DoorLockClusterSetWeekdayScheduleResponseCallback> * cb =
1093         Callback::Callback<DoorLockClusterSetWeekdayScheduleResponseCallback>::FromCancelable(onSuccessCallback);
1094     cb->mCall(cb->mContext);
1095     return true;
1096 }
1097
1098 bool emberAfDoorLockClusterSetYeardayScheduleResponseCallback(uint8_t status)
1099 {
1100     ChipLogProgress(Zcl, "SetYeardayScheduleResponse:");
1101     LogStatus(status);
1102
1103     GET_RESPONSE_CALLBACKS("DoorLockClusterSetYeardayScheduleResponseCallback");
1104
1105     if (status != EMBER_ZCL_STATUS_SUCCESS)
1106     {
1107         Callback::Callback<DefaultFailureCallback> * cb =
1108             Callback::Callback<DefaultFailureCallback>::FromCancelable(onFailureCallback);
1109         cb->mCall(cb->mContext, status);
1110         return true;
1111     }
1112
1113     Callback::Callback<DoorLockClusterSetYeardayScheduleResponseCallback> * cb =
1114         Callback::Callback<DoorLockClusterSetYeardayScheduleResponseCallback>::FromCancelable(onSuccessCallback);
1115     cb->mCall(cb->mContext);
1116     return true;
1117 }
1118
1119 bool emberAfDoorLockClusterUnlockDoorResponseCallback(uint8_t status)
1120 {
1121     ChipLogProgress(Zcl, "UnlockDoorResponse:");
1122     LogStatus(status);
1123
1124     GET_RESPONSE_CALLBACKS("DoorLockClusterUnlockDoorResponseCallback");
1125
1126     if (status != EMBER_ZCL_STATUS_SUCCESS)
1127     {
1128         Callback::Callback<DefaultFailureCallback> * cb =
1129             Callback::Callback<DefaultFailureCallback>::FromCancelable(onFailureCallback);
1130         cb->mCall(cb->mContext, status);
1131         return true;
1132     }
1133
1134     Callback::Callback<DoorLockClusterUnlockDoorResponseCallback> * cb =
1135         Callback::Callback<DoorLockClusterUnlockDoorResponseCallback>::FromCancelable(onSuccessCallback);
1136     cb->mCall(cb->mContext);
1137     return true;
1138 }
1139
1140 bool emberAfDoorLockClusterUnlockWithTimeoutResponseCallback(uint8_t status)
1141 {
1142     ChipLogProgress(Zcl, "UnlockWithTimeoutResponse:");
1143     LogStatus(status);
1144
1145     GET_RESPONSE_CALLBACKS("DoorLockClusterUnlockWithTimeoutResponseCallback");
1146
1147     if (status != EMBER_ZCL_STATUS_SUCCESS)
1148     {
1149         Callback::Callback<DefaultFailureCallback> * cb =
1150             Callback::Callback<DefaultFailureCallback>::FromCancelable(onFailureCallback);
1151         cb->mCall(cb->mContext, status);
1152         return true;
1153     }
1154
1155     Callback::Callback<DoorLockClusterUnlockWithTimeoutResponseCallback> * cb =
1156         Callback::Callback<DoorLockClusterUnlockWithTimeoutResponseCallback>::FromCancelable(onSuccessCallback);
1157     cb->mCall(cb->mContext);
1158     return true;
1159 }
1160
1161 bool emberAfGeneralCommissioningClusterArmFailSafeResponseCallback(uint8_t errorCode, uint8_t * debugText)
1162 {
1163     ChipLogProgress(Zcl, "ArmFailSafeResponse:");
1164     ChipLogProgress(Zcl, "  errorCode: %" PRIu8 "", errorCode);
1165     ChipLogProgress(Zcl, "  debugText: %s", debugText);
1166
1167     GET_RESPONSE_CALLBACKS("GeneralCommissioningClusterArmFailSafeResponseCallback");
1168
1169     Callback::Callback<GeneralCommissioningClusterArmFailSafeResponseCallback> * cb =
1170         Callback::Callback<GeneralCommissioningClusterArmFailSafeResponseCallback>::FromCancelable(onSuccessCallback);
1171     cb->mCall(cb->mContext, errorCode, debugText);
1172     return true;
1173 }
1174
1175 bool emberAfGeneralCommissioningClusterCommissioningCompleteResponseCallback(uint8_t errorCode, uint8_t * debugText)
1176 {
1177     ChipLogProgress(Zcl, "CommissioningCompleteResponse:");
1178     ChipLogProgress(Zcl, "  errorCode: %" PRIu8 "", errorCode);
1179     ChipLogProgress(Zcl, "  debugText: %s", debugText);
1180
1181     GET_RESPONSE_CALLBACKS("GeneralCommissioningClusterCommissioningCompleteResponseCallback");
1182
1183     Callback::Callback<GeneralCommissioningClusterCommissioningCompleteResponseCallback> * cb =
1184         Callback::Callback<GeneralCommissioningClusterCommissioningCompleteResponseCallback>::FromCancelable(onSuccessCallback);
1185     cb->mCall(cb->mContext, errorCode, debugText);
1186     return true;
1187 }
1188
1189 bool emberAfGeneralCommissioningClusterSetFabricResponseCallback(uint8_t errorCode, uint8_t * debugText)
1190 {
1191     ChipLogProgress(Zcl, "SetFabricResponse:");
1192     ChipLogProgress(Zcl, "  errorCode: %" PRIu8 "", errorCode);
1193     ChipLogProgress(Zcl, "  debugText: %s", debugText);
1194
1195     GET_RESPONSE_CALLBACKS("GeneralCommissioningClusterSetFabricResponseCallback");
1196
1197     Callback::Callback<GeneralCommissioningClusterSetFabricResponseCallback> * cb =
1198         Callback::Callback<GeneralCommissioningClusterSetFabricResponseCallback>::FromCancelable(onSuccessCallback);
1199     cb->mCall(cb->mContext, errorCode, debugText);
1200     return true;
1201 }
1202
1203 bool emberAfGroupsClusterAddGroupResponseCallback(uint8_t status, uint16_t groupId)
1204 {
1205     ChipLogProgress(Zcl, "AddGroupResponse:");
1206     LogStatus(status);
1207     ChipLogProgress(Zcl, "  groupId: %" PRIu16 "", groupId);
1208
1209     GET_RESPONSE_CALLBACKS("GroupsClusterAddGroupResponseCallback");
1210
1211     if (status != EMBER_ZCL_STATUS_SUCCESS)
1212     {
1213         Callback::Callback<DefaultFailureCallback> * cb =
1214             Callback::Callback<DefaultFailureCallback>::FromCancelable(onFailureCallback);
1215         cb->mCall(cb->mContext, status);
1216         return true;
1217     }
1218
1219     Callback::Callback<GroupsClusterAddGroupResponseCallback> * cb =
1220         Callback::Callback<GroupsClusterAddGroupResponseCallback>::FromCancelable(onSuccessCallback);
1221     cb->mCall(cb->mContext, groupId);
1222     return true;
1223 }
1224
1225 bool emberAfGroupsClusterGetGroupMembershipResponseCallback(uint8_t capacity, uint8_t groupCount,
1226                                                             /* TYPE WARNING: array array defaults to */ uint8_t * groupList)
1227 {
1228     ChipLogProgress(Zcl, "GetGroupMembershipResponse:");
1229     ChipLogProgress(Zcl, "  capacity: %" PRIu8 "", capacity);
1230     ChipLogProgress(Zcl, "  groupCount: %" PRIu8 "", groupCount);
1231     ChipLogProgress(Zcl, "  groupList: %p", groupList);
1232
1233     GET_RESPONSE_CALLBACKS("GroupsClusterGetGroupMembershipResponseCallback");
1234
1235     Callback::Callback<GroupsClusterGetGroupMembershipResponseCallback> * cb =
1236         Callback::Callback<GroupsClusterGetGroupMembershipResponseCallback>::FromCancelable(onSuccessCallback);
1237     cb->mCall(cb->mContext, capacity, groupCount, groupList);
1238     return true;
1239 }
1240
1241 bool emberAfGroupsClusterRemoveGroupResponseCallback(uint8_t status, uint16_t groupId)
1242 {
1243     ChipLogProgress(Zcl, "RemoveGroupResponse:");
1244     LogStatus(status);
1245     ChipLogProgress(Zcl, "  groupId: %" PRIu16 "", groupId);
1246
1247     GET_RESPONSE_CALLBACKS("GroupsClusterRemoveGroupResponseCallback");
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<GroupsClusterRemoveGroupResponseCallback> * cb =
1258         Callback::Callback<GroupsClusterRemoveGroupResponseCallback>::FromCancelable(onSuccessCallback);
1259     cb->mCall(cb->mContext, groupId);
1260     return true;
1261 }
1262
1263 bool emberAfGroupsClusterViewGroupResponseCallback(uint8_t status, uint16_t groupId, uint8_t * groupName)
1264 {
1265     ChipLogProgress(Zcl, "ViewGroupResponse:");
1266     LogStatus(status);
1267     ChipLogProgress(Zcl, "  groupId: %" PRIu16 "", groupId);
1268     ChipLogProgress(Zcl, "  groupName: %s", groupName);
1269
1270     GET_RESPONSE_CALLBACKS("GroupsClusterViewGroupResponseCallback");
1271
1272     if (status != EMBER_ZCL_STATUS_SUCCESS)
1273     {
1274         Callback::Callback<DefaultFailureCallback> * cb =
1275             Callback::Callback<DefaultFailureCallback>::FromCancelable(onFailureCallback);
1276         cb->mCall(cb->mContext, status);
1277         return true;
1278     }
1279
1280     Callback::Callback<GroupsClusterViewGroupResponseCallback> * cb =
1281         Callback::Callback<GroupsClusterViewGroupResponseCallback>::FromCancelable(onSuccessCallback);
1282     cb->mCall(cb->mContext, groupId, groupName);
1283     return true;
1284 }
1285
1286 bool emberAfIdentifyClusterIdentifyQueryResponseCallback(uint16_t timeout)
1287 {
1288     ChipLogProgress(Zcl, "IdentifyQueryResponse:");
1289     ChipLogProgress(Zcl, "  timeout: %" PRIu16 "", timeout);
1290
1291     GET_RESPONSE_CALLBACKS("IdentifyClusterIdentifyQueryResponseCallback");
1292
1293     Callback::Callback<IdentifyClusterIdentifyQueryResponseCallback> * cb =
1294         Callback::Callback<IdentifyClusterIdentifyQueryResponseCallback>::FromCancelable(onSuccessCallback);
1295     cb->mCall(cb->mContext, timeout);
1296     return true;
1297 }
1298
1299 bool emberAfScenesClusterAddSceneResponseCallback(uint8_t status, uint16_t groupId, uint8_t sceneId)
1300 {
1301     ChipLogProgress(Zcl, "AddSceneResponse:");
1302     LogStatus(status);
1303     ChipLogProgress(Zcl, "  groupId: %" PRIu16 "", groupId);
1304     ChipLogProgress(Zcl, "  sceneId: %" PRIu8 "", sceneId);
1305
1306     GET_RESPONSE_CALLBACKS("ScenesClusterAddSceneResponseCallback");
1307
1308     if (status != EMBER_ZCL_STATUS_SUCCESS)
1309     {
1310         Callback::Callback<DefaultFailureCallback> * cb =
1311             Callback::Callback<DefaultFailureCallback>::FromCancelable(onFailureCallback);
1312         cb->mCall(cb->mContext, status);
1313         return true;
1314     }
1315
1316     Callback::Callback<ScenesClusterAddSceneResponseCallback> * cb =
1317         Callback::Callback<ScenesClusterAddSceneResponseCallback>::FromCancelable(onSuccessCallback);
1318     cb->mCall(cb->mContext, groupId, sceneId);
1319     return true;
1320 }
1321
1322 bool emberAfScenesClusterGetSceneMembershipResponseCallback(uint8_t status, uint8_t capacity, uint16_t groupId, uint8_t sceneCount,
1323                                                             /* TYPE WARNING: array array defaults to */ uint8_t * sceneList)
1324 {
1325     ChipLogProgress(Zcl, "GetSceneMembershipResponse:");
1326     LogStatus(status);
1327     ChipLogProgress(Zcl, "  capacity: %" PRIu8 "", capacity);
1328     ChipLogProgress(Zcl, "  groupId: %" PRIu16 "", groupId);
1329     ChipLogProgress(Zcl, "  sceneCount: %" PRIu8 "", sceneCount);
1330     ChipLogProgress(Zcl, "  sceneList: %p", sceneList);
1331
1332     GET_RESPONSE_CALLBACKS("ScenesClusterGetSceneMembershipResponseCallback");
1333
1334     if (status != EMBER_ZCL_STATUS_SUCCESS)
1335     {
1336         Callback::Callback<DefaultFailureCallback> * cb =
1337             Callback::Callback<DefaultFailureCallback>::FromCancelable(onFailureCallback);
1338         cb->mCall(cb->mContext, status);
1339         return true;
1340     }
1341
1342     Callback::Callback<ScenesClusterGetSceneMembershipResponseCallback> * cb =
1343         Callback::Callback<ScenesClusterGetSceneMembershipResponseCallback>::FromCancelable(onSuccessCallback);
1344     cb->mCall(cb->mContext, capacity, groupId, sceneCount, sceneList);
1345     return true;
1346 }
1347
1348 bool emberAfScenesClusterRemoveAllScenesResponseCallback(uint8_t status, uint16_t groupId)
1349 {
1350     ChipLogProgress(Zcl, "RemoveAllScenesResponse:");
1351     LogStatus(status);
1352     ChipLogProgress(Zcl, "  groupId: %" PRIu16 "", groupId);
1353
1354     GET_RESPONSE_CALLBACKS("ScenesClusterRemoveAllScenesResponseCallback");
1355
1356     if (status != EMBER_ZCL_STATUS_SUCCESS)
1357     {
1358         Callback::Callback<DefaultFailureCallback> * cb =
1359             Callback::Callback<DefaultFailureCallback>::FromCancelable(onFailureCallback);
1360         cb->mCall(cb->mContext, status);
1361         return true;
1362     }
1363
1364     Callback::Callback<ScenesClusterRemoveAllScenesResponseCallback> * cb =
1365         Callback::Callback<ScenesClusterRemoveAllScenesResponseCallback>::FromCancelable(onSuccessCallback);
1366     cb->mCall(cb->mContext, groupId);
1367     return true;
1368 }
1369
1370 bool emberAfScenesClusterRemoveSceneResponseCallback(uint8_t status, uint16_t groupId, uint8_t sceneId)
1371 {
1372     ChipLogProgress(Zcl, "RemoveSceneResponse:");
1373     LogStatus(status);
1374     ChipLogProgress(Zcl, "  groupId: %" PRIu16 "", groupId);
1375     ChipLogProgress(Zcl, "  sceneId: %" PRIu8 "", sceneId);
1376
1377     GET_RESPONSE_CALLBACKS("ScenesClusterRemoveSceneResponseCallback");
1378
1379     if (status != EMBER_ZCL_STATUS_SUCCESS)
1380     {
1381         Callback::Callback<DefaultFailureCallback> * cb =
1382             Callback::Callback<DefaultFailureCallback>::FromCancelable(onFailureCallback);
1383         cb->mCall(cb->mContext, status);
1384         return true;
1385     }
1386
1387     Callback::Callback<ScenesClusterRemoveSceneResponseCallback> * cb =
1388         Callback::Callback<ScenesClusterRemoveSceneResponseCallback>::FromCancelable(onSuccessCallback);
1389     cb->mCall(cb->mContext, groupId, sceneId);
1390     return true;
1391 }
1392
1393 bool emberAfScenesClusterStoreSceneResponseCallback(uint8_t status, uint16_t groupId, uint8_t sceneId)
1394 {
1395     ChipLogProgress(Zcl, "StoreSceneResponse:");
1396     LogStatus(status);
1397     ChipLogProgress(Zcl, "  groupId: %" PRIu16 "", groupId);
1398     ChipLogProgress(Zcl, "  sceneId: %" PRIu8 "", sceneId);
1399
1400     GET_RESPONSE_CALLBACKS("ScenesClusterStoreSceneResponseCallback");
1401
1402     if (status != EMBER_ZCL_STATUS_SUCCESS)
1403     {
1404         Callback::Callback<DefaultFailureCallback> * cb =
1405             Callback::Callback<DefaultFailureCallback>::FromCancelable(onFailureCallback);
1406         cb->mCall(cb->mContext, status);
1407         return true;
1408     }
1409
1410     Callback::Callback<ScenesClusterStoreSceneResponseCallback> * cb =
1411         Callback::Callback<ScenesClusterStoreSceneResponseCallback>::FromCancelable(onSuccessCallback);
1412     cb->mCall(cb->mContext, groupId, sceneId);
1413     return true;
1414 }
1415
1416 bool emberAfScenesClusterViewSceneResponseCallback(uint8_t status, uint16_t groupId, uint8_t sceneId, uint16_t transitionTime,
1417                                                    uint8_t * sceneName,
1418                                                    /* TYPE WARNING: array array defaults to */ uint8_t * extensionFieldSets)
1419 {
1420     ChipLogProgress(Zcl, "ViewSceneResponse:");
1421     LogStatus(status);
1422     ChipLogProgress(Zcl, "  groupId: %" PRIu16 "", groupId);
1423     ChipLogProgress(Zcl, "  sceneId: %" PRIu8 "", sceneId);
1424     ChipLogProgress(Zcl, "  transitionTime: %" PRIu16 "", transitionTime);
1425     ChipLogProgress(Zcl, "  sceneName: %s", sceneName);
1426     ChipLogProgress(Zcl, "  extensionFieldSets: %p", extensionFieldSets);
1427
1428     GET_RESPONSE_CALLBACKS("ScenesClusterViewSceneResponseCallback");
1429
1430     if (status != EMBER_ZCL_STATUS_SUCCESS)
1431     {
1432         Callback::Callback<DefaultFailureCallback> * cb =
1433             Callback::Callback<DefaultFailureCallback>::FromCancelable(onFailureCallback);
1434         cb->mCall(cb->mContext, status);
1435         return true;
1436     }
1437
1438     Callback::Callback<ScenesClusterViewSceneResponseCallback> * cb =
1439         Callback::Callback<ScenesClusterViewSceneResponseCallback>::FromCancelable(onSuccessCallback);
1440     cb->mCall(cb->mContext, groupId, sceneId, transitionTime, sceneName, extensionFieldSets);
1441     return true;
1442 }
1443
1444 bool emberAfReportAttributesCallback(ClusterId clusterId, uint8_t * message, uint16_t messageLen)
1445 {
1446     ChipLogProgress(Zcl, "emberAfReportAttributeCallback:");
1447     ChipLogProgress(Zcl, "  ClusterId: 0x%04x", clusterId);
1448
1449     NodeId sourceId = emberAfCurrentCommand()->source;
1450     ChipLogProgress(Zcl, "  Source NodeId: %" PRIu64, sourceId);
1451
1452     EndpointId endpointId = emberAfCurrentCommand()->apsFrame->sourceEndpoint;
1453     ChipLogProgress(Zcl, "  Source EndpointId: 0x%04x", endpointId);
1454
1455     // TODO onFailureCallback is just here because of the CHECK_MESSAGE_LENGTH macro. It needs to be removed.
1456     Callback::Cancelable * onFailureCallback = nullptr;
1457
1458     while (messageLen)
1459     {
1460         CHECK_MESSAGE_LENGTH(2);
1461         uint16_t attributeId = chip::Encoding::LittleEndian::Read16(message); // attribId
1462         ChipLogProgress(Zcl, "  attributeId: 0x%04x", attributeId);
1463
1464         GET_REPORT_CALLBACK("emberAfReportAttributesCallback");
1465
1466         CHECK_MESSAGE_LENGTH(1);
1467         uint8_t attributeType = chip::Encoding::Read8(message);
1468         ChipLogProgress(Zcl, "  attributeType: 0x%02x", attributeType);
1469
1470         switch (attributeType)
1471         {
1472         case 0x00: // nodata / No data
1473         case 0x0A: // data24 / 24-bit data
1474         case 0x0C: // data40 / 40-bit data
1475         case 0x0D: // data48 / 48-bit data
1476         case 0x0E: // data56 / 56-bit data
1477         case 0x1A: // map24 / 24-bit bitmap
1478         case 0x1C: // map40 / 40-bit bitmap
1479         case 0x1D: // map48 / 48-bit bitmap
1480         case 0x1E: // map56 / 56-bit bitmap
1481         case 0x22: // uint24 / Unsigned 24-bit integer
1482         case 0x24: // uint40 / Unsigned 40-bit integer
1483         case 0x25: // uint48 / Unsigned 48-bit integer
1484         case 0x26: // uint56 / Unsigned 56-bit integer
1485         case 0x2A: // int24 / Signed 24-bit integer
1486         case 0x2C: // int40 / Signed 40-bit integer
1487         case 0x2D: // int48 / Signed 48-bit integer
1488         case 0x2E: // int56 / Signed 56-bit integer
1489         case 0x38: // semi / Semi-precision
1490         case 0x39: // single / Single precision
1491         case 0x3A: // double / Double precision
1492         case 0x41: // octstr / Octet string
1493         case 0x42: // string / Character string
1494         case 0x43: // octstr16 / Long octet string
1495         case 0x44: // string16 / Long character string
1496         case 0x48: // array / Array
1497         case 0x49: // struct / Structure
1498         case 0x50: // set / Set
1499         case 0x51: // bag / Bag
1500         case 0xE0: // ToD / Time of day
1501         {
1502             ChipLogError(Zcl, "attributeType 0x%02x is not supported", attributeType);
1503             return true;
1504         }
1505
1506         case 0x08: // data8 / 8-bit data
1507         case 0x18: // map8 / 8-bit bitmap
1508         case 0x20: // uint8 / Unsigned  8-bit integer
1509         case 0x30: // enum8 / 8-bit enumeration
1510         {
1511             CHECK_MESSAGE_LENGTH(1);
1512             uint8_t value = chip::Encoding::Read8(message);
1513             ChipLogProgress(Zcl, "  value: 0x%02x", value);
1514
1515             Callback::Callback<Int8uAttributeCallback> * cb =
1516                 Callback::Callback<Int8uAttributeCallback>::FromCancelable(onReportCallback);
1517             cb->mCall(cb->mContext, value);
1518             break;
1519         }
1520
1521         case 0x09: // data16 / 16-bit data
1522         case 0x19: // map16 / 16-bit bitmap
1523         case 0x21: // uint16 / Unsigned 16-bit integer
1524         case 0x31: // enum16 / 16-bit enumeration
1525         case 0xE8: // clusterId / Cluster ID
1526         case 0xE9: // attribId / Attribute ID
1527         case 0xEA: // bacOID / BACnet OID
1528         case 0xF1: // key128 / 128-bit security key
1529         case 0xFF: // unk / Unknown
1530         {
1531             CHECK_MESSAGE_LENGTH(2);
1532             uint16_t value = chip::Encoding::LittleEndian::Read16(message);
1533             ChipLogProgress(Zcl, "  value: 0x%04x", value);
1534
1535             Callback::Callback<Int16uAttributeCallback> * cb =
1536                 Callback::Callback<Int16uAttributeCallback>::FromCancelable(onReportCallback);
1537             cb->mCall(cb->mContext, value);
1538             break;
1539         }
1540
1541         case 0x0B: // data32 / 32-bit data
1542         case 0x1B: // map32 / 32-bit bitmap
1543         case 0x23: // uint32 / Unsigned 32-bit integer
1544         case 0xE1: // date / Date
1545         case 0xE2: // UTC / UTCTime
1546         {
1547             CHECK_MESSAGE_LENGTH(4);
1548             uint32_t value = chip::Encoding::LittleEndian::Read32(message);
1549             ChipLogProgress(Zcl, "  value: 0x%08x", value);
1550
1551             Callback::Callback<Int32uAttributeCallback> * cb =
1552                 Callback::Callback<Int32uAttributeCallback>::FromCancelable(onReportCallback);
1553             cb->mCall(cb->mContext, value);
1554             break;
1555         }
1556
1557         case 0x0F: // data64 / 64-bit data
1558         case 0x1F: // map64 / 64-bit bitmap
1559         case 0x27: // uint64 / Unsigned 64-bit integer
1560         case 0xF0: // EUI64 / IEEE address
1561         {
1562             CHECK_MESSAGE_LENGTH(8);
1563             uint64_t value = chip::Encoding::LittleEndian::Read64(message);
1564             ChipLogProgress(Zcl, "  value: 0x%16x", value);
1565
1566             Callback::Callback<Int64uAttributeCallback> * cb =
1567                 Callback::Callback<Int64uAttributeCallback>::FromCancelable(onReportCallback);
1568             cb->mCall(cb->mContext, value);
1569             break;
1570         }
1571
1572         case 0x10: // bool / Boolean
1573         {
1574             CHECK_MESSAGE_LENGTH(1);
1575             uint8_t value = chip::Encoding::Read8(message);
1576             ChipLogProgress(Zcl, "  value: %d", value);
1577
1578             Callback::Callback<BooleanAttributeCallback> * cb =
1579                 Callback::Callback<BooleanAttributeCallback>::FromCancelable(onReportCallback);
1580             cb->mCall(cb->mContext, value);
1581             break;
1582         }
1583
1584         case 0x28: // int8 / Signed 8-bit integer
1585         {
1586             CHECK_MESSAGE_LENGTH(1);
1587             int8_t value = chip::CastToSigned(chip::Encoding::Read8(message));
1588             ChipLogProgress(Zcl, "  value: %" PRId8, value);
1589
1590             Callback::Callback<Int8sAttributeCallback> * cb =
1591                 Callback::Callback<Int8sAttributeCallback>::FromCancelable(onReportCallback);
1592             cb->mCall(cb->mContext, value);
1593             break;
1594         }
1595
1596         case 0x29: // int16 / Signed 16-bit integer
1597         {
1598             CHECK_MESSAGE_LENGTH(2);
1599             int16_t value = chip::CastToSigned(chip::Encoding::LittleEndian::Read16(message));
1600             ChipLogProgress(Zcl, "  value: %" PRId16, value);
1601
1602             Callback::Callback<Int16sAttributeCallback> * cb =
1603                 Callback::Callback<Int16sAttributeCallback>::FromCancelable(onReportCallback);
1604             cb->mCall(cb->mContext, value);
1605             break;
1606         }
1607
1608         case 0x2B: // int32 / Signed 32-bit integer
1609         {
1610             CHECK_MESSAGE_LENGTH(4);
1611             int32_t value = chip::CastToSigned(chip::Encoding::LittleEndian::Read32(message));
1612             ChipLogProgress(Zcl, "  value: %" PRId32, value);
1613
1614             Callback::Callback<Int32sAttributeCallback> * cb =
1615                 Callback::Callback<Int32sAttributeCallback>::FromCancelable(onReportCallback);
1616             cb->mCall(cb->mContext, value);
1617             break;
1618         }
1619
1620         case 0x2F: // int64 / Signed 64-bit integer
1621         {
1622             CHECK_MESSAGE_LENGTH(8);
1623             int64_t value = chip::CastToSigned(chip::Encoding::LittleEndian::Read64(message));
1624             ChipLogProgress(Zcl, "  value: %" PRId64, value);
1625
1626             Callback::Callback<Int64sAttributeCallback> * cb =
1627                 Callback::Callback<Int64sAttributeCallback>::FromCancelable(onReportCallback);
1628             cb->mCall(cb->mContext, value);
1629             break;
1630         }
1631         }
1632     }
1633
1634     return true;
1635 }