examples/tv-app/tv-common/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 emberAfDoorLockClusterLockDoorResponseCallback(uint8_t status)
 690 {
 691     ChipLogProgress(Zcl, "LockDoorResponse:");
 692     LogStatus(status);
 693
 694     GET_RESPONSE_CALLBACKS("DoorLockClusterLockDoorResponseCallback");
 695
 696     if (status != EMBER_ZCL_STATUS_SUCCESS)
 697     {
 698         Callback::Callback<DefaultFailureCallback> * cb =
 699             Callback::Callback<DefaultFailureCallback>::FromCancelable(onFailureCallback);
 700         cb->mCall(cb->mContext, status);
 701         return true;
 702     }
 703
 704     Callback::Callback<DoorLockClusterLockDoorResponseCallback> * cb =
 705         Callback::Callback<DoorLockClusterLockDoorResponseCallback>::FromCancelable(onSuccessCallback);
 706     cb->mCall(cb->mContext);
 707     return true;
 708 }
 709
 710 bool emberAfDoorLockClusterUnlockDoorResponseCallback(uint8_t status)
 711 {
 712     ChipLogProgress(Zcl, "UnlockDoorResponse:");
 713     LogStatus(status);
 714
 715     GET_RESPONSE_CALLBACKS("DoorLockClusterUnlockDoorResponseCallback");
 716
 717     if (status != EMBER_ZCL_STATUS_SUCCESS)
 718     {
 719         Callback::Callback<DefaultFailureCallback> * cb =
 720             Callback::Callback<DefaultFailureCallback>::FromCancelable(onFailureCallback);
 721         cb->mCall(cb->mContext, status);
 722         return true;
 723     }
 724
 725     Callback::Callback<DoorLockClusterUnlockDoorResponseCallback> * cb =
 726         Callback::Callback<DoorLockClusterUnlockDoorResponseCallback>::FromCancelable(onSuccessCallback);
 727     cb->mCall(cb->mContext);
 728     return true;
 729 }
 730
 731 bool emberAfReportAttributesCallback(ClusterId clusterId, uint8_t * message, uint16_t messageLen)
 732 {
 733     ChipLogProgress(Zcl, "emberAfReportAttributeCallback:");
 734     ChipLogProgress(Zcl, "  ClusterId: 0x%04x", clusterId);
 735
 736     NodeId sourceId = emberAfCurrentCommand()->source;
 737     ChipLogProgress(Zcl, "  Source NodeId: %" PRIu64, sourceId);
 738
 739     EndpointId endpointId = emberAfCurrentCommand()->apsFrame->sourceEndpoint;
 740     ChipLogProgress(Zcl, "  Source EndpointId: 0x%04x", endpointId);
 741
 742     // TODO onFailureCallback is just here because of the CHECK_MESSAGE_LENGTH macro. It needs to be removed.
 743     Callback::Cancelable * onFailureCallback = nullptr;
 744
 745     while (messageLen)
 746     {
 747         CHECK_MESSAGE_LENGTH(2);
 748         uint16_t attributeId = chip::Encoding::LittleEndian::Read16(message); // attribId
 749         ChipLogProgress(Zcl, "  attributeId: 0x%04x", attributeId);
 750
 751         GET_REPORT_CALLBACK("emberAfReportAttributesCallback");
 752
 753         CHECK_MESSAGE_LENGTH(1);
 754         uint8_t attributeType = chip::Encoding::Read8(message);
 755         ChipLogProgress(Zcl, "  attributeType: 0x%02x", attributeType);
 756
 757         switch (attributeType)
 758         {
 759         case 0x00: // nodata / No data
 760         case 0x0A: // data24 / 24-bit data
 761         case 0x0C: // data40 / 40-bit data
 762         case 0x0D: // data48 / 48-bit data
 763         case 0x0E: // data56 / 56-bit data
 764         case 0x1A: // map24 / 24-bit bitmap
 765         case 0x1C: // map40 / 40-bit bitmap
 766         case 0x1D: // map48 / 48-bit bitmap
 767         case 0x1E: // map56 / 56-bit bitmap
 768         case 0x22: // uint24 / Unsigned 24-bit integer
 769         case 0x24: // uint40 / Unsigned 40-bit integer
 770         case 0x25: // uint48 / Unsigned 48-bit integer
 771         case 0x26: // uint56 / Unsigned 56-bit integer
 772         case 0x2A: // int24 / Signed 24-bit integer
 773         case 0x2C: // int40 / Signed 40-bit integer
 774         case 0x2D: // int48 / Signed 48-bit integer
 775         case 0x2E: // int56 / Signed 56-bit integer
 776         case 0x38: // semi / Semi-precision
 777         case 0x39: // single / Single precision
 778         case 0x3A: // double / Double precision
 779         case 0x48: // array / Array
 780         case 0x49: // struct / Structure
 781         case 0x50: // set / Set
 782         case 0x51: // bag / Bag
 783         case 0xE0: // ToD / Time of day
 784         {
 785             ChipLogError(Zcl, "attributeType 0x%02x is not supported", attributeType);
 786             return true;
 787         }
 788
 789         case 0x41: // octstr / Octet string
 790         case 0x42: // string / Character string
 791         {
 792             // Short Strings must contains at least one byte for the length
 793             CHECK_MESSAGE_LENGTH(1);
 794             uint8_t length = chip::Encoding::Read8(message);
 795             ChipLogProgress(Zcl, "  length: 0x%02x", length);
 796
 797             // When the length is set to 0xFF, it represents a non-value. In this case the data field is zero length.
 798             if (length == 0xFF)
 799             {
 800                 length = 0;
 801             }
 802
 803             CHECK_MESSAGE_LENGTH(length);
 804             Callback::Callback<StringAttributeCallback> * cb =
 805                 Callback::Callback<StringAttributeCallback>::FromCancelable(onReportCallback);
 806             cb->mCall(cb->mContext, chip::ByteSpan(message, length));
 807             break;
 808         }
 809
 810         case 0x43: // octstr16 / Long octet string
 811         case 0x44: // string16 / Long character string
 812         {
 813             // Long Strings must contains at least two bytes for the length
 814             CHECK_MESSAGE_LENGTH(2);
 815             uint16_t length = chip::Encoding::LittleEndian::Read16(message);
 816             ChipLogProgress(Zcl, "  length: 0x%02x", length);
 817
 818             // When the length is set to 0xFFFF, it represents a non-value. In this case the data field is zero length.
 819             if (length == 0xFFFF)
 820             {
 821                 length = 0;
 822             }
 823
 824             CHECK_MESSAGE_LENGTH(length);
 825             Callback::Callback<StringAttributeCallback> * cb =
 826                 Callback::Callback<StringAttributeCallback>::FromCancelable(onReportCallback);
 827             cb->mCall(cb->mContext, chip::ByteSpan(message, length));
 828             break;
 829         }
 830
 831         case 0x08: // data8 / 8-bit data
 832         case 0x18: // map8 / 8-bit bitmap
 833         case 0x20: // uint8 / Unsigned  8-bit integer
 834         case 0x30: // enum8 / 8-bit enumeration
 835         {
 836             CHECK_MESSAGE_LENGTH(1);
 837             uint8_t value = chip::Encoding::Read8(message);
 838             ChipLogProgress(Zcl, "  value: 0x%02x", value);
 839
 840             Callback::Callback<Int8uAttributeCallback> * cb =
 841                 Callback::Callback<Int8uAttributeCallback>::FromCancelable(onReportCallback);
 842             cb->mCall(cb->mContext, value);
 843             break;
 844         }
 845
 846         case 0x09: // data16 / 16-bit data
 847         case 0x19: // map16 / 16-bit bitmap
 848         case 0x21: // uint16 / Unsigned 16-bit integer
 849         case 0x31: // enum16 / 16-bit enumeration
 850         case 0xE8: // clusterId / Cluster ID
 851         case 0xE9: // attribId / Attribute ID
 852         case 0xEA: // bacOID / BACnet OID
 853         case 0xF1: // key128 / 128-bit security key
 854         case 0xFF: // unk / Unknown
 855         {
 856             CHECK_MESSAGE_LENGTH(2);
 857             uint16_t value = chip::Encoding::LittleEndian::Read16(message);
 858             ChipLogProgress(Zcl, "  value: 0x%04x", value);
 859
 860             Callback::Callback<Int16uAttributeCallback> * cb =
 861                 Callback::Callback<Int16uAttributeCallback>::FromCancelable(onReportCallback);
 862             cb->mCall(cb->mContext, value);
 863             break;
 864         }
 865
 866         case 0x0B: // data32 / 32-bit data
 867         case 0x1B: // map32 / 32-bit bitmap
 868         case 0x23: // uint32 / Unsigned 32-bit integer
 869         case 0xE1: // date / Date
 870         case 0xE2: // UTC / UTCTime
 871         {
 872             CHECK_MESSAGE_LENGTH(4);
 873             uint32_t value = chip::Encoding::LittleEndian::Read32(message);
 874             ChipLogProgress(Zcl, "  value: 0x%08x", value);
 875
 876             Callback::Callback<Int32uAttributeCallback> * cb =
 877                 Callback::Callback<Int32uAttributeCallback>::FromCancelable(onReportCallback);
 878             cb->mCall(cb->mContext, value);
 879             break;
 880         }
 881
 882         case 0x0F: // data64 / 64-bit data
 883         case 0x1F: // map64 / 64-bit bitmap
 884         case 0x27: // uint64 / Unsigned 64-bit integer
 885         case 0xF0: // EUI64 / IEEE address
 886         {
 887             CHECK_MESSAGE_LENGTH(8);
 888             uint64_t value = chip::Encoding::LittleEndian::Read64(message);
 889             ChipLogProgress(Zcl, "  value: 0x%16x", value);
 890
 891             Callback::Callback<Int64uAttributeCallback> * cb =
 892                 Callback::Callback<Int64uAttributeCallback>::FromCancelable(onReportCallback);
 893             cb->mCall(cb->mContext, value);
 894             break;
 895         }
 896
 897         case 0x10: // bool / Boolean
 898         {
 899             CHECK_MESSAGE_LENGTH(1);
 900             uint8_t value = chip::Encoding::Read8(message);
 901             ChipLogProgress(Zcl, "  value: %d", value);
 902
 903             Callback::Callback<BooleanAttributeCallback> * cb =
 904                 Callback::Callback<BooleanAttributeCallback>::FromCancelable(onReportCallback);
 905             cb->mCall(cb->mContext, value);
 906             break;
 907         }
 908
 909         case 0x28: // int8 / Signed 8-bit integer
 910         {
 911             CHECK_MESSAGE_LENGTH(1);
 912             int8_t value = chip::CastToSigned(chip::Encoding::Read8(message));
 913             ChipLogProgress(Zcl, "  value: %" PRId8, value);
 914
 915             Callback::Callback<Int8sAttributeCallback> * cb =
 916                 Callback::Callback<Int8sAttributeCallback>::FromCancelable(onReportCallback);
 917             cb->mCall(cb->mContext, value);
 918             break;
 919         }
 920
 921         case 0x29: // int16 / Signed 16-bit integer
 922         {
 923             CHECK_MESSAGE_LENGTH(2);
 924             int16_t value = chip::CastToSigned(chip::Encoding::LittleEndian::Read16(message));
 925             ChipLogProgress(Zcl, "  value: %" PRId16, value);
 926
 927             Callback::Callback<Int16sAttributeCallback> * cb =
 928                 Callback::Callback<Int16sAttributeCallback>::FromCancelable(onReportCallback);
 929             cb->mCall(cb->mContext, value);
 930             break;
 931         }
 932
 933         case 0x2B: // int32 / Signed 32-bit integer
 934         {
 935             CHECK_MESSAGE_LENGTH(4);
 936             int32_t value = chip::CastToSigned(chip::Encoding::LittleEndian::Read32(message));
 937             ChipLogProgress(Zcl, "  value: %" PRId32, value);
 938
 939             Callback::Callback<Int32sAttributeCallback> * cb =
 940                 Callback::Callback<Int32sAttributeCallback>::FromCancelable(onReportCallback);
 941             cb->mCall(cb->mContext, value);
 942             break;
 943         }
 944
 945         case 0x2F: // int64 / Signed 64-bit integer
 946         {
 947             CHECK_MESSAGE_LENGTH(8);
 948             int64_t value = chip::CastToSigned(chip::Encoding::LittleEndian::Read64(message));
 949             ChipLogProgress(Zcl, "  value: %" PRId64, value);
 950
 951             Callback::Callback<Int64sAttributeCallback> * cb =
 952                 Callback::Callback<Int64sAttributeCallback>::FromCancelable(onReportCallback);
 953             cb->mCall(cb->mContext, value);
 954             break;
 955         }
 956         }
 957     }
 958
 959     return true;
 960 }