| /* |
| * |
| * Copyright (c) 2021 Project CHIP Authors |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| // THIS FILE IS GENERATED BY ZAP |
| |
| #include "gen/CHIPClientCallbacks.h" |
| |
| #include <cinttypes> |
| |
| #include <app/Command.h> |
| #include <app/common/gen/enums.h> |
| #include <app/util/CHIPDeviceCallbacksMgr.h> |
| #include <app/util/af-enums.h> |
| #include <app/util/af.h> |
| #include <app/util/attribute-list-byte-span.h> |
| #include <app/util/basic-types.h> |
| #include <core/CHIPEncoding.h> |
| #include <support/SafeInt.h> |
| #include <support/TypeTraits.h> |
| #include <support/logging/CHIPLogging.h> |
| |
| using namespace ::chip; |
| using namespace ::chip::app::List; |
| |
| constexpr uint16_t kByteSpanSizeLengthInBytes = 2; |
| |
| #define CHECK_STATUS_WITH_RETVAL(error, retval) \ |
| if (CHIP_NO_ERROR != error) \ |
| { \ |
| ChipLogError(Zcl, "CHECK_STATUS %s", ErrorStr(error)); \ |
| if (onFailureCallback != nullptr) \ |
| { \ |
| Callback::Callback<DefaultFailureCallback> * cb = \ |
| Callback::Callback<DefaultFailureCallback>::FromCancelable(onFailureCallback); \ |
| cb->mCall(cb->mContext, static_cast<uint8_t>(EMBER_ZCL_STATUS_INVALID_VALUE)); \ |
| } \ |
| return retval; \ |
| } |
| |
| #define CHECK_STATUS(error) CHECK_STATUS_WITH_RETVAL(error, true) |
| #define CHECK_STATUS_VOID(error) CHECK_STATUS_WITH_RETVAL(error, ) |
| |
| #define CHECK_MESSAGE_LENGTH_WITH_RETVAL(value, retval) \ |
| if (!chip::CanCastTo<uint16_t>(value)) \ |
| { \ |
| ChipLogError(Zcl, "CHECK_MESSAGE_LENGTH expects a uint16_t value, got: %d", value); \ |
| if (onFailureCallback != nullptr) \ |
| { \ |
| Callback::Callback<DefaultFailureCallback> * cb = \ |
| Callback::Callback<DefaultFailureCallback>::FromCancelable(onFailureCallback); \ |
| cb->mCall(cb->mContext, static_cast<uint8_t>(EMBER_ZCL_STATUS_INVALID_VALUE)); \ |
| } \ |
| return retval; \ |
| } \ |
| \ |
| if (messageLen < value) \ |
| { \ |
| ChipLogError(Zcl, "Unexpected response length: %d", messageLen); \ |
| if (onFailureCallback != nullptr) \ |
| { \ |
| Callback::Callback<DefaultFailureCallback> * cb = \ |
| Callback::Callback<DefaultFailureCallback>::FromCancelable(onFailureCallback); \ |
| cb->mCall(cb->mContext, static_cast<uint8_t>(EMBER_ZCL_STATUS_INVALID_VALUE)); \ |
| } \ |
| return retval; \ |
| } \ |
| \ |
| messageLen = static_cast<uint16_t>(messageLen - static_cast<uint16_t>(value)); |
| |
| #define CHECK_MESSAGE_LENGTH(value) CHECK_MESSAGE_LENGTH_WITH_RETVAL(value, true) |
| #define CHECK_MESSAGE_LENGTH_VOID(value) CHECK_MESSAGE_LENGTH_WITH_RETVAL(value, ) |
| |
| #define GET_RESPONSE_CALLBACKS(name) \ |
| Callback::Cancelable * onSuccessCallback = nullptr; \ |
| Callback::Cancelable * onFailureCallback = nullptr; \ |
| NodeId sourceId = emberAfCurrentCommand()->SourceNodeId(); \ |
| uint8_t sequenceNumber = emberAfCurrentCommand()->seqNum; \ |
| CHIP_ERROR err = gCallbacks.GetResponseCallback(sourceId, sequenceNumber, &onSuccessCallback, &onFailureCallback); \ |
| \ |
| if (CHIP_NO_ERROR != err) \ |
| { \ |
| if (onSuccessCallback == nullptr) \ |
| { \ |
| ChipLogDetail(Zcl, "%s: Missing success callback", name); \ |
| } \ |
| \ |
| if (onFailureCallback == nullptr) \ |
| { \ |
| ChipLogDetail(Zcl, "%s: Missing failure callback", name); \ |
| } \ |
| \ |
| return true; \ |
| } |
| |
| #define GET_CLUSTER_RESPONSE_CALLBACKS(name) \ |
| Callback::Cancelable * onSuccessCallback = nullptr; \ |
| Callback::Cancelable * onFailureCallback = nullptr; \ |
| NodeId sourceIdentifier = reinterpret_cast<NodeId>(commandObj); \ |
| /* #6559: Currently, we only have one commands for the IMInvokeCommands and to a device, so the seqNum is always set to 0. */ \ |
| CHIP_ERROR err = gCallbacks.GetResponseCallback(sourceIdentifier, 0, &onSuccessCallback, &onFailureCallback); \ |
| \ |
| if (CHIP_NO_ERROR != err) \ |
| { \ |
| if (onSuccessCallback == nullptr) \ |
| { \ |
| ChipLogDetail(Zcl, "%s: Missing success callback", name); \ |
| } \ |
| \ |
| if (onFailureCallback == nullptr) \ |
| { \ |
| ChipLogDetail(Zcl, "%s: Missing failure callback", name); \ |
| } \ |
| \ |
| return true; \ |
| } |
| |
| #define GET_ATTRIBUTE_RESPONSE_CALLBACKS(name) |
| |
| #define GET_REPORT_CALLBACK(name) \ |
| Callback::Cancelable * onReportCallback = nullptr; \ |
| CHIP_ERROR err = gCallbacks.GetReportCallback(sourceId, endpointId, clusterId, attributeId, &onReportCallback); \ |
| \ |
| if (CHIP_NO_ERROR != err) \ |
| { \ |
| if (onReportCallback == nullptr) \ |
| { \ |
| ChipLogDetail(Zcl, "%s: Missing report callback", name); \ |
| } \ |
| \ |
| return true; \ |
| } |
| |
| // TODO: These IM related callbacks contains small or no generated code, should be put into seperate file to reduce the size of |
| // template. |
| |
| void LogStatus(uint8_t status) |
| { |
| switch (status) |
| { |
| case EMBER_ZCL_STATUS_SUCCESS: |
| ChipLogProgress(Zcl, " status: EMBER_ZCL_STATUS_SUCCESS (0x%02x)", status); |
| break; |
| case EMBER_ZCL_STATUS_FAILURE: |
| ChipLogProgress(Zcl, " status: EMBER_ZCL_STATUS_FAILURE (0x%02x)", status); |
| break; |
| case EMBER_ZCL_STATUS_NOT_AUTHORIZED: |
| ChipLogProgress(Zcl, " status: EMBER_ZCL_STATUS_NOT_AUTHORIZED (0x%02x)", status); |
| break; |
| case EMBER_ZCL_STATUS_MALFORMED_COMMAND: |
| ChipLogProgress(Zcl, " status: EMBER_ZCL_STATUS_MALFORMED_COMMAND (0x%02x)", status); |
| break; |
| case EMBER_ZCL_STATUS_UNSUP_COMMAND: |
| ChipLogProgress(Zcl, " status: EMBER_ZCL_STATUS_UNSUP_CLUSTER_COMMAND (0x%02x)", status); |
| break; |
| case EMBER_ZCL_STATUS_UNSUP_GENERAL_COMMAND: |
| ChipLogProgress(Zcl, " status: EMBER_ZCL_STATUS_UNSUP_GENERAL_COMMAND (0x%02x)", status); |
| break; |
| case EMBER_ZCL_STATUS_UNSUP_MANUF_CLUSTER_COMMAND: |
| ChipLogProgress(Zcl, " status: EMBER_ZCL_STATUS_UNSUP_MANUF_CLUSTER_COMMAND (0x%02x)", status); |
| break; |
| case EMBER_ZCL_STATUS_UNSUP_MANUF_GENERAL_COMMAND: |
| ChipLogProgress(Zcl, " status: EMBER_ZCL_STATUS_UNSUP_MANUF_GENERAL_COMMAND (0x%02x)", status); |
| break; |
| case EMBER_ZCL_STATUS_INVALID_FIELD: |
| ChipLogProgress(Zcl, " status: EMBER_ZCL_STATUS_INVALID_FIELD (0x%02x)", status); |
| break; |
| case EMBER_ZCL_STATUS_UNSUPPORTED_ATTRIBUTE: |
| ChipLogProgress(Zcl, " status: EMBER_ZCL_STATUS_UNSUPPORTED_ATTRIBUTE (0x%02x)", status); |
| break; |
| case EMBER_ZCL_STATUS_INVALID_VALUE: |
| ChipLogProgress(Zcl, " status: EMBER_ZCL_STATUS_INVALID_VALUE (0x%02x)", status); |
| break; |
| case EMBER_ZCL_STATUS_READ_ONLY: |
| ChipLogProgress(Zcl, " status: EMBER_ZCL_STATUS_READ_ONLY (0x%02x)", status); |
| break; |
| case EMBER_ZCL_STATUS_INSUFFICIENT_SPACE: |
| ChipLogProgress(Zcl, " status: EMBER_ZCL_STATUS_INSUFFICIENT_SPACE (0x%02x)", status); |
| break; |
| case EMBER_ZCL_STATUS_DUPLICATE_EXISTS: |
| ChipLogProgress(Zcl, " status: EMBER_ZCL_STATUS_DUPLICATE_EXISTS (0x%02x)", status); |
| break; |
| case EMBER_ZCL_STATUS_NOT_FOUND: |
| ChipLogProgress(Zcl, " status: EMBER_ZCL_STATUS_NOT_FOUND (0x%02x)", status); |
| break; |
| case EMBER_ZCL_STATUS_UNREPORTABLE_ATTRIBUTE: |
| ChipLogProgress(Zcl, " status: EMBER_ZCL_STATUS_UNREPORTABLE_ATTRIBUTE (0x%02x)", status); |
| break; |
| case EMBER_ZCL_STATUS_INVALID_DATA_TYPE: |
| ChipLogProgress(Zcl, " status: EMBER_ZCL_STATUS_INVALID_DATA_TYPE (0x%02x)", status); |
| break; |
| case EMBER_ZCL_STATUS_INVALID_SELECTOR: |
| ChipLogProgress(Zcl, " status: EMBER_ZCL_STATUS_INVALID_SELECTOR (0x%02x)", status); |
| break; |
| case EMBER_ZCL_STATUS_WRITE_ONLY: |
| ChipLogProgress(Zcl, " status: EMBER_ZCL_STATUS_WRITE_ONLY (0x%02x)", status); |
| break; |
| case EMBER_ZCL_STATUS_INCONSISTENT_STARTUP_STATE: |
| ChipLogProgress(Zcl, " status: EMBER_ZCL_STATUS_INCONSISTENT_STARTUP_STATE (0x%02x)", status); |
| break; |
| case EMBER_ZCL_STATUS_DEFINED_OUT_OF_BAND: |
| ChipLogProgress(Zcl, " status: EMBER_ZCL_STATUS_DEFINED_OUT_Of_BAND (0x%02x)", status); |
| break; |
| case EMBER_ZCL_STATUS_ACTION_DENIED: |
| ChipLogProgress(Zcl, " status: EMBER_ZCL_STATUS_ACTION_DENIED (0x%02x)", status); |
| break; |
| case EMBER_ZCL_STATUS_TIMEOUT: |
| ChipLogProgress(Zcl, " status: EMBER_ZCL_STATUS_TIMEOUT (0x%02x)", status); |
| break; |
| case EMBER_ZCL_STATUS_ABORT: |
| ChipLogProgress(Zcl, " status: EMBER_ZCL_STATUS_ABORT (0x%02x)", status); |
| break; |
| case EMBER_ZCL_STATUS_INVALID_IMAGE: |
| ChipLogProgress(Zcl, " status: EMBER_ZCL_STATUS_INVALID_IMAGE (0x%02x)", status); |
| break; |
| case EMBER_ZCL_STATUS_WAIT_FOR_DATA: |
| ChipLogProgress(Zcl, " status: EMBER_ZCL_STATUS_WAIT_FOR_DATA (0x%02x)", status); |
| break; |
| case EMBER_ZCL_STATUS_NO_IMAGE_AVAILABLE: |
| ChipLogProgress(Zcl, " status: EMBER_ZCL_STATUS_NO_IMAGE_AVAILABLE (0x%02x)", status); |
| break; |
| case EMBER_ZCL_STATUS_REQUIRE_MORE_IMAGE: |
| ChipLogProgress(Zcl, " status: EMBER_ZCL_STATUS_REQUIRE_MORE_IMAGE (0x%02x)", status); |
| break; |
| case EMBER_ZCL_STATUS_HARDWARE_FAILURE: |
| ChipLogProgress(Zcl, " status: EMBER_ZCL_STATUS_HARDWARE_FAILURE (0x%02x)", status); |
| break; |
| case EMBER_ZCL_STATUS_SOFTWARE_FAILURE: |
| ChipLogProgress(Zcl, " status: EMBER_ZCL_STATUS_SOFTWARE_FAILURE (0x%02x)", status); |
| break; |
| case EMBER_ZCL_STATUS_UNSUPPORTED_CLUSTER: |
| ChipLogProgress(Zcl, " status: EMBER_ZCL_STATUS_UNSUPPORTED_CLUSTER (0x%02x)", status); |
| break; |
| case EMBER_ZCL_STATUS_LIMIT_REACHED: |
| ChipLogProgress(Zcl, " status: EMBER_ZCL_STATUS_LIMIT_REACHED (0x%02x)", status); |
| break; |
| default: |
| ChipLogError(Zcl, "Unknow status: 0x%02x", status); |
| break; |
| } |
| } |
| |
| static void LogIMStatus(Protocols::InteractionModel::ProtocolCode status) |
| { |
| switch (status) |
| { |
| case Protocols::InteractionModel::ProtocolCode::Success: |
| ChipLogProgress(Zcl, " status: Success (0x%04" PRIx16 ")", chip::to_underlying(status)); |
| break; |
| case Protocols::InteractionModel::ProtocolCode::Failure: |
| ChipLogProgress(Zcl, " status: Failure (0x%04" PRIx16 ")", chip::to_underlying(status)); |
| break; |
| case Protocols::InteractionModel::ProtocolCode::InvalidSubscription: |
| ChipLogProgress(Zcl, " status: InvalidSubscription (0x%04" PRIx16 ")", chip::to_underlying(status)); |
| break; |
| case Protocols::InteractionModel::ProtocolCode::UnsupportedAccess: |
| ChipLogProgress(Zcl, " status: UnsupportedAccess (0x%04" PRIx16 ")", chip::to_underlying(status)); |
| break; |
| case Protocols::InteractionModel::ProtocolCode::UnsupportedEndpoint: |
| ChipLogProgress(Zcl, " status: UnsupportedEndpoint (0x%04" PRIx16 ")", chip::to_underlying(status)); |
| break; |
| case Protocols::InteractionModel::ProtocolCode::InvalidAction: |
| ChipLogProgress(Zcl, " status: InvalidAction (0x%04" PRIx16 ")", chip::to_underlying(status)); |
| break; |
| case Protocols::InteractionModel::ProtocolCode::UnsupportedCommand: |
| ChipLogProgress(Zcl, " status: UnsupportedCommand (0x%04" PRIx16 ")", chip::to_underlying(status)); |
| break; |
| case Protocols::InteractionModel::ProtocolCode::Deprecated82: |
| ChipLogProgress(Zcl, " status: Deprecated82 (0x%04" PRIx16 ")", chip::to_underlying(status)); |
| break; |
| case Protocols::InteractionModel::ProtocolCode::Deprecated83: |
| ChipLogProgress(Zcl, " status: Deprecated83 (0x%04" PRIx16 ")", chip::to_underlying(status)); |
| break; |
| case Protocols::InteractionModel::ProtocolCode::Deprecated84: |
| ChipLogProgress(Zcl, " status: Deprecated84 (0x%04" PRIx16 ")", chip::to_underlying(status)); |
| break; |
| case Protocols::InteractionModel::ProtocolCode::InvalidCommand: |
| ChipLogProgress(Zcl, " status: InvalidCommand (0x%04" PRIx16 ")", chip::to_underlying(status)); |
| break; |
| case Protocols::InteractionModel::ProtocolCode::UnsupportedAttribute: |
| ChipLogProgress(Zcl, " status: UnsupportedAttribute (0x%04" PRIx16 ")", chip::to_underlying(status)); |
| break; |
| case Protocols::InteractionModel::ProtocolCode::InvalidValue: |
| ChipLogProgress(Zcl, " status: InvalidValue (0x%04" PRIx16 ")", chip::to_underlying(status)); |
| break; |
| case Protocols::InteractionModel::ProtocolCode::UnsupportedWrite: |
| ChipLogProgress(Zcl, " status: UnsupportedWrite (0x%04" PRIx16 ")", chip::to_underlying(status)); |
| break; |
| case Protocols::InteractionModel::ProtocolCode::ResourceExhausted: |
| ChipLogProgress(Zcl, " status: ResourceExhausted (0x%04" PRIx16 ")", chip::to_underlying(status)); |
| break; |
| case Protocols::InteractionModel::ProtocolCode::Deprecated8a: |
| ChipLogProgress(Zcl, " status: Deprecated8a (0x%04" PRIx16 ")", chip::to_underlying(status)); |
| break; |
| case Protocols::InteractionModel::ProtocolCode::NotFound: |
| ChipLogProgress(Zcl, " status: NotFound (0x%04" PRIx16 ")", chip::to_underlying(status)); |
| break; |
| case Protocols::InteractionModel::ProtocolCode::UnreportableAttribute: |
| ChipLogProgress(Zcl, " status: UnreportableAttribute (0x%04" PRIx16 ")", chip::to_underlying(status)); |
| break; |
| case Protocols::InteractionModel::ProtocolCode::InvalidDataType: |
| ChipLogProgress(Zcl, " status: InvalidDataType (0x%04" PRIx16 ")", chip::to_underlying(status)); |
| break; |
| case Protocols::InteractionModel::ProtocolCode::Deprecated8e: |
| ChipLogProgress(Zcl, " status: Deprecated8e (0x%04" PRIx16 ")", chip::to_underlying(status)); |
| break; |
| case Protocols::InteractionModel::ProtocolCode::UnsupportedRead: |
| ChipLogProgress(Zcl, " status: UnsupportedRead (0x%04" PRIx16 ")", chip::to_underlying(status)); |
| break; |
| case Protocols::InteractionModel::ProtocolCode::Deprecated90: |
| ChipLogProgress(Zcl, " status: Deprecated90 (0x%04" PRIx16 ")", chip::to_underlying(status)); |
| break; |
| case Protocols::InteractionModel::ProtocolCode::Deprecated91: |
| ChipLogProgress(Zcl, " status: Deprecated91 (0x%04" PRIx16 ")", chip::to_underlying(status)); |
| break; |
| case Protocols::InteractionModel::ProtocolCode::Reserved92: |
| ChipLogProgress(Zcl, " status: Reserved92 (0x%04" PRIx16 ")", chip::to_underlying(status)); |
| break; |
| case Protocols::InteractionModel::ProtocolCode::Deprecated93: |
| ChipLogProgress(Zcl, " status: Deprecated93 (0x%04" PRIx16 ")", chip::to_underlying(status)); |
| break; |
| case Protocols::InteractionModel::ProtocolCode::Timeout: |
| ChipLogProgress(Zcl, " status: Timeout (0x%04" PRIx16 ")", chip::to_underlying(status)); |
| break; |
| case Protocols::InteractionModel::ProtocolCode::Reserved95: |
| ChipLogProgress(Zcl, " status: Reserved95 (0x%04" PRIx16 ")", chip::to_underlying(status)); |
| break; |
| case Protocols::InteractionModel::ProtocolCode::Reserved96: |
| ChipLogProgress(Zcl, " status: Reserved96 (0x%04" PRIx16 ")", chip::to_underlying(status)); |
| break; |
| case Protocols::InteractionModel::ProtocolCode::Reserved97: |
| ChipLogProgress(Zcl, " status: Reserved97 (0x%04" PRIx16 ")", chip::to_underlying(status)); |
| break; |
| case Protocols::InteractionModel::ProtocolCode::Reserved98: |
| ChipLogProgress(Zcl, " status: Reserved98 (0x%04" PRIx16 ")", chip::to_underlying(status)); |
| break; |
| case Protocols::InteractionModel::ProtocolCode::Reserved99: |
| ChipLogProgress(Zcl, " status: Reserved99 (0x%04" PRIx16 ")", chip::to_underlying(status)); |
| break; |
| case Protocols::InteractionModel::ProtocolCode::Reserved9a: |
| ChipLogProgress(Zcl, " status: Reserved9a (0x%04" PRIx16 ")", chip::to_underlying(status)); |
| break; |
| case Protocols::InteractionModel::ProtocolCode::ConstraintError: |
| ChipLogProgress(Zcl, " status: ConstraintError (0x%04" PRIx16 ")", chip::to_underlying(status)); |
| break; |
| case Protocols::InteractionModel::ProtocolCode::Busy: |
| ChipLogProgress(Zcl, " status: Busy (0x%04" PRIx16 ")", chip::to_underlying(status)); |
| break; |
| case Protocols::InteractionModel::ProtocolCode::Deprecatedc0: |
| ChipLogProgress(Zcl, " status: Deprecatedc0 (0x%04" PRIx16 ")", chip::to_underlying(status)); |
| break; |
| case Protocols::InteractionModel::ProtocolCode::Deprecatedc1: |
| ChipLogProgress(Zcl, " status: Deprecatedc1 (0x%04" PRIx16 ")", chip::to_underlying(status)); |
| break; |
| case Protocols::InteractionModel::ProtocolCode::Deprecatedc2: |
| ChipLogProgress(Zcl, " status: Deprecatedc2 (0x%04" PRIx16 ")", chip::to_underlying(status)); |
| break; |
| case Protocols::InteractionModel::ProtocolCode::UnsupportedCluster: |
| ChipLogProgress(Zcl, " status: UnsupportedCluster (0x%04" PRIx16 ")", chip::to_underlying(status)); |
| break; |
| case Protocols::InteractionModel::ProtocolCode::Deprecatedc4: |
| ChipLogProgress(Zcl, " status: Deprecatedc4 (0x%04" PRIx16 ")", chip::to_underlying(status)); |
| break; |
| case Protocols::InteractionModel::ProtocolCode::NoUpstreamSubscription: |
| ChipLogProgress(Zcl, " status: NoUpstreamSubscription (0x%04" PRIx16 ")", chip::to_underlying(status)); |
| break; |
| case Protocols::InteractionModel::ProtocolCode::InvalidArgument: |
| ChipLogProgress(Zcl, " status: InvalidArgument (0x%04" PRIx16 ")", chip::to_underlying(status)); |
| break; |
| default: |
| ChipLogError(Zcl, "Unknown status: 0x%04" PRIx16, chip::to_underlying(status)); |
| break; |
| } |
| } |
| |
| // Singleton instance of the callbacks manager |
| app::CHIPDeviceCallbacksMgr & gCallbacks = app::CHIPDeviceCallbacksMgr::GetInstance(); |
| |
| bool emberAfDefaultResponseCallback(ClusterId clusterId, CommandId commandId, EmberAfStatus status) |
| { |
| ChipLogProgress(Zcl, "DefaultResponse:"); |
| ChipLogProgress(Zcl, " ClusterId: " ChipLogFormatMEI, ChipLogValueMEI(clusterId)); |
| ChipLogProgress(Zcl, " CommandId: " ChipLogFormatMEI, ChipLogValueMEI(commandId)); |
| LogStatus(status); |
| |
| GET_RESPONSE_CALLBACKS("emberAfDefaultResponseCallback"); |
| if (status == EMBER_ZCL_STATUS_SUCCESS) |
| { |
| Callback::Callback<DefaultSuccessCallback> * cb = |
| Callback::Callback<DefaultSuccessCallback>::FromCancelable(onSuccessCallback); |
| cb->mCall(cb->mContext); |
| } |
| else |
| { |
| Callback::Callback<DefaultFailureCallback> * cb = |
| Callback::Callback<DefaultFailureCallback>::FromCancelable(onFailureCallback); |
| cb->mCall(cb->mContext, static_cast<uint8_t>(status)); |
| } |
| |
| return true; |
| } |
| |
| bool IMDefaultResponseCallback(const chip::app::Command * commandObj, EmberAfStatus status) |
| { |
| ChipLogProgress(Zcl, "DefaultResponse:"); |
| ChipLogProgress(Zcl, " Transaction: %p", commandObj); |
| LogStatus(status); |
| |
| GET_CLUSTER_RESPONSE_CALLBACKS("emberAfDefaultResponseCallback"); |
| if (status == EMBER_ZCL_STATUS_SUCCESS) |
| { |
| Callback::Callback<DefaultSuccessCallback> * cb = |
| Callback::Callback<DefaultSuccessCallback>::FromCancelable(onSuccessCallback); |
| cb->mCall(cb->mContext); |
| } |
| else |
| { |
| Callback::Callback<DefaultFailureCallback> * cb = |
| Callback::Callback<DefaultFailureCallback>::FromCancelable(onFailureCallback); |
| cb->mCall(cb->mContext, static_cast<uint8_t>(status)); |
| } |
| |
| return true; |
| } |
| |
| bool IMWriteResponseCallback(const chip::app::WriteClient * writeClient, EmberAfStatus status) |
| { |
| ChipLogProgress(Zcl, "WriteResponse:"); |
| LogStatus(status); |
| |
| Callback::Cancelable * onSuccessCallback = nullptr; |
| Callback::Cancelable * onFailureCallback = nullptr; |
| NodeId sourceNodeId = writeClient->GetSourceNodeId(); |
| uint8_t seq = static_cast<uint8_t>(writeClient->GetAppIdentifier()); |
| CHIP_ERROR err = gCallbacks.GetResponseCallback(sourceNodeId, seq, &onSuccessCallback, &onFailureCallback); |
| |
| if (CHIP_NO_ERROR != err) |
| { |
| if (onSuccessCallback == nullptr) |
| { |
| ChipLogDetail(Zcl, "%s: Missing success callback", __FUNCTION__); |
| } |
| |
| if (onFailureCallback == nullptr) |
| { |
| ChipLogDetail(Zcl, "%s: Missing failure callback", __FUNCTION__); |
| } |
| |
| return true; |
| } |
| |
| if (status == EMBER_ZCL_STATUS_SUCCESS) |
| { |
| Callback::Callback<DefaultSuccessCallback> * cb = |
| Callback::Callback<DefaultSuccessCallback>::FromCancelable(onSuccessCallback); |
| cb->mCall(cb->mContext); |
| } |
| else |
| { |
| Callback::Callback<DefaultFailureCallback> * cb = |
| Callback::Callback<DefaultFailureCallback>::FromCancelable(onFailureCallback); |
| cb->mCall(cb->mContext, static_cast<uint8_t>(status)); |
| } |
| |
| return true; |
| } |
| |
| bool IMReadReportAttributesResponseCallback(const app::ReadClient * apReadClient, const app::ClusterInfo & aPath, |
| TLV::TLVReader * apData, Protocols::InteractionModel::ProtocolCode status) |
| { |
| ChipLogProgress(Zcl, "ReadAttributesResponse:"); |
| ChipLogProgress(Zcl, " ClusterId: " ChipLogFormatMEI, ChipLogValueMEI(aPath.mClusterId)); |
| |
| Callback::Cancelable * onSuccessCallback = nullptr; |
| Callback::Cancelable * onFailureCallback = nullptr; |
| app::TLVDataFilter tlvFilter = nullptr; |
| NodeId sourceId = aPath.mNodeId; |
| // In CHIPClusters.cpp, we are using sequenceNumber as application identifier. |
| uint8_t sequenceNumber = static_cast<uint8_t>(apReadClient->GetAppIdentifier()); |
| CHIP_ERROR err = gCallbacks.GetResponseCallback(sourceId, sequenceNumber, &onSuccessCallback, &onFailureCallback, &tlvFilter); |
| |
| if (CHIP_NO_ERROR != err) |
| { |
| if (onSuccessCallback == nullptr) |
| { |
| ChipLogDetail(Zcl, "%s: Missing success callback", __FUNCTION__); |
| } |
| |
| if (onFailureCallback == nullptr) |
| { |
| ChipLogDetail(Zcl, "%s: Missing failure callback", __FUNCTION__); |
| } |
| |
| if (tlvFilter == nullptr) |
| { |
| ChipLogDetail(Zcl, "%s: Missing TLV Data Filter", __FUNCTION__); |
| } |
| return true; |
| } |
| |
| ChipLogProgress(Zcl, " attributeId: " ChipLogFormatMEI, ChipLogValueMEI(aPath.mFieldId)); |
| LogIMStatus(status); |
| |
| if (status == Protocols::InteractionModel::ProtocolCode::Success && apData != nullptr) |
| { |
| ChipLogProgress(Zcl, " attribute TLV Type: 0x%02x", apData->GetType()); |
| tlvFilter(apData, onSuccessCallback, onFailureCallback); |
| } |
| else |
| { |
| Callback::Callback<DefaultFailureCallback> * cb = |
| Callback::Callback<DefaultFailureCallback>::FromCancelable(onFailureCallback); |
| // TODO: Should change failure callbacks to accept uint16 status code. |
| cb->mCall(cb->mContext, static_cast<uint8_t>(chip::to_underlying(status))); |
| } |
| |
| return true; |
| } |
| |
| bool emberAfWriteAttributesResponseCallback(ClusterId clusterId, uint8_t * message, uint16_t messageLen) |
| { |
| ChipLogProgress(Zcl, "WriteAttributesResponse:"); |
| ChipLogProgress(Zcl, " ClusterId: " ChipLogFormatMEI, ChipLogValueMEI(clusterId)); |
| |
| GET_RESPONSE_CALLBACKS("emberAfWriteAttributesResponseCallback"); |
| |
| // struct writeAttributeResponseRecord[] |
| while (messageLen) |
| { |
| CHECK_MESSAGE_LENGTH(1); |
| uint8_t status = chip::Encoding::Read8(message); // zclStatus |
| LogStatus(status); |
| |
| if (status == EMBER_ZCL_STATUS_SUCCESS) |
| { |
| Callback::Callback<DefaultSuccessCallback> * cb = |
| Callback::Callback<DefaultSuccessCallback>::FromCancelable(onSuccessCallback); |
| cb->mCall(cb->mContext); |
| } |
| else |
| { |
| CHECK_MESSAGE_LENGTH(4); |
| AttributeId attributeId = chip::Encoding::LittleEndian::Read32(message); // attribId |
| ChipLogProgress(Zcl, " attributeId: " ChipLogFormatMEI, ChipLogValueMEI(attributeId)); |
| // Silence unused var warning if progress logging is disabled. Note |
| // that we _do_ want to call Read32 unconditionally here, because we |
| // want to advance the 'message' pointer even if we don't use |
| // attributeId. |
| UNUSED_VAR(attributeId); |
| |
| Callback::Callback<DefaultFailureCallback> * cb = |
| Callback::Callback<DefaultFailureCallback>::FromCancelable(onFailureCallback); |
| cb->mCall(cb->mContext, status); |
| } |
| |
| // The current code is written matching the current API where there is a single attribute written |
| // per write command. So if multiple attributes are written at the same time, something is wrong |
| // somewhere. |
| if (messageLen) |
| { |
| ChipLogError(Zcl, "Multiple attributes written at the same time. Something went wrong."); |
| break; |
| } |
| } |
| |
| return true; |
| } |
| |
| bool emberAfConfigureReportingResponseCallback(ClusterId clusterId, uint8_t * message, uint16_t messageLen) |
| { |
| ChipLogProgress(Zcl, "ConfigureReportingResponseCallback:"); |
| ChipLogProgress(Zcl, " ClusterId: " ChipLogFormatMEI, ChipLogValueMEI(clusterId)); |
| |
| GET_RESPONSE_CALLBACKS("emberAfConfigureReportingResponseCallback"); |
| |
| // struct configureReportingResponseRecord[] |
| while (messageLen) |
| { |
| CHECK_MESSAGE_LENGTH(1); |
| uint8_t status = chip::Encoding::Read8(message); // zclStatus |
| LogStatus(status); |
| |
| if (status == EMBER_ZCL_STATUS_SUCCESS) |
| { |
| Callback::Callback<DefaultSuccessCallback> * cb = |
| Callback::Callback<DefaultSuccessCallback>::FromCancelable(onSuccessCallback); |
| cb->mCall(cb->mContext); |
| } |
| else |
| { |
| CHECK_MESSAGE_LENGTH(1); |
| uint8_t direction = chip::Encoding::Read8(message); // reportingRole |
| ChipLogProgress(Zcl, " direction: 0x%02x", direction); |
| // Silence unused var warning if progress logging is disabled. Note |
| // that we _do_ want to call Read8 unconditionally here, because we |
| // want to advance the 'message' pointer even if we don't use |
| // direction. |
| UNUSED_VAR(direction); |
| |
| CHECK_MESSAGE_LENGTH(4); |
| AttributeId attributeId = chip::Encoding::LittleEndian::Read32(message); // attribId |
| ChipLogProgress(Zcl, " attributeId: " ChipLogFormatMEI, ChipLogValueMEI(attributeId)); |
| // Silence unused var warning if progress logging is disabled. Note |
| // that we _do_ want to call Read32 unconditionally here, because we |
| // want to advance the 'message' pointer even if we don't use |
| // direction. |
| UNUSED_VAR(attributeId); |
| |
| Callback::Callback<DefaultFailureCallback> * cb = |
| Callback::Callback<DefaultFailureCallback>::FromCancelable(onFailureCallback); |
| cb->mCall(cb->mContext, status); |
| } |
| |
| // The current code is written matching the current API where there is a single attribute report |
| // per configure command. So if multiple attributes are configured at the same time, something is wrong |
| // somewhere. |
| if (messageLen) |
| { |
| ChipLogError(Zcl, "Multiple attributes reports configured at the same time. Something went wrong."); |
| break; |
| } |
| } |
| |
| return true; |
| } |
| |
| bool emberAfReadReportingConfigurationResponseCallback(chip::ClusterId clusterId, uint8_t * message, uint16_t messageLen) |
| { |
| ChipLogProgress(Zcl, "ReadReportingConfigurationResponse:"); |
| ChipLogProgress(Zcl, " ClusterId: " ChipLogFormatMEI, ChipLogValueMEI(clusterId)); |
| |
| GET_RESPONSE_CALLBACKS("emberAfReadReportingConfigurationResponseCallback"); |
| |
| // struct readReportingConfigurationResponseRecord[] |
| while (messageLen) |
| { |
| CHECK_MESSAGE_LENGTH(1); |
| uint8_t direction = chip::Encoding::Read8(message); // reportingRole |
| ChipLogProgress(Zcl, " direction: 0x%02x", direction); |
| |
| CHECK_MESSAGE_LENGTH(4); |
| AttributeId attributeId = chip::Encoding::LittleEndian::Read32(message); // attribId |
| ChipLogProgress(Zcl, " attributeId: " ChipLogFormatMEI, ChipLogValueMEI(attributeId)); |
| // Silence unused var warning if progress logging is disabled. Note |
| // that we _do_ want to call Read32 unconditionally here, because we |
| // want to advance the 'message' pointer even if we don't use |
| // attributeId. |
| UNUSED_VAR(attributeId); |
| |
| if (direction == EMBER_ZCL_REPORTING_DIRECTION_REPORTED) |
| { |
| CHECK_MESSAGE_LENGTH(1); |
| uint8_t attributeType = chip::Encoding::Read8(message); // zclType |
| ChipLogProgress(Zcl, " attributeType: 0x%02x", attributeType); |
| // Silence unused var warning if progress logging is disabled. Note |
| // that we _do_ want to call Read8 unconditionally here, because we |
| // want to advance the 'message' pointer even if we don't use |
| // attributeType. |
| UNUSED_VAR(attributeType); |
| |
| CHECK_MESSAGE_LENGTH(2); |
| uint16_t minimumReportingInterval = chip::Encoding::LittleEndian::Read16(message); // uint16 |
| ChipLogProgress(Zcl, " minimumReportingInterval: %" PRIu16, minimumReportingInterval); |
| |
| CHECK_MESSAGE_LENGTH(2); |
| uint16_t maximumReportingInterval = chip::Encoding::LittleEndian::Read16(message); // uint16 |
| ChipLogProgress(Zcl, " maximumReportingInterval: %" PRIu16, maximumReportingInterval); |
| |
| // FIXME: unk is not supported yet. |
| |
| Callback::Callback<ReadReportingConfigurationReportedCallback> * cb = |
| Callback::Callback<ReadReportingConfigurationReportedCallback>::FromCancelable(onSuccessCallback); |
| cb->mCall(cb->mContext, minimumReportingInterval, maximumReportingInterval); |
| } |
| else |
| { |
| CHECK_MESSAGE_LENGTH(2); |
| uint16_t timeout = chip::Encoding::LittleEndian::Read16(message); // uint16 |
| ChipLogProgress(Zcl, " timeout: %" PRIu16, timeout); |
| |
| Callback::Callback<ReadReportingConfigurationReceivedCallback> * cb = |
| Callback::Callback<ReadReportingConfigurationReceivedCallback>::FromCancelable(onSuccessCallback); |
| cb->mCall(cb->mContext, timeout); |
| } |
| } |
| |
| return true; |
| } |
| |
| bool emberAfDiscoverAttributesResponseCallback(ClusterId clusterId, bool discoveryComplete, uint8_t * message, uint16_t messageLen, |
| bool extended) |
| { |
| ChipLogProgress(Zcl, "DiscoverAttributesResponse:"); |
| ChipLogProgress(Zcl, " ClusterId: " ChipLogFormatMEI, ChipLogValueMEI(clusterId)); |
| ChipLogProgress(Zcl, " discoveryComplete: %d", discoveryComplete); |
| ChipLogProgress(Zcl, " extended: %d", extended); |
| |
| GET_RESPONSE_CALLBACKS("emberAfDiscoverAttributesCallback"); |
| |
| // struct discoverAttributesResponseRecord[] |
| while (messageLen) |
| { |
| CHECK_MESSAGE_LENGTH(4); |
| AttributeId attributeId = chip::Encoding::LittleEndian::Read32(message); // attribId |
| ChipLogProgress(Zcl, " attributeId: " ChipLogFormatMEI, ChipLogValueMEI(attributeId)); |
| // Silence unused var warning if progress logging is disabled. Note |
| // that we _do_ want to call Read32 unconditionally here, because we |
| // want to advance the 'message' pointer even if we don't use |
| // attributeId. |
| UNUSED_VAR(attributeId); |
| |
| CHECK_MESSAGE_LENGTH(1); |
| uint8_t attributeType = chip::Encoding::Read8(message); // zclType |
| ChipLogProgress(Zcl, " attributeType: 0x%02x", attributeType); |
| // Silence unused var warning if progress logging is disabled. Note |
| // that we _do_ want to call Read8 unconditionally here, because we want |
| // to advance the 'message' pointer even if we don't use attributeType. |
| UNUSED_VAR(attributeType); |
| } |
| |
| Callback::Callback<DefaultSuccessCallback> * cb = Callback::Callback<DefaultSuccessCallback>::FromCancelable(onSuccessCallback); |
| cb->mCall(cb->mContext); |
| return true; |
| } |
| |
| bool emberAfDiscoverCommandsGeneratedResponseCallback(ClusterId clusterId, uint16_t manufacturerCode, bool discoveryComplete, |
| CommandId * commandIds, uint16_t commandIdCount) |
| { |
| ChipLogProgress(Zcl, "DiscoverCommandsGeneratedResponse:"); |
| ChipLogProgress(Zcl, " ClusterId: " ChipLogFormatMEI, ChipLogValueMEI(clusterId)); |
| ChipLogProgress(Zcl, " manufacturerCode: 0x%04x", manufacturerCode); |
| ChipLogProgress(Zcl, " discoveryComplete: %d", discoveryComplete); |
| ChipLogProgress(Zcl, " commandIdCount: %" PRIu16, commandIdCount); |
| |
| for (uint16_t i = 0; i < commandIdCount; i++) |
| { |
| ChipLogProgress(Zcl, " commandId: " ChipLogFormatMEI, ChipLogValueMEI(*commandIds)); |
| commandIds++; |
| } |
| |
| GET_RESPONSE_CALLBACKS("emberAfDiscoverCommandsGeneratedResponseCallback"); |
| Callback::Callback<DefaultSuccessCallback> * cb = Callback::Callback<DefaultSuccessCallback>::FromCancelable(onSuccessCallback); |
| cb->mCall(cb->mContext); |
| return true; |
| } |
| |
| bool emberAfDiscoverCommandsReceivedResponseCallback(ClusterId clusterId, uint16_t manufacturerCode, bool discoveryComplete, |
| CommandId * commandIds, uint16_t commandIdCount) |
| { |
| ChipLogProgress(Zcl, "DiscoverCommandsReceivedResponse:"); |
| ChipLogProgress(Zcl, " ClusterId: " ChipLogFormatMEI, ChipLogValueMEI(clusterId)); |
| ChipLogProgress(Zcl, " manufacturerCode: 0x%04x", manufacturerCode); |
| ChipLogProgress(Zcl, " discoveryComplete: %d", discoveryComplete); |
| ChipLogProgress(Zcl, " commandIdCount: %" PRIu16, commandIdCount); |
| |
| for (uint16_t i = 0; i < commandIdCount; i++) |
| { |
| ChipLogProgress(Zcl, " commandId: " ChipLogFormatMEI, ChipLogValueMEI(*commandIds)); |
| commandIds++; |
| } |
| |
| GET_RESPONSE_CALLBACKS("emberAfDiscoverCommandsGeneratedResponseCallback"); |
| Callback::Callback<DefaultSuccessCallback> * cb = Callback::Callback<DefaultSuccessCallback>::FromCancelable(onSuccessCallback); |
| cb->mCall(cb->mContext); |
| return true; |
| } |
| |
| static EmberAfStatus PrepareListFromTLV(TLV::TLVReader * tlvData, const uint8_t *& message, uint16_t & messageLen) |
| { |
| CHIP_ERROR tlvError = CHIP_NO_ERROR; |
| TLV::TLVReader reader; |
| TLV::TLVType type; |
| reader.Init(*tlvData); |
| reader.EnterContainer(type); |
| tlvError = reader.Next(); |
| if (tlvError != CHIP_NO_ERROR && tlvError != CHIP_END_OF_TLV && chip::CanCastTo<uint16_t>(reader.GetLength())) |
| { |
| return EMBER_ZCL_STATUS_INVALID_VALUE; |
| } |
| if (tlvError == CHIP_NO_ERROR) |
| { |
| tlvError = reader.GetDataPtr(message); |
| messageLen = static_cast<uint16_t>(reader.GetLength()); |
| } |
| if (tlvError != CHIP_NO_ERROR) |
| { |
| return EMBER_ZCL_STATUS_INVALID_VALUE; |
| } |
| reader.ExitContainer(type); |
| return EMBER_ZCL_STATUS_SUCCESS; |
| } |
| |
| bool emberAfReportAttributesCallback(ClusterId clusterId, uint8_t * message, uint16_t messageLen) |
| { |
| ChipLogProgress(Zcl, "emberAfReportAttributeCallback:"); |
| ChipLogProgress(Zcl, " ClusterId: " ChipLogFormatMEI, ChipLogValueMEI(clusterId)); |
| |
| NodeId sourceId = emberAfCurrentCommand()->SourceNodeId(); |
| ChipLogProgress(Zcl, " Source NodeId: %" PRIu64, sourceId); |
| |
| EndpointId endpointId = emberAfCurrentCommand()->apsFrame->sourceEndpoint; |
| ChipLogProgress(Zcl, " Source EndpointId: 0x%04x", endpointId); |
| |
| // TODO onFailureCallback is just here because of the CHECK_MESSAGE_LENGTH macro. It needs to be removed. |
| Callback::Cancelable * onFailureCallback = nullptr; |
| |
| while (messageLen) |
| { |
| CHECK_MESSAGE_LENGTH(4); |
| AttributeId attributeId = chip::Encoding::LittleEndian::Read32(message); // attribId |
| ChipLogProgress(Zcl, " attributeId: " ChipLogFormatMEI, ChipLogValueMEI(attributeId)); |
| |
| GET_REPORT_CALLBACK("emberAfReportAttributesCallback"); |
| |
| CHECK_MESSAGE_LENGTH(1); |
| uint8_t attributeType = chip::Encoding::Read8(message); |
| ChipLogProgress(Zcl, " attributeType: 0x%02x", attributeType); |
| |
| switch (attributeType) |
| { |
| case 0x00: // nodata / No data |
| case 0x0A: // data24 / 24-bit data |
| case 0x0C: // data40 / 40-bit data |
| case 0x0D: // data48 / 48-bit data |
| case 0x0E: // data56 / 56-bit data |
| case 0x1A: // map24 / 24-bit bitmap |
| case 0x1C: // map40 / 40-bit bitmap |
| case 0x1D: // map48 / 48-bit bitmap |
| case 0x1E: // map56 / 56-bit bitmap |
| case 0x22: // uint24 / Unsigned 24-bit integer |
| case 0x24: // uint40 / Unsigned 40-bit integer |
| case 0x25: // uint48 / Unsigned 48-bit integer |
| case 0x26: // uint56 / Unsigned 56-bit integer |
| case 0x2A: // int24 / Signed 24-bit integer |
| case 0x2C: // int40 / Signed 40-bit integer |
| case 0x2D: // int48 / Signed 48-bit integer |
| case 0x2E: // int56 / Signed 56-bit integer |
| case 0x38: // semi / Semi-precision |
| case 0x39: // single / Single precision |
| case 0x3A: // double / Double precision |
| case 0x48: // array / Array |
| case 0x49: // struct / Structure |
| case 0x50: // set / Set |
| case 0x51: // bag / Bag |
| case 0xE0: // ToD / Time of day |
| { |
| ChipLogError(Zcl, "attributeType 0x%02x is not supported", attributeType); |
| return true; |
| } |
| |
| case 0x41: // octstr / Octet string |
| case 0x42: // string / Character string |
| { |
| // Short Strings must contains at least one byte for the length |
| CHECK_MESSAGE_LENGTH(1); |
| uint8_t length = chip::Encoding::Read8(message); |
| ChipLogProgress(Zcl, " length: 0x%02x", length); |
| |
| // When the length is set to 0xFF, it represents a non-value. In this case the data field is zero length. |
| if (length == 0xFF) |
| { |
| length = 0; |
| } |
| |
| CHECK_MESSAGE_LENGTH(length); |
| if (attributeType == 0x41) |
| { |
| Callback::Callback<OctetStringAttributeCallback> * cb = |
| Callback::Callback<OctetStringAttributeCallback>::FromCancelable(onReportCallback); |
| cb->mCall(cb->mContext, chip::ByteSpan(message, length)); |
| } |
| else |
| { |
| Callback::Callback<CharStringAttributeCallback> * cb = |
| Callback::Callback<CharStringAttributeCallback>::FromCancelable(onReportCallback); |
| cb->mCall(cb->mContext, chip::ByteSpan(message, length)); |
| } |
| break; |
| } |
| |
| case 0x43: // octstr16 / Long octet string |
| case 0x44: // string16 / Long character string |
| { |
| // Long Strings must contains at least two bytes for the length |
| CHECK_MESSAGE_LENGTH(2); |
| uint16_t length = chip::Encoding::LittleEndian::Read16(message); |
| ChipLogProgress(Zcl, " length: 0x%02x", length); |
| |
| // When the length is set to 0xFFFF, it represents a non-value. In this case the data field is zero length. |
| if (length == 0xFFFF) |
| { |
| length = 0; |
| } |
| |
| CHECK_MESSAGE_LENGTH(length); |
| if (attributeType == 0x43) |
| { |
| Callback::Callback<OctetStringAttributeCallback> * cb = |
| Callback::Callback<OctetStringAttributeCallback>::FromCancelable(onReportCallback); |
| cb->mCall(cb->mContext, chip::ByteSpan(message, length)); |
| } |
| else |
| { |
| Callback::Callback<CharStringAttributeCallback> * cb = |
| Callback::Callback<CharStringAttributeCallback>::FromCancelable(onReportCallback); |
| cb->mCall(cb->mContext, chip::ByteSpan(message, length)); |
| } |
| break; |
| } |
| |
| case 0x08: // data8 / 8-bit data |
| case 0x18: // map8 / 8-bit bitmap |
| case 0x20: // uint8 / Unsigned 8-bit integer |
| case 0x30: // enum8 / 8-bit enumeration |
| { |
| CHECK_MESSAGE_LENGTH(1); |
| uint8_t value = chip::Encoding::Read8(message); |
| ChipLogProgress(Zcl, " value: 0x%02x", value); |
| |
| Callback::Callback<Int8uAttributeCallback> * cb = |
| Callback::Callback<Int8uAttributeCallback>::FromCancelable(onReportCallback); |
| cb->mCall(cb->mContext, value); |
| break; |
| } |
| |
| case 0x09: // data16 / 16-bit data |
| case 0x19: // map16 / 16-bit bitmap |
| case 0x21: // uint16 / Unsigned 16-bit integer |
| case 0x31: // enum16 / 16-bit enumeration |
| case 0xE8: // clusterId / Cluster ID |
| case 0xE9: // attribId / Attribute ID |
| case 0xEA: // bacOID / BACnet OID |
| case 0xF1: // key128 / 128-bit security key |
| case 0xFF: // unk / Unknown |
| { |
| CHECK_MESSAGE_LENGTH(2); |
| uint16_t value = chip::Encoding::LittleEndian::Read16(message); |
| ChipLogProgress(Zcl, " value: 0x%04x", value); |
| |
| Callback::Callback<Int16uAttributeCallback> * cb = |
| Callback::Callback<Int16uAttributeCallback>::FromCancelable(onReportCallback); |
| cb->mCall(cb->mContext, value); |
| break; |
| } |
| |
| case 0x0B: // data32 / 32-bit data |
| case 0x1B: // map32 / 32-bit bitmap |
| case 0x23: // uint32 / Unsigned 32-bit integer |
| case 0xE1: // date / Date |
| case 0xE2: // UTC / UTCTime |
| { |
| CHECK_MESSAGE_LENGTH(4); |
| uint32_t value = chip::Encoding::LittleEndian::Read32(message); |
| ChipLogProgress(Zcl, " value: 0x%08x", value); |
| |
| Callback::Callback<Int32uAttributeCallback> * cb = |
| Callback::Callback<Int32uAttributeCallback>::FromCancelable(onReportCallback); |
| cb->mCall(cb->mContext, value); |
| break; |
| } |
| |
| case 0x0F: // data64 / 64-bit data |
| case 0x1F: // map64 / 64-bit bitmap |
| case 0x27: // uint64 / Unsigned 64-bit integer |
| case 0xF0: // EUI64 / IEEE address |
| { |
| CHECK_MESSAGE_LENGTH(8); |
| uint64_t value = chip::Encoding::LittleEndian::Read64(message); |
| ChipLogProgress(Zcl, " value: 0x" ChipLogFormatX64, ChipLogValueX64(value)); |
| |
| Callback::Callback<Int64uAttributeCallback> * cb = |
| Callback::Callback<Int64uAttributeCallback>::FromCancelable(onReportCallback); |
| cb->mCall(cb->mContext, value); |
| break; |
| } |
| |
| case 0x10: // bool / Boolean |
| { |
| CHECK_MESSAGE_LENGTH(1); |
| uint8_t value = chip::Encoding::Read8(message); |
| ChipLogProgress(Zcl, " value: %d", value); |
| |
| Callback::Callback<BooleanAttributeCallback> * cb = |
| Callback::Callback<BooleanAttributeCallback>::FromCancelable(onReportCallback); |
| cb->mCall(cb->mContext, value); |
| break; |
| } |
| |
| case 0x28: // int8 / Signed 8-bit integer |
| { |
| CHECK_MESSAGE_LENGTH(1); |
| int8_t value = chip::CastToSigned(chip::Encoding::Read8(message)); |
| ChipLogProgress(Zcl, " value: %" PRId8, value); |
| |
| Callback::Callback<Int8sAttributeCallback> * cb = |
| Callback::Callback<Int8sAttributeCallback>::FromCancelable(onReportCallback); |
| cb->mCall(cb->mContext, value); |
| break; |
| } |
| |
| case 0x29: // int16 / Signed 16-bit integer |
| { |
| CHECK_MESSAGE_LENGTH(2); |
| int16_t value = chip::CastToSigned(chip::Encoding::LittleEndian::Read16(message)); |
| ChipLogProgress(Zcl, " value: %" PRId16, value); |
| |
| Callback::Callback<Int16sAttributeCallback> * cb = |
| Callback::Callback<Int16sAttributeCallback>::FromCancelable(onReportCallback); |
| cb->mCall(cb->mContext, value); |
| break; |
| } |
| |
| case 0x2B: // int32 / Signed 32-bit integer |
| { |
| CHECK_MESSAGE_LENGTH(4); |
| int32_t value = chip::CastToSigned(chip::Encoding::LittleEndian::Read32(message)); |
| ChipLogProgress(Zcl, " value: %" PRId32, value); |
| |
| Callback::Callback<Int32sAttributeCallback> * cb = |
| Callback::Callback<Int32sAttributeCallback>::FromCancelable(onReportCallback); |
| cb->mCall(cb->mContext, value); |
| break; |
| } |
| |
| case 0x2F: // int64 / Signed 64-bit integer |
| { |
| CHECK_MESSAGE_LENGTH(8); |
| int64_t value = chip::CastToSigned(chip::Encoding::LittleEndian::Read64(message)); |
| ChipLogProgress(Zcl, " value: %" PRId64, value); |
| |
| Callback::Callback<Int64sAttributeCallback> * cb = |
| Callback::Callback<Int64sAttributeCallback>::FromCancelable(onReportCallback); |
| cb->mCall(cb->mContext, value); |
| break; |
| } |
| } |
| } |
| |
| return true; |
| } |
