| /* |
| * |
| * Copyright (c) 2022 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 <cinttypes> |
| #include <cstdint> |
| |
| #include <app-common/zap-generated/af-structs.h> |
| #include <app-common/zap-generated/callback.h> |
| #include <app-common/zap-generated/cluster-objects.h> |
| #include <app-common/zap-generated/ids/Clusters.h> |
| #include <app-common/zap-generated/ids/Commands.h> |
| #include <app/CommandHandler.h> |
| #include <app/InteractionModelEngine.h> |
| #include <app/util/util.h> |
| #include <lib/core/CHIPSafeCasts.h> |
| #include <lib/support/TypeTraits.h> |
| |
| // Currently we need some work to keep compatible with ember lib. |
| #include <app/util/ember-compatibility-functions.h> |
| |
| namespace chip { |
| namespace app { |
| |
| // Cluster specific command parsing |
| |
| namespace Clusters { |
| |
| namespace AccountLogin { |
| |
| void DispatchServerCommand(CommandHandler * apCommandObj, const ConcreteCommandPath & aCommandPath, TLV::TLVReader & aDataTlv) |
| { |
| CHIP_ERROR TLVError = CHIP_NO_ERROR; |
| bool wasHandled = false; |
| { |
| switch (aCommandPath.mCommandId) |
| { |
| case Commands::GetSetupPIN::Id: { |
| Commands::GetSetupPIN::DecodableType commandData; |
| TLVError = DataModel::Decode(aDataTlv, commandData); |
| if (TLVError == CHIP_NO_ERROR) |
| { |
| wasHandled = emberAfAccountLoginClusterGetSetupPINCallback(apCommandObj, aCommandPath, commandData); |
| } |
| break; |
| } |
| case Commands::Login::Id: { |
| Commands::Login::DecodableType commandData; |
| TLVError = DataModel::Decode(aDataTlv, commandData); |
| if (TLVError == CHIP_NO_ERROR) |
| { |
| wasHandled = emberAfAccountLoginClusterLoginCallback(apCommandObj, aCommandPath, commandData); |
| } |
| break; |
| } |
| case Commands::Logout::Id: { |
| Commands::Logout::DecodableType commandData; |
| TLVError = DataModel::Decode(aDataTlv, commandData); |
| if (TLVError == CHIP_NO_ERROR) |
| { |
| wasHandled = emberAfAccountLoginClusterLogoutCallback(apCommandObj, aCommandPath, commandData); |
| } |
| break; |
| } |
| default: { |
| // Unrecognized command ID, error status will apply. |
| apCommandObj->AddStatus(aCommandPath, Protocols::InteractionModel::Status::UnsupportedCommand); |
| ChipLogError(Zcl, "Unknown command " ChipLogFormatMEI " for cluster " ChipLogFormatMEI, |
| ChipLogValueMEI(aCommandPath.mCommandId), ChipLogValueMEI(aCommandPath.mClusterId)); |
| return; |
| } |
| } |
| } |
| |
| if (CHIP_NO_ERROR != TLVError || !wasHandled) |
| { |
| apCommandObj->AddStatus(aCommandPath, Protocols::InteractionModel::Status::InvalidCommand); |
| ChipLogProgress(Zcl, "Failed to dispatch command, TLVError=%" CHIP_ERROR_FORMAT, TLVError.Format()); |
| } |
| } |
| |
| } // namespace AccountLogin |
| |
| namespace AdministratorCommissioning { |
| |
| void DispatchServerCommand(CommandHandler * apCommandObj, const ConcreteCommandPath & aCommandPath, TLV::TLVReader & aDataTlv) |
| { |
| CHIP_ERROR TLVError = CHIP_NO_ERROR; |
| bool wasHandled = false; |
| { |
| switch (aCommandPath.mCommandId) |
| { |
| case Commands::OpenCommissioningWindow::Id: { |
| Commands::OpenCommissioningWindow::DecodableType commandData; |
| TLVError = DataModel::Decode(aDataTlv, commandData); |
| if (TLVError == CHIP_NO_ERROR) |
| { |
| wasHandled = emberAfAdministratorCommissioningClusterOpenCommissioningWindowCallback(apCommandObj, aCommandPath, |
| commandData); |
| } |
| break; |
| } |
| case Commands::RevokeCommissioning::Id: { |
| Commands::RevokeCommissioning::DecodableType commandData; |
| TLVError = DataModel::Decode(aDataTlv, commandData); |
| if (TLVError == CHIP_NO_ERROR) |
| { |
| wasHandled = |
| emberAfAdministratorCommissioningClusterRevokeCommissioningCallback(apCommandObj, aCommandPath, commandData); |
| } |
| break; |
| } |
| default: { |
| // Unrecognized command ID, error status will apply. |
| apCommandObj->AddStatus(aCommandPath, Protocols::InteractionModel::Status::UnsupportedCommand); |
| ChipLogError(Zcl, "Unknown command " ChipLogFormatMEI " for cluster " ChipLogFormatMEI, |
| ChipLogValueMEI(aCommandPath.mCommandId), ChipLogValueMEI(aCommandPath.mClusterId)); |
| return; |
| } |
| } |
| } |
| |
| if (CHIP_NO_ERROR != TLVError || !wasHandled) |
| { |
| apCommandObj->AddStatus(aCommandPath, Protocols::InteractionModel::Status::InvalidCommand); |
| ChipLogProgress(Zcl, "Failed to dispatch command, TLVError=%" CHIP_ERROR_FORMAT, TLVError.Format()); |
| } |
| } |
| |
| } // namespace AdministratorCommissioning |
| |
| namespace ApplicationLauncher { |
| |
| void DispatchServerCommand(CommandHandler * apCommandObj, const ConcreteCommandPath & aCommandPath, TLV::TLVReader & aDataTlv) |
| { |
| CHIP_ERROR TLVError = CHIP_NO_ERROR; |
| bool wasHandled = false; |
| { |
| switch (aCommandPath.mCommandId) |
| { |
| case Commands::LaunchApp::Id: { |
| Commands::LaunchApp::DecodableType commandData; |
| TLVError = DataModel::Decode(aDataTlv, commandData); |
| if (TLVError == CHIP_NO_ERROR) |
| { |
| wasHandled = emberAfApplicationLauncherClusterLaunchAppCallback(apCommandObj, aCommandPath, commandData); |
| } |
| break; |
| } |
| case Commands::StopApp::Id: { |
| Commands::StopApp::DecodableType commandData; |
| TLVError = DataModel::Decode(aDataTlv, commandData); |
| if (TLVError == CHIP_NO_ERROR) |
| { |
| wasHandled = emberAfApplicationLauncherClusterStopAppCallback(apCommandObj, aCommandPath, commandData); |
| } |
| break; |
| } |
| case Commands::HideApp::Id: { |
| Commands::HideApp::DecodableType commandData; |
| TLVError = DataModel::Decode(aDataTlv, commandData); |
| if (TLVError == CHIP_NO_ERROR) |
| { |
| wasHandled = emberAfApplicationLauncherClusterHideAppCallback(apCommandObj, aCommandPath, commandData); |
| } |
| break; |
| } |
| default: { |
| // Unrecognized command ID, error status will apply. |
| apCommandObj->AddStatus(aCommandPath, Protocols::InteractionModel::Status::UnsupportedCommand); |
| ChipLogError(Zcl, "Unknown command " ChipLogFormatMEI " for cluster " ChipLogFormatMEI, |
| ChipLogValueMEI(aCommandPath.mCommandId), ChipLogValueMEI(aCommandPath.mClusterId)); |
| return; |
| } |
| } |
| } |
| |
| if (CHIP_NO_ERROR != TLVError || !wasHandled) |
| { |
| apCommandObj->AddStatus(aCommandPath, Protocols::InteractionModel::Status::InvalidCommand); |
| ChipLogProgress(Zcl, "Failed to dispatch command, TLVError=%" CHIP_ERROR_FORMAT, TLVError.Format()); |
| } |
| } |
| |
| } // namespace ApplicationLauncher |
| |
| namespace AudioOutput { |
| |
| void DispatchServerCommand(CommandHandler * apCommandObj, const ConcreteCommandPath & aCommandPath, TLV::TLVReader & aDataTlv) |
| { |
| CHIP_ERROR TLVError = CHIP_NO_ERROR; |
| bool wasHandled = false; |
| { |
| switch (aCommandPath.mCommandId) |
| { |
| case Commands::SelectOutput::Id: { |
| Commands::SelectOutput::DecodableType commandData; |
| TLVError = DataModel::Decode(aDataTlv, commandData); |
| if (TLVError == CHIP_NO_ERROR) |
| { |
| wasHandled = emberAfAudioOutputClusterSelectOutputCallback(apCommandObj, aCommandPath, commandData); |
| } |
| break; |
| } |
| default: { |
| // Unrecognized command ID, error status will apply. |
| apCommandObj->AddStatus(aCommandPath, Protocols::InteractionModel::Status::UnsupportedCommand); |
| ChipLogError(Zcl, "Unknown command " ChipLogFormatMEI " for cluster " ChipLogFormatMEI, |
| ChipLogValueMEI(aCommandPath.mCommandId), ChipLogValueMEI(aCommandPath.mClusterId)); |
| return; |
| } |
| } |
| } |
| |
| if (CHIP_NO_ERROR != TLVError || !wasHandled) |
| { |
| apCommandObj->AddStatus(aCommandPath, Protocols::InteractionModel::Status::InvalidCommand); |
| ChipLogProgress(Zcl, "Failed to dispatch command, TLVError=%" CHIP_ERROR_FORMAT, TLVError.Format()); |
| } |
| } |
| |
| } // namespace AudioOutput |
| |
| namespace Channel { |
| |
| void DispatchServerCommand(CommandHandler * apCommandObj, const ConcreteCommandPath & aCommandPath, TLV::TLVReader & aDataTlv) |
| { |
| CHIP_ERROR TLVError = CHIP_NO_ERROR; |
| bool wasHandled = false; |
| { |
| switch (aCommandPath.mCommandId) |
| { |
| case Commands::ChangeChannelByNumber::Id: { |
| Commands::ChangeChannelByNumber::DecodableType commandData; |
| TLVError = DataModel::Decode(aDataTlv, commandData); |
| if (TLVError == CHIP_NO_ERROR) |
| { |
| wasHandled = emberAfChannelClusterChangeChannelByNumberCallback(apCommandObj, aCommandPath, commandData); |
| } |
| break; |
| } |
| case Commands::SkipChannel::Id: { |
| Commands::SkipChannel::DecodableType commandData; |
| TLVError = DataModel::Decode(aDataTlv, commandData); |
| if (TLVError == CHIP_NO_ERROR) |
| { |
| wasHandled = emberAfChannelClusterSkipChannelCallback(apCommandObj, aCommandPath, commandData); |
| } |
| break; |
| } |
| default: { |
| // Unrecognized command ID, error status will apply. |
| apCommandObj->AddStatus(aCommandPath, Protocols::InteractionModel::Status::UnsupportedCommand); |
| ChipLogError(Zcl, "Unknown command " ChipLogFormatMEI " for cluster " ChipLogFormatMEI, |
| ChipLogValueMEI(aCommandPath.mCommandId), ChipLogValueMEI(aCommandPath.mClusterId)); |
| return; |
| } |
| } |
| } |
| |
| if (CHIP_NO_ERROR != TLVError || !wasHandled) |
| { |
| apCommandObj->AddStatus(aCommandPath, Protocols::InteractionModel::Status::InvalidCommand); |
| ChipLogProgress(Zcl, "Failed to dispatch command, TLVError=%" CHIP_ERROR_FORMAT, TLVError.Format()); |
| } |
| } |
| |
| } // namespace Channel |
| |
| namespace DiagnosticLogs { |
| |
| void DispatchServerCommand(CommandHandler * apCommandObj, const ConcreteCommandPath & aCommandPath, TLV::TLVReader & aDataTlv) |
| { |
| CHIP_ERROR TLVError = CHIP_NO_ERROR; |
| bool wasHandled = false; |
| { |
| switch (aCommandPath.mCommandId) |
| { |
| case Commands::RetrieveLogsRequest::Id: { |
| Commands::RetrieveLogsRequest::DecodableType commandData; |
| TLVError = DataModel::Decode(aDataTlv, commandData); |
| if (TLVError == CHIP_NO_ERROR) |
| { |
| wasHandled = emberAfDiagnosticLogsClusterRetrieveLogsRequestCallback(apCommandObj, aCommandPath, commandData); |
| } |
| break; |
| } |
| default: { |
| // Unrecognized command ID, error status will apply. |
| apCommandObj->AddStatus(aCommandPath, Protocols::InteractionModel::Status::UnsupportedCommand); |
| ChipLogError(Zcl, "Unknown command " ChipLogFormatMEI " for cluster " ChipLogFormatMEI, |
| ChipLogValueMEI(aCommandPath.mCommandId), ChipLogValueMEI(aCommandPath.mClusterId)); |
| return; |
| } |
| } |
| } |
| |
| if (CHIP_NO_ERROR != TLVError || !wasHandled) |
| { |
| apCommandObj->AddStatus(aCommandPath, Protocols::InteractionModel::Status::InvalidCommand); |
| ChipLogProgress(Zcl, "Failed to dispatch command, TLVError=%" CHIP_ERROR_FORMAT, TLVError.Format()); |
| } |
| } |
| |
| } // namespace DiagnosticLogs |
| |
| namespace DoorLock { |
| |
| void DispatchServerCommand(CommandHandler * apCommandObj, const ConcreteCommandPath & aCommandPath, TLV::TLVReader & aDataTlv) |
| { |
| CHIP_ERROR TLVError = CHIP_NO_ERROR; |
| bool wasHandled = false; |
| { |
| switch (aCommandPath.mCommandId) |
| { |
| case Commands::LockDoor::Id: { |
| Commands::LockDoor::DecodableType commandData; |
| TLVError = DataModel::Decode(aDataTlv, commandData); |
| if (TLVError == CHIP_NO_ERROR) |
| { |
| wasHandled = emberAfDoorLockClusterLockDoorCallback(apCommandObj, aCommandPath, commandData); |
| } |
| break; |
| } |
| case Commands::UnlockDoor::Id: { |
| Commands::UnlockDoor::DecodableType commandData; |
| TLVError = DataModel::Decode(aDataTlv, commandData); |
| if (TLVError == CHIP_NO_ERROR) |
| { |
| wasHandled = emberAfDoorLockClusterUnlockDoorCallback(apCommandObj, aCommandPath, commandData); |
| } |
| break; |
| } |
| default: { |
| // Unrecognized command ID, error status will apply. |
| apCommandObj->AddStatus(aCommandPath, Protocols::InteractionModel::Status::UnsupportedCommand); |
| ChipLogError(Zcl, "Unknown command " ChipLogFormatMEI " for cluster " ChipLogFormatMEI, |
| ChipLogValueMEI(aCommandPath.mCommandId), ChipLogValueMEI(aCommandPath.mClusterId)); |
| return; |
| } |
| } |
| } |
| |
| if (CHIP_NO_ERROR != TLVError || !wasHandled) |
| { |
| apCommandObj->AddStatus(aCommandPath, Protocols::InteractionModel::Status::InvalidCommand); |
| ChipLogProgress(Zcl, "Failed to dispatch command, TLVError=%" CHIP_ERROR_FORMAT, TLVError.Format()); |
| } |
| } |
| |
| } // namespace DoorLock |
| |
| namespace EthernetNetworkDiagnostics { |
| |
| void DispatchServerCommand(CommandHandler * apCommandObj, const ConcreteCommandPath & aCommandPath, TLV::TLVReader & aDataTlv) |
| { |
| CHIP_ERROR TLVError = CHIP_NO_ERROR; |
| bool wasHandled = false; |
| { |
| switch (aCommandPath.mCommandId) |
| { |
| case Commands::ResetCounts::Id: { |
| Commands::ResetCounts::DecodableType commandData; |
| TLVError = DataModel::Decode(aDataTlv, commandData); |
| if (TLVError == CHIP_NO_ERROR) |
| { |
| wasHandled = emberAfEthernetNetworkDiagnosticsClusterResetCountsCallback(apCommandObj, aCommandPath, commandData); |
| } |
| break; |
| } |
| default: { |
| // Unrecognized command ID, error status will apply. |
| apCommandObj->AddStatus(aCommandPath, Protocols::InteractionModel::Status::UnsupportedCommand); |
| ChipLogError(Zcl, "Unknown command " ChipLogFormatMEI " for cluster " ChipLogFormatMEI, |
| ChipLogValueMEI(aCommandPath.mCommandId), ChipLogValueMEI(aCommandPath.mClusterId)); |
| return; |
| } |
| } |
| } |
| |
| if (CHIP_NO_ERROR != TLVError || !wasHandled) |
| { |
| apCommandObj->AddStatus(aCommandPath, Protocols::InteractionModel::Status::InvalidCommand); |
| ChipLogProgress(Zcl, "Failed to dispatch command, TLVError=%" CHIP_ERROR_FORMAT, TLVError.Format()); |
| } |
| } |
| |
| } // namespace EthernetNetworkDiagnostics |
| |
| namespace GeneralCommissioning { |
| |
| void DispatchServerCommand(CommandHandler * apCommandObj, const ConcreteCommandPath & aCommandPath, TLV::TLVReader & aDataTlv) |
| { |
| CHIP_ERROR TLVError = CHIP_NO_ERROR; |
| bool wasHandled = false; |
| { |
| switch (aCommandPath.mCommandId) |
| { |
| case Commands::ArmFailSafe::Id: { |
| Commands::ArmFailSafe::DecodableType commandData; |
| TLVError = DataModel::Decode(aDataTlv, commandData); |
| if (TLVError == CHIP_NO_ERROR) |
| { |
| wasHandled = emberAfGeneralCommissioningClusterArmFailSafeCallback(apCommandObj, aCommandPath, commandData); |
| } |
| break; |
| } |
| case Commands::SetRegulatoryConfig::Id: { |
| Commands::SetRegulatoryConfig::DecodableType commandData; |
| TLVError = DataModel::Decode(aDataTlv, commandData); |
| if (TLVError == CHIP_NO_ERROR) |
| { |
| wasHandled = emberAfGeneralCommissioningClusterSetRegulatoryConfigCallback(apCommandObj, aCommandPath, commandData); |
| } |
| break; |
| } |
| case Commands::CommissioningComplete::Id: { |
| Commands::CommissioningComplete::DecodableType commandData; |
| TLVError = DataModel::Decode(aDataTlv, commandData); |
| if (TLVError == CHIP_NO_ERROR) |
| { |
| wasHandled = |
| emberAfGeneralCommissioningClusterCommissioningCompleteCallback(apCommandObj, aCommandPath, commandData); |
| } |
| break; |
| } |
| default: { |
| // Unrecognized command ID, error status will apply. |
| apCommandObj->AddStatus(aCommandPath, Protocols::InteractionModel::Status::UnsupportedCommand); |
| ChipLogError(Zcl, "Unknown command " ChipLogFormatMEI " for cluster " ChipLogFormatMEI, |
| ChipLogValueMEI(aCommandPath.mCommandId), ChipLogValueMEI(aCommandPath.mClusterId)); |
| return; |
| } |
| } |
| } |
| |
| if (CHIP_NO_ERROR != TLVError || !wasHandled) |
| { |
| apCommandObj->AddStatus(aCommandPath, Protocols::InteractionModel::Status::InvalidCommand); |
| ChipLogProgress(Zcl, "Failed to dispatch command, TLVError=%" CHIP_ERROR_FORMAT, TLVError.Format()); |
| } |
| } |
| |
| } // namespace GeneralCommissioning |
| |
| namespace GeneralDiagnostics { |
| |
| void DispatchServerCommand(CommandHandler * apCommandObj, const ConcreteCommandPath & aCommandPath, TLV::TLVReader & aDataTlv) |
| { |
| CHIP_ERROR TLVError = CHIP_NO_ERROR; |
| bool wasHandled = false; |
| { |
| switch (aCommandPath.mCommandId) |
| { |
| case Commands::TestEventTrigger::Id: { |
| Commands::TestEventTrigger::DecodableType commandData; |
| TLVError = DataModel::Decode(aDataTlv, commandData); |
| if (TLVError == CHIP_NO_ERROR) |
| { |
| wasHandled = emberAfGeneralDiagnosticsClusterTestEventTriggerCallback(apCommandObj, aCommandPath, commandData); |
| } |
| break; |
| } |
| default: { |
| // Unrecognized command ID, error status will apply. |
| apCommandObj->AddStatus(aCommandPath, Protocols::InteractionModel::Status::UnsupportedCommand); |
| ChipLogError(Zcl, "Unknown command " ChipLogFormatMEI " for cluster " ChipLogFormatMEI, |
| ChipLogValueMEI(aCommandPath.mCommandId), ChipLogValueMEI(aCommandPath.mClusterId)); |
| return; |
| } |
| } |
| } |
| |
| if (CHIP_NO_ERROR != TLVError || !wasHandled) |
| { |
| apCommandObj->AddStatus(aCommandPath, Protocols::InteractionModel::Status::InvalidCommand); |
| ChipLogProgress(Zcl, "Failed to dispatch command, TLVError=%" CHIP_ERROR_FORMAT, TLVError.Format()); |
| } |
| } |
| |
| } // namespace GeneralDiagnostics |
| |
| namespace GroupKeyManagement { |
| |
| void DispatchServerCommand(CommandHandler * apCommandObj, const ConcreteCommandPath & aCommandPath, TLV::TLVReader & aDataTlv) |
| { |
| CHIP_ERROR TLVError = CHIP_NO_ERROR; |
| bool wasHandled = false; |
| { |
| switch (aCommandPath.mCommandId) |
| { |
| case Commands::KeySetWrite::Id: { |
| Commands::KeySetWrite::DecodableType commandData; |
| TLVError = DataModel::Decode(aDataTlv, commandData); |
| if (TLVError == CHIP_NO_ERROR) |
| { |
| wasHandled = emberAfGroupKeyManagementClusterKeySetWriteCallback(apCommandObj, aCommandPath, commandData); |
| } |
| break; |
| } |
| case Commands::KeySetRead::Id: { |
| Commands::KeySetRead::DecodableType commandData; |
| TLVError = DataModel::Decode(aDataTlv, commandData); |
| if (TLVError == CHIP_NO_ERROR) |
| { |
| wasHandled = emberAfGroupKeyManagementClusterKeySetReadCallback(apCommandObj, aCommandPath, commandData); |
| } |
| break; |
| } |
| case Commands::KeySetRemove::Id: { |
| Commands::KeySetRemove::DecodableType commandData; |
| TLVError = DataModel::Decode(aDataTlv, commandData); |
| if (TLVError == CHIP_NO_ERROR) |
| { |
| wasHandled = emberAfGroupKeyManagementClusterKeySetRemoveCallback(apCommandObj, aCommandPath, commandData); |
| } |
| break; |
| } |
| case Commands::KeySetReadAllIndices::Id: { |
| Commands::KeySetReadAllIndices::DecodableType commandData; |
| TLVError = DataModel::Decode(aDataTlv, commandData); |
| if (TLVError == CHIP_NO_ERROR) |
| { |
| wasHandled = emberAfGroupKeyManagementClusterKeySetReadAllIndicesCallback(apCommandObj, aCommandPath, commandData); |
| } |
| break; |
| } |
| default: { |
| // Unrecognized command ID, error status will apply. |
| apCommandObj->AddStatus(aCommandPath, Protocols::InteractionModel::Status::UnsupportedCommand); |
| ChipLogError(Zcl, "Unknown command " ChipLogFormatMEI " for cluster " ChipLogFormatMEI, |
| ChipLogValueMEI(aCommandPath.mCommandId), ChipLogValueMEI(aCommandPath.mClusterId)); |
| return; |
| } |
| } |
| } |
| |
| if (CHIP_NO_ERROR != TLVError || !wasHandled) |
| { |
| apCommandObj->AddStatus(aCommandPath, Protocols::InteractionModel::Status::InvalidCommand); |
| ChipLogProgress(Zcl, "Failed to dispatch command, TLVError=%" CHIP_ERROR_FORMAT, TLVError.Format()); |
| } |
| } |
| |
| } // namespace GroupKeyManagement |
| |
| namespace Groups { |
| |
| void DispatchServerCommand(CommandHandler * apCommandObj, const ConcreteCommandPath & aCommandPath, TLV::TLVReader & aDataTlv) |
| { |
| CHIP_ERROR TLVError = CHIP_NO_ERROR; |
| bool wasHandled = false; |
| { |
| switch (aCommandPath.mCommandId) |
| { |
| case Commands::AddGroup::Id: { |
| Commands::AddGroup::DecodableType commandData; |
| TLVError = DataModel::Decode(aDataTlv, commandData); |
| if (TLVError == CHIP_NO_ERROR) |
| { |
| wasHandled = emberAfGroupsClusterAddGroupCallback(apCommandObj, aCommandPath, commandData); |
| } |
| break; |
| } |
| case Commands::ViewGroup::Id: { |
| Commands::ViewGroup::DecodableType commandData; |
| TLVError = DataModel::Decode(aDataTlv, commandData); |
| if (TLVError == CHIP_NO_ERROR) |
| { |
| wasHandled = emberAfGroupsClusterViewGroupCallback(apCommandObj, aCommandPath, commandData); |
| } |
| break; |
| } |
| case Commands::GetGroupMembership::Id: { |
| Commands::GetGroupMembership::DecodableType commandData; |
| TLVError = DataModel::Decode(aDataTlv, commandData); |
| if (TLVError == CHIP_NO_ERROR) |
| { |
| wasHandled = emberAfGroupsClusterGetGroupMembershipCallback(apCommandObj, aCommandPath, commandData); |
| } |
| break; |
| } |
| case Commands::RemoveGroup::Id: { |
| Commands::RemoveGroup::DecodableType commandData; |
| TLVError = DataModel::Decode(aDataTlv, commandData); |
| if (TLVError == CHIP_NO_ERROR) |
| { |
| wasHandled = emberAfGroupsClusterRemoveGroupCallback(apCommandObj, aCommandPath, commandData); |
| } |
| break; |
| } |
| case Commands::RemoveAllGroups::Id: { |
| Commands::RemoveAllGroups::DecodableType commandData; |
| TLVError = DataModel::Decode(aDataTlv, commandData); |
| if (TLVError == CHIP_NO_ERROR) |
| { |
| wasHandled = emberAfGroupsClusterRemoveAllGroupsCallback(apCommandObj, aCommandPath, commandData); |
| } |
| break; |
| } |
| case Commands::AddGroupIfIdentifying::Id: { |
| Commands::AddGroupIfIdentifying::DecodableType commandData; |
| TLVError = DataModel::Decode(aDataTlv, commandData); |
| if (TLVError == CHIP_NO_ERROR) |
| { |
| wasHandled = emberAfGroupsClusterAddGroupIfIdentifyingCallback(apCommandObj, aCommandPath, commandData); |
| } |
| break; |
| } |
| default: { |
| // Unrecognized command ID, error status will apply. |
| apCommandObj->AddStatus(aCommandPath, Protocols::InteractionModel::Status::UnsupportedCommand); |
| ChipLogError(Zcl, "Unknown command " ChipLogFormatMEI " for cluster " ChipLogFormatMEI, |
| ChipLogValueMEI(aCommandPath.mCommandId), ChipLogValueMEI(aCommandPath.mClusterId)); |
| return; |
| } |
| } |
| } |
| |
| if (CHIP_NO_ERROR != TLVError || !wasHandled) |
| { |
| apCommandObj->AddStatus(aCommandPath, Protocols::InteractionModel::Status::InvalidCommand); |
| ChipLogProgress(Zcl, "Failed to dispatch command, TLVError=%" CHIP_ERROR_FORMAT, TLVError.Format()); |
| } |
| } |
| |
| } // namespace Groups |
| |
| namespace Identify { |
| |
| void DispatchServerCommand(CommandHandler * apCommandObj, const ConcreteCommandPath & aCommandPath, TLV::TLVReader & aDataTlv) |
| { |
| CHIP_ERROR TLVError = CHIP_NO_ERROR; |
| bool wasHandled = false; |
| { |
| switch (aCommandPath.mCommandId) |
| { |
| case Commands::Identify::Id: { |
| Commands::Identify::DecodableType commandData; |
| TLVError = DataModel::Decode(aDataTlv, commandData); |
| if (TLVError == CHIP_NO_ERROR) |
| { |
| wasHandled = emberAfIdentifyClusterIdentifyCallback(apCommandObj, aCommandPath, commandData); |
| } |
| break; |
| } |
| default: { |
| // Unrecognized command ID, error status will apply. |
| apCommandObj->AddStatus(aCommandPath, Protocols::InteractionModel::Status::UnsupportedCommand); |
| ChipLogError(Zcl, "Unknown command " ChipLogFormatMEI " for cluster " ChipLogFormatMEI, |
| ChipLogValueMEI(aCommandPath.mCommandId), ChipLogValueMEI(aCommandPath.mClusterId)); |
| return; |
| } |
| } |
| } |
| |
| if (CHIP_NO_ERROR != TLVError || !wasHandled) |
| { |
| apCommandObj->AddStatus(aCommandPath, Protocols::InteractionModel::Status::InvalidCommand); |
| ChipLogProgress(Zcl, "Failed to dispatch command, TLVError=%" CHIP_ERROR_FORMAT, TLVError.Format()); |
| } |
| } |
| |
| } // namespace Identify |
| |
| namespace KeypadInput { |
| |
| void DispatchServerCommand(CommandHandler * apCommandObj, const ConcreteCommandPath & aCommandPath, TLV::TLVReader & aDataTlv) |
| { |
| CHIP_ERROR TLVError = CHIP_NO_ERROR; |
| bool wasHandled = false; |
| { |
| switch (aCommandPath.mCommandId) |
| { |
| case Commands::SendKey::Id: { |
| Commands::SendKey::DecodableType commandData; |
| TLVError = DataModel::Decode(aDataTlv, commandData); |
| if (TLVError == CHIP_NO_ERROR) |
| { |
| wasHandled = emberAfKeypadInputClusterSendKeyCallback(apCommandObj, aCommandPath, commandData); |
| } |
| break; |
| } |
| default: { |
| // Unrecognized command ID, error status will apply. |
| apCommandObj->AddStatus(aCommandPath, Protocols::InteractionModel::Status::UnsupportedCommand); |
| ChipLogError(Zcl, "Unknown command " ChipLogFormatMEI " for cluster " ChipLogFormatMEI, |
| ChipLogValueMEI(aCommandPath.mCommandId), ChipLogValueMEI(aCommandPath.mClusterId)); |
| return; |
| } |
| } |
| } |
| |
| if (CHIP_NO_ERROR != TLVError || !wasHandled) |
| { |
| apCommandObj->AddStatus(aCommandPath, Protocols::InteractionModel::Status::InvalidCommand); |
| ChipLogProgress(Zcl, "Failed to dispatch command, TLVError=%" CHIP_ERROR_FORMAT, TLVError.Format()); |
| } |
| } |
| |
| } // namespace KeypadInput |
| |
| namespace LevelControl { |
| |
| void DispatchServerCommand(CommandHandler * apCommandObj, const ConcreteCommandPath & aCommandPath, TLV::TLVReader & aDataTlv) |
| { |
| CHIP_ERROR TLVError = CHIP_NO_ERROR; |
| bool wasHandled = false; |
| { |
| switch (aCommandPath.mCommandId) |
| { |
| case Commands::MoveToLevel::Id: { |
| Commands::MoveToLevel::DecodableType commandData; |
| TLVError = DataModel::Decode(aDataTlv, commandData); |
| if (TLVError == CHIP_NO_ERROR) |
| { |
| wasHandled = emberAfLevelControlClusterMoveToLevelCallback(apCommandObj, aCommandPath, commandData); |
| } |
| break; |
| } |
| case Commands::Move::Id: { |
| Commands::Move::DecodableType commandData; |
| TLVError = DataModel::Decode(aDataTlv, commandData); |
| if (TLVError == CHIP_NO_ERROR) |
| { |
| wasHandled = emberAfLevelControlClusterMoveCallback(apCommandObj, aCommandPath, commandData); |
| } |
| break; |
| } |
| case Commands::Step::Id: { |
| Commands::Step::DecodableType commandData; |
| TLVError = DataModel::Decode(aDataTlv, commandData); |
| if (TLVError == CHIP_NO_ERROR) |
| { |
| wasHandled = emberAfLevelControlClusterStepCallback(apCommandObj, aCommandPath, commandData); |
| } |
| break; |
| } |
| case Commands::Stop::Id: { |
| Commands::Stop::DecodableType commandData; |
| TLVError = DataModel::Decode(aDataTlv, commandData); |
| if (TLVError == CHIP_NO_ERROR) |
| { |
| wasHandled = emberAfLevelControlClusterStopCallback(apCommandObj, aCommandPath, commandData); |
| } |
| break; |
| } |
| case Commands::MoveToLevelWithOnOff::Id: { |
| Commands::MoveToLevelWithOnOff::DecodableType commandData; |
| TLVError = DataModel::Decode(aDataTlv, commandData); |
| if (TLVError == CHIP_NO_ERROR) |
| { |
| wasHandled = emberAfLevelControlClusterMoveToLevelWithOnOffCallback(apCommandObj, aCommandPath, commandData); |
| } |
| break; |
| } |
| case Commands::MoveWithOnOff::Id: { |
| Commands::MoveWithOnOff::DecodableType commandData; |
| TLVError = DataModel::Decode(aDataTlv, commandData); |
| if (TLVError == CHIP_NO_ERROR) |
| { |
| wasHandled = emberAfLevelControlClusterMoveWithOnOffCallback(apCommandObj, aCommandPath, commandData); |
| } |
| break; |
| } |
| case Commands::StepWithOnOff::Id: { |
| Commands::StepWithOnOff::DecodableType commandData; |
| TLVError = DataModel::Decode(aDataTlv, commandData); |
| if (TLVError == CHIP_NO_ERROR) |
| { |
| wasHandled = emberAfLevelControlClusterStepWithOnOffCallback(apCommandObj, aCommandPath, commandData); |
| } |
| break; |
| } |
| case Commands::StopWithOnOff::Id: { |
| Commands::StopWithOnOff::DecodableType commandData; |
| TLVError = DataModel::Decode(aDataTlv, commandData); |
| if (TLVError == CHIP_NO_ERROR) |
| { |
| wasHandled = emberAfLevelControlClusterStopWithOnOffCallback(apCommandObj, aCommandPath, commandData); |
| } |
| break; |
| } |
| default: { |
| // Unrecognized command ID, error status will apply. |
| apCommandObj->AddStatus(aCommandPath, Protocols::InteractionModel::Status::UnsupportedCommand); |
| ChipLogError(Zcl, "Unknown command " ChipLogFormatMEI " for cluster " ChipLogFormatMEI, |
| ChipLogValueMEI(aCommandPath.mCommandId), ChipLogValueMEI(aCommandPath.mClusterId)); |
| return; |
| } |
| } |
| } |
| |
| if (CHIP_NO_ERROR != TLVError || !wasHandled) |
| { |
| apCommandObj->AddStatus(aCommandPath, Protocols::InteractionModel::Status::InvalidCommand); |
| ChipLogProgress(Zcl, "Failed to dispatch command, TLVError=%" CHIP_ERROR_FORMAT, TLVError.Format()); |
| } |
| } |
| |
| } // namespace LevelControl |
| |
| namespace LowPower { |
| |
| void DispatchServerCommand(CommandHandler * apCommandObj, const ConcreteCommandPath & aCommandPath, TLV::TLVReader & aDataTlv) |
| { |
| CHIP_ERROR TLVError = CHIP_NO_ERROR; |
| bool wasHandled = false; |
| { |
| switch (aCommandPath.mCommandId) |
| { |
| case Commands::Sleep::Id: { |
| Commands::Sleep::DecodableType commandData; |
| TLVError = DataModel::Decode(aDataTlv, commandData); |
| if (TLVError == CHIP_NO_ERROR) |
| { |
| wasHandled = emberAfLowPowerClusterSleepCallback(apCommandObj, aCommandPath, commandData); |
| } |
| break; |
| } |
| default: { |
| // Unrecognized command ID, error status will apply. |
| apCommandObj->AddStatus(aCommandPath, Protocols::InteractionModel::Status::UnsupportedCommand); |
| ChipLogError(Zcl, "Unknown command " ChipLogFormatMEI " for cluster " ChipLogFormatMEI, |
| ChipLogValueMEI(aCommandPath.mCommandId), ChipLogValueMEI(aCommandPath.mClusterId)); |
| return; |
| } |
| } |
| } |
| |
| if (CHIP_NO_ERROR != TLVError || !wasHandled) |
| { |
| apCommandObj->AddStatus(aCommandPath, Protocols::InteractionModel::Status::InvalidCommand); |
| ChipLogProgress(Zcl, "Failed to dispatch command, TLVError=%" CHIP_ERROR_FORMAT, TLVError.Format()); |
| } |
| } |
| |
| } // namespace LowPower |
| |
| namespace MediaInput { |
| |
| void DispatchServerCommand(CommandHandler * apCommandObj, const ConcreteCommandPath & aCommandPath, TLV::TLVReader & aDataTlv) |
| { |
| CHIP_ERROR TLVError = CHIP_NO_ERROR; |
| bool wasHandled = false; |
| { |
| switch (aCommandPath.mCommandId) |
| { |
| case Commands::SelectInput::Id: { |
| Commands::SelectInput::DecodableType commandData; |
| TLVError = DataModel::Decode(aDataTlv, commandData); |
| if (TLVError == CHIP_NO_ERROR) |
| { |
| wasHandled = emberAfMediaInputClusterSelectInputCallback(apCommandObj, aCommandPath, commandData); |
| } |
| break; |
| } |
| case Commands::ShowInputStatus::Id: { |
| Commands::ShowInputStatus::DecodableType commandData; |
| TLVError = DataModel::Decode(aDataTlv, commandData); |
| if (TLVError == CHIP_NO_ERROR) |
| { |
| wasHandled = emberAfMediaInputClusterShowInputStatusCallback(apCommandObj, aCommandPath, commandData); |
| } |
| break; |
| } |
| case Commands::HideInputStatus::Id: { |
| Commands::HideInputStatus::DecodableType commandData; |
| TLVError = DataModel::Decode(aDataTlv, commandData); |
| if (TLVError == CHIP_NO_ERROR) |
| { |
| wasHandled = emberAfMediaInputClusterHideInputStatusCallback(apCommandObj, aCommandPath, commandData); |
| } |
| break; |
| } |
| default: { |
| // Unrecognized command ID, error status will apply. |
| apCommandObj->AddStatus(aCommandPath, Protocols::InteractionModel::Status::UnsupportedCommand); |
| ChipLogError(Zcl, "Unknown command " ChipLogFormatMEI " for cluster " ChipLogFormatMEI, |
| ChipLogValueMEI(aCommandPath.mCommandId), ChipLogValueMEI(aCommandPath.mClusterId)); |
| return; |
| } |
| } |
| } |
| |
| if (CHIP_NO_ERROR != TLVError || !wasHandled) |
| { |
| apCommandObj->AddStatus(aCommandPath, Protocols::InteractionModel::Status::InvalidCommand); |
| ChipLogProgress(Zcl, "Failed to dispatch command, TLVError=%" CHIP_ERROR_FORMAT, TLVError.Format()); |
| } |
| } |
| |
| } // namespace MediaInput |
| |
| namespace MediaPlayback { |
| |
| void DispatchServerCommand(CommandHandler * apCommandObj, const ConcreteCommandPath & aCommandPath, TLV::TLVReader & aDataTlv) |
| { |
| CHIP_ERROR TLVError = CHIP_NO_ERROR; |
| bool wasHandled = false; |
| { |
| switch (aCommandPath.mCommandId) |
| { |
| case Commands::Play::Id: { |
| Commands::Play::DecodableType commandData; |
| TLVError = DataModel::Decode(aDataTlv, commandData); |
| if (TLVError == CHIP_NO_ERROR) |
| { |
| wasHandled = emberAfMediaPlaybackClusterPlayCallback(apCommandObj, aCommandPath, commandData); |
| } |
| break; |
| } |
| case Commands::Pause::Id: { |
| Commands::Pause::DecodableType commandData; |
| TLVError = DataModel::Decode(aDataTlv, commandData); |
| if (TLVError == CHIP_NO_ERROR) |
| { |
| wasHandled = emberAfMediaPlaybackClusterPauseCallback(apCommandObj, aCommandPath, commandData); |
| } |
| break; |
| } |
| case Commands::StopPlayback::Id: { |
| Commands::StopPlayback::DecodableType commandData; |
| TLVError = DataModel::Decode(aDataTlv, commandData); |
| if (TLVError == CHIP_NO_ERROR) |
| { |
| wasHandled = emberAfMediaPlaybackClusterStopPlaybackCallback(apCommandObj, aCommandPath, commandData); |
| } |
| break; |
| } |
| default: { |
| // Unrecognized command ID, error status will apply. |
| apCommandObj->AddStatus(aCommandPath, Protocols::InteractionModel::Status::UnsupportedCommand); |
| ChipLogError(Zcl, "Unknown command " ChipLogFormatMEI " for cluster " ChipLogFormatMEI, |
| ChipLogValueMEI(aCommandPath.mCommandId), ChipLogValueMEI(aCommandPath.mClusterId)); |
| return; |
| } |
| } |
| } |
| |
| if (CHIP_NO_ERROR != TLVError || !wasHandled) |
| { |
| apCommandObj->AddStatus(aCommandPath, Protocols::InteractionModel::Status::InvalidCommand); |
| ChipLogProgress(Zcl, "Failed to dispatch command, TLVError=%" CHIP_ERROR_FORMAT, TLVError.Format()); |
| } |
| } |
| |
| } // namespace MediaPlayback |
| |
| namespace ModeSelect { |
| |
| void DispatchServerCommand(CommandHandler * apCommandObj, const ConcreteCommandPath & aCommandPath, TLV::TLVReader & aDataTlv) |
| { |
| CHIP_ERROR TLVError = CHIP_NO_ERROR; |
| bool wasHandled = false; |
| { |
| switch (aCommandPath.mCommandId) |
| { |
| case Commands::ChangeToMode::Id: { |
| Commands::ChangeToMode::DecodableType commandData; |
| TLVError = DataModel::Decode(aDataTlv, commandData); |
| if (TLVError == CHIP_NO_ERROR) |
| { |
| wasHandled = emberAfModeSelectClusterChangeToModeCallback(apCommandObj, aCommandPath, commandData); |
| } |
| break; |
| } |
| default: { |
| // Unrecognized command ID, error status will apply. |
| apCommandObj->AddStatus(aCommandPath, Protocols::InteractionModel::Status::UnsupportedCommand); |
| ChipLogError(Zcl, "Unknown command " ChipLogFormatMEI " for cluster " ChipLogFormatMEI, |
| ChipLogValueMEI(aCommandPath.mCommandId), ChipLogValueMEI(aCommandPath.mClusterId)); |
| return; |
| } |
| } |
| } |
| |
| if (CHIP_NO_ERROR != TLVError || !wasHandled) |
| { |
| apCommandObj->AddStatus(aCommandPath, Protocols::InteractionModel::Status::InvalidCommand); |
| ChipLogProgress(Zcl, "Failed to dispatch command, TLVError=%" CHIP_ERROR_FORMAT, TLVError.Format()); |
| } |
| } |
| |
| } // namespace ModeSelect |
| |
| namespace NetworkCommissioning { |
| |
| void DispatchServerCommand(CommandHandler * apCommandObj, const ConcreteCommandPath & aCommandPath, TLV::TLVReader & aDataTlv) |
| { |
| CHIP_ERROR TLVError = CHIP_NO_ERROR; |
| bool wasHandled = false; |
| { |
| switch (aCommandPath.mCommandId) |
| { |
| case Commands::ScanNetworks::Id: { |
| Commands::ScanNetworks::DecodableType commandData; |
| TLVError = DataModel::Decode(aDataTlv, commandData); |
| if (TLVError == CHIP_NO_ERROR) |
| { |
| wasHandled = emberAfNetworkCommissioningClusterScanNetworksCallback(apCommandObj, aCommandPath, commandData); |
| } |
| break; |
| } |
| case Commands::AddOrUpdateWiFiNetwork::Id: { |
| Commands::AddOrUpdateWiFiNetwork::DecodableType commandData; |
| TLVError = DataModel::Decode(aDataTlv, commandData); |
| if (TLVError == CHIP_NO_ERROR) |
| { |
| wasHandled = |
| emberAfNetworkCommissioningClusterAddOrUpdateWiFiNetworkCallback(apCommandObj, aCommandPath, commandData); |
| } |
| break; |
| } |
| case Commands::AddOrUpdateThreadNetwork::Id: { |
| Commands::AddOrUpdateThreadNetwork::DecodableType commandData; |
| TLVError = DataModel::Decode(aDataTlv, commandData); |
| if (TLVError == CHIP_NO_ERROR) |
| { |
| wasHandled = |
| emberAfNetworkCommissioningClusterAddOrUpdateThreadNetworkCallback(apCommandObj, aCommandPath, commandData); |
| } |
| break; |
| } |
| case Commands::RemoveNetwork::Id: { |
| Commands::RemoveNetwork::DecodableType commandData; |
| TLVError = DataModel::Decode(aDataTlv, commandData); |
| if (TLVError == CHIP_NO_ERROR) |
| { |
| wasHandled = emberAfNetworkCommissioningClusterRemoveNetworkCallback(apCommandObj, aCommandPath, commandData); |
| } |
| break; |
| } |
| case Commands::ConnectNetwork::Id: { |
| Commands::ConnectNetwork::DecodableType commandData; |
| TLVError = DataModel::Decode(aDataTlv, commandData); |
| if (TLVError == CHIP_NO_ERROR) |
| { |
| wasHandled = emberAfNetworkCommissioningClusterConnectNetworkCallback(apCommandObj, aCommandPath, commandData); |
| } |
| break; |
| } |
| case Commands::ReorderNetwork::Id: { |
| Commands::ReorderNetwork::DecodableType commandData; |
| TLVError = DataModel::Decode(aDataTlv, commandData); |
| if (TLVError == CHIP_NO_ERROR) |
| { |
| wasHandled = emberAfNetworkCommissioningClusterReorderNetworkCallback(apCommandObj, aCommandPath, commandData); |
| } |
| break; |
| } |
| default: { |
| // Unrecognized command ID, error status will apply. |
| apCommandObj->AddStatus(aCommandPath, Protocols::InteractionModel::Status::UnsupportedCommand); |
| ChipLogError(Zcl, "Unknown command " ChipLogFormatMEI " for cluster " ChipLogFormatMEI, |
| ChipLogValueMEI(aCommandPath.mCommandId), ChipLogValueMEI(aCommandPath.mClusterId)); |
| return; |
| } |
| } |
| } |
| |
| if (CHIP_NO_ERROR != TLVError || !wasHandled) |
| { |
| apCommandObj->AddStatus(aCommandPath, Protocols::InteractionModel::Status::InvalidCommand); |
| ChipLogProgress(Zcl, "Failed to dispatch command, TLVError=%" CHIP_ERROR_FORMAT, TLVError.Format()); |
| } |
| } |
| |
| } // namespace NetworkCommissioning |
| |
| namespace OtaSoftwareUpdateRequestor { |
| |
| void DispatchServerCommand(CommandHandler * apCommandObj, const ConcreteCommandPath & aCommandPath, TLV::TLVReader & aDataTlv) |
| { |
| CHIP_ERROR TLVError = CHIP_NO_ERROR; |
| bool wasHandled = false; |
| { |
| switch (aCommandPath.mCommandId) |
| { |
| case Commands::AnnounceOtaProvider::Id: { |
| Commands::AnnounceOtaProvider::DecodableType commandData; |
| TLVError = DataModel::Decode(aDataTlv, commandData); |
| if (TLVError == CHIP_NO_ERROR) |
| { |
| wasHandled = |
| emberAfOtaSoftwareUpdateRequestorClusterAnnounceOtaProviderCallback(apCommandObj, aCommandPath, commandData); |
| } |
| break; |
| } |
| default: { |
| // Unrecognized command ID, error status will apply. |
| apCommandObj->AddStatus(aCommandPath, Protocols::InteractionModel::Status::UnsupportedCommand); |
| ChipLogError(Zcl, "Unknown command " ChipLogFormatMEI " for cluster " ChipLogFormatMEI, |
| ChipLogValueMEI(aCommandPath.mCommandId), ChipLogValueMEI(aCommandPath.mClusterId)); |
| return; |
| } |
| } |
| } |
| |
| if (CHIP_NO_ERROR != TLVError || !wasHandled) |
| { |
| apCommandObj->AddStatus(aCommandPath, Protocols::InteractionModel::Status::InvalidCommand); |
| ChipLogProgress(Zcl, "Failed to dispatch command, TLVError=%" CHIP_ERROR_FORMAT, TLVError.Format()); |
| } |
| } |
| |
| } // namespace OtaSoftwareUpdateRequestor |
| |
| namespace OnOff { |
| |
| void DispatchServerCommand(CommandHandler * apCommandObj, const ConcreteCommandPath & aCommandPath, TLV::TLVReader & aDataTlv) |
| { |
| CHIP_ERROR TLVError = CHIP_NO_ERROR; |
| bool wasHandled = false; |
| { |
| switch (aCommandPath.mCommandId) |
| { |
| case Commands::Off::Id: { |
| Commands::Off::DecodableType commandData; |
| TLVError = DataModel::Decode(aDataTlv, commandData); |
| if (TLVError == CHIP_NO_ERROR) |
| { |
| wasHandled = emberAfOnOffClusterOffCallback(apCommandObj, aCommandPath, commandData); |
| } |
| break; |
| } |
| case Commands::On::Id: { |
| Commands::On::DecodableType commandData; |
| TLVError = DataModel::Decode(aDataTlv, commandData); |
| if (TLVError == CHIP_NO_ERROR) |
| { |
| wasHandled = emberAfOnOffClusterOnCallback(apCommandObj, aCommandPath, commandData); |
| } |
| break; |
| } |
| case Commands::Toggle::Id: { |
| Commands::Toggle::DecodableType commandData; |
| TLVError = DataModel::Decode(aDataTlv, commandData); |
| if (TLVError == CHIP_NO_ERROR) |
| { |
| wasHandled = emberAfOnOffClusterToggleCallback(apCommandObj, aCommandPath, commandData); |
| } |
| break; |
| } |
| default: { |
| // Unrecognized command ID, error status will apply. |
| apCommandObj->AddStatus(aCommandPath, Protocols::InteractionModel::Status::UnsupportedCommand); |
| ChipLogError(Zcl, "Unknown command " ChipLogFormatMEI " for cluster " ChipLogFormatMEI, |
| ChipLogValueMEI(aCommandPath.mCommandId), ChipLogValueMEI(aCommandPath.mClusterId)); |
| return; |
| } |
| } |
| } |
| |
| if (CHIP_NO_ERROR != TLVError || !wasHandled) |
| { |
| apCommandObj->AddStatus(aCommandPath, Protocols::InteractionModel::Status::InvalidCommand); |
| ChipLogProgress(Zcl, "Failed to dispatch command, TLVError=%" CHIP_ERROR_FORMAT, TLVError.Format()); |
| } |
| } |
| |
| } // namespace OnOff |
| |
| namespace OperationalCredentials { |
| |
| void DispatchServerCommand(CommandHandler * apCommandObj, const ConcreteCommandPath & aCommandPath, TLV::TLVReader & aDataTlv) |
| { |
| CHIP_ERROR TLVError = CHIP_NO_ERROR; |
| bool wasHandled = false; |
| { |
| switch (aCommandPath.mCommandId) |
| { |
| case Commands::AttestationRequest::Id: { |
| Commands::AttestationRequest::DecodableType commandData; |
| TLVError = DataModel::Decode(aDataTlv, commandData); |
| if (TLVError == CHIP_NO_ERROR) |
| { |
| wasHandled = |
| emberAfOperationalCredentialsClusterAttestationRequestCallback(apCommandObj, aCommandPath, commandData); |
| } |
| break; |
| } |
| case Commands::CertificateChainRequest::Id: { |
| Commands::CertificateChainRequest::DecodableType commandData; |
| TLVError = DataModel::Decode(aDataTlv, commandData); |
| if (TLVError == CHIP_NO_ERROR) |
| { |
| wasHandled = |
| emberAfOperationalCredentialsClusterCertificateChainRequestCallback(apCommandObj, aCommandPath, commandData); |
| } |
| break; |
| } |
| case Commands::CSRRequest::Id: { |
| Commands::CSRRequest::DecodableType commandData; |
| TLVError = DataModel::Decode(aDataTlv, commandData); |
| if (TLVError == CHIP_NO_ERROR) |
| { |
| wasHandled = emberAfOperationalCredentialsClusterCSRRequestCallback(apCommandObj, aCommandPath, commandData); |
| } |
| break; |
| } |
| case Commands::AddNOC::Id: { |
| Commands::AddNOC::DecodableType commandData; |
| TLVError = DataModel::Decode(aDataTlv, commandData); |
| if (TLVError == CHIP_NO_ERROR) |
| { |
| wasHandled = emberAfOperationalCredentialsClusterAddNOCCallback(apCommandObj, aCommandPath, commandData); |
| } |
| break; |
| } |
| case Commands::UpdateNOC::Id: { |
| Commands::UpdateNOC::DecodableType commandData; |
| TLVError = DataModel::Decode(aDataTlv, commandData); |
| if (TLVError == CHIP_NO_ERROR) |
| { |
| wasHandled = emberAfOperationalCredentialsClusterUpdateNOCCallback(apCommandObj, aCommandPath, commandData); |
| } |
| break; |
| } |
| case Commands::UpdateFabricLabel::Id: { |
| Commands::UpdateFabricLabel::DecodableType commandData; |
| TLVError = DataModel::Decode(aDataTlv, commandData); |
| if (TLVError == CHIP_NO_ERROR) |
| { |
| wasHandled = emberAfOperationalCredentialsClusterUpdateFabricLabelCallback(apCommandObj, aCommandPath, commandData); |
| } |
| break; |
| } |
| case Commands::RemoveFabric::Id: { |
| Commands::RemoveFabric::DecodableType commandData; |
| TLVError = DataModel::Decode(aDataTlv, commandData); |
| if (TLVError == CHIP_NO_ERROR) |
| { |
| wasHandled = emberAfOperationalCredentialsClusterRemoveFabricCallback(apCommandObj, aCommandPath, commandData); |
| } |
| break; |
| } |
| case Commands::AddTrustedRootCertificate::Id: { |
| Commands::AddTrustedRootCertificate::DecodableType commandData; |
| TLVError = DataModel::Decode(aDataTlv, commandData); |
| if (TLVError == CHIP_NO_ERROR) |
| { |
| wasHandled = |
| emberAfOperationalCredentialsClusterAddTrustedRootCertificateCallback(apCommandObj, aCommandPath, commandData); |
| } |
| break; |
| } |
| default: { |
| // Unrecognized command ID, error status will apply. |
| apCommandObj->AddStatus(aCommandPath, Protocols::InteractionModel::Status::UnsupportedCommand); |
| ChipLogError(Zcl, "Unknown command " ChipLogFormatMEI " for cluster " ChipLogFormatMEI, |
| ChipLogValueMEI(aCommandPath.mCommandId), ChipLogValueMEI(aCommandPath.mClusterId)); |
| return; |
| } |
| } |
| } |
| |
| if (CHIP_NO_ERROR != TLVError || !wasHandled) |
| { |
| apCommandObj->AddStatus(aCommandPath, Protocols::InteractionModel::Status::InvalidCommand); |
| ChipLogProgress(Zcl, "Failed to dispatch command, TLVError=%" CHIP_ERROR_FORMAT, TLVError.Format()); |
| } |
| } |
| |
| } // namespace OperationalCredentials |
| |
| namespace Scenes { |
| |
| void DispatchServerCommand(CommandHandler * apCommandObj, const ConcreteCommandPath & aCommandPath, TLV::TLVReader & aDataTlv) |
| { |
| CHIP_ERROR TLVError = CHIP_NO_ERROR; |
| bool wasHandled = false; |
| { |
| switch (aCommandPath.mCommandId) |
| { |
| case Commands::AddScene::Id: { |
| Commands::AddScene::DecodableType commandData; |
| TLVError = DataModel::Decode(aDataTlv, commandData); |
| if (TLVError == CHIP_NO_ERROR) |
| { |
| wasHandled = emberAfScenesClusterAddSceneCallback(apCommandObj, aCommandPath, commandData); |
| } |
| break; |
| } |
| case Commands::ViewScene::Id: { |
| Commands::ViewScene::DecodableType commandData; |
| TLVError = DataModel::Decode(aDataTlv, commandData); |
| if (TLVError == CHIP_NO_ERROR) |
| { |
| wasHandled = emberAfScenesClusterViewSceneCallback(apCommandObj, aCommandPath, commandData); |
| } |
| break; |
| } |
| case Commands::RemoveScene::Id: { |
| Commands::RemoveScene::DecodableType commandData; |
| TLVError = DataModel::Decode(aDataTlv, commandData); |
| if (TLVError == CHIP_NO_ERROR) |
| { |
| wasHandled = emberAfScenesClusterRemoveSceneCallback(apCommandObj, aCommandPath, commandData); |
| } |
| break; |
| } |
| case Commands::RemoveAllScenes::Id: { |
| Commands::RemoveAllScenes::DecodableType commandData; |
| TLVError = DataModel::Decode(aDataTlv, commandData); |
| if (TLVError == CHIP_NO_ERROR) |
| { |
| wasHandled = emberAfScenesClusterRemoveAllScenesCallback(apCommandObj, aCommandPath, commandData); |
| } |
| break; |
| } |
| case Commands::StoreScene::Id: { |
| Commands::StoreScene::DecodableType commandData; |
| TLVError = DataModel::Decode(aDataTlv, commandData); |
| if (TLVError == CHIP_NO_ERROR) |
| { |
| wasHandled = emberAfScenesClusterStoreSceneCallback(apCommandObj, aCommandPath, commandData); |
| } |
| break; |
| } |
| case Commands::RecallScene::Id: { |
| Commands::RecallScene::DecodableType commandData; |
| TLVError = DataModel::Decode(aDataTlv, commandData); |
| if (TLVError == CHIP_NO_ERROR) |
| { |
| wasHandled = emberAfScenesClusterRecallSceneCallback(apCommandObj, aCommandPath, commandData); |
| } |
| break; |
| } |
| case Commands::GetSceneMembership::Id: { |
| Commands::GetSceneMembership::DecodableType commandData; |
| TLVError = DataModel::Decode(aDataTlv, commandData); |
| if (TLVError == CHIP_NO_ERROR) |
| { |
| wasHandled = emberAfScenesClusterGetSceneMembershipCallback(apCommandObj, aCommandPath, commandData); |
| } |
| break; |
| } |
| default: { |
| // Unrecognized command ID, error status will apply. |
| apCommandObj->AddStatus(aCommandPath, Protocols::InteractionModel::Status::UnsupportedCommand); |
| ChipLogError(Zcl, "Unknown command " ChipLogFormatMEI " for cluster " ChipLogFormatMEI, |
| ChipLogValueMEI(aCommandPath.mCommandId), ChipLogValueMEI(aCommandPath.mClusterId)); |
| return; |
| } |
| } |
| } |
| |
| if (CHIP_NO_ERROR != TLVError || !wasHandled) |
| { |
| apCommandObj->AddStatus(aCommandPath, Protocols::InteractionModel::Status::InvalidCommand); |
| ChipLogProgress(Zcl, "Failed to dispatch command, TLVError=%" CHIP_ERROR_FORMAT, TLVError.Format()); |
| } |
| } |
| |
| } // namespace Scenes |
| |
| namespace TargetNavigator { |
| |
| void DispatchServerCommand(CommandHandler * apCommandObj, const ConcreteCommandPath & aCommandPath, TLV::TLVReader & aDataTlv) |
| { |
| CHIP_ERROR TLVError = CHIP_NO_ERROR; |
| bool wasHandled = false; |
| { |
| switch (aCommandPath.mCommandId) |
| { |
| case Commands::NavigateTarget::Id: { |
| Commands::NavigateTarget::DecodableType commandData; |
| TLVError = DataModel::Decode(aDataTlv, commandData); |
| if (TLVError == CHIP_NO_ERROR) |
| { |
| wasHandled = emberAfTargetNavigatorClusterNavigateTargetCallback(apCommandObj, aCommandPath, commandData); |
| } |
| break; |
| } |
| default: { |
| // Unrecognized command ID, error status will apply. |
| apCommandObj->AddStatus(aCommandPath, Protocols::InteractionModel::Status::UnsupportedCommand); |
| ChipLogError(Zcl, "Unknown command " ChipLogFormatMEI " for cluster " ChipLogFormatMEI, |
| ChipLogValueMEI(aCommandPath.mCommandId), ChipLogValueMEI(aCommandPath.mClusterId)); |
| return; |
| } |
| } |
| } |
| |
| if (CHIP_NO_ERROR != TLVError || !wasHandled) |
| { |
| apCommandObj->AddStatus(aCommandPath, Protocols::InteractionModel::Status::InvalidCommand); |
| ChipLogProgress(Zcl, "Failed to dispatch command, TLVError=%" CHIP_ERROR_FORMAT, TLVError.Format()); |
| } |
| } |
| |
| } // namespace TargetNavigator |
| |
| namespace TestCluster { |
| |
| void DispatchServerCommand(CommandHandler * apCommandObj, const ConcreteCommandPath & aCommandPath, TLV::TLVReader & aDataTlv) |
| { |
| CHIP_ERROR TLVError = CHIP_NO_ERROR; |
| bool wasHandled = false; |
| { |
| switch (aCommandPath.mCommandId) |
| { |
| case Commands::Test::Id: { |
| Commands::Test::DecodableType commandData; |
| TLVError = DataModel::Decode(aDataTlv, commandData); |
| if (TLVError == CHIP_NO_ERROR) |
| { |
| wasHandled = emberAfTestClusterClusterTestCallback(apCommandObj, aCommandPath, commandData); |
| } |
| break; |
| } |
| case Commands::TestNotHandled::Id: { |
| Commands::TestNotHandled::DecodableType commandData; |
| TLVError = DataModel::Decode(aDataTlv, commandData); |
| if (TLVError == CHIP_NO_ERROR) |
| { |
| wasHandled = emberAfTestClusterClusterTestNotHandledCallback(apCommandObj, aCommandPath, commandData); |
| } |
| break; |
| } |
| case Commands::TestSpecific::Id: { |
| Commands::TestSpecific::DecodableType commandData; |
| TLVError = DataModel::Decode(aDataTlv, commandData); |
| if (TLVError == CHIP_NO_ERROR) |
| { |
| wasHandled = emberAfTestClusterClusterTestSpecificCallback(apCommandObj, aCommandPath, commandData); |
| } |
| break; |
| } |
| case Commands::TestAddArguments::Id: { |
| Commands::TestAddArguments::DecodableType commandData; |
| TLVError = DataModel::Decode(aDataTlv, commandData); |
| if (TLVError == CHIP_NO_ERROR) |
| { |
| wasHandled = emberAfTestClusterClusterTestAddArgumentsCallback(apCommandObj, aCommandPath, commandData); |
| } |
| break; |
| } |
| case Commands::TestStructArgumentRequest::Id: { |
| Commands::TestStructArgumentRequest::DecodableType commandData; |
| TLVError = DataModel::Decode(aDataTlv, commandData); |
| if (TLVError == CHIP_NO_ERROR) |
| { |
| wasHandled = emberAfTestClusterClusterTestStructArgumentRequestCallback(apCommandObj, aCommandPath, commandData); |
| } |
| break; |
| } |
| case Commands::TestNestedStructArgumentRequest::Id: { |
| Commands::TestNestedStructArgumentRequest::DecodableType commandData; |
| TLVError = DataModel::Decode(aDataTlv, commandData); |
| if (TLVError == CHIP_NO_ERROR) |
| { |
| wasHandled = |
| emberAfTestClusterClusterTestNestedStructArgumentRequestCallback(apCommandObj, aCommandPath, commandData); |
| } |
| break; |
| } |
| case Commands::TestListStructArgumentRequest::Id: { |
| Commands::TestListStructArgumentRequest::DecodableType commandData; |
| TLVError = DataModel::Decode(aDataTlv, commandData); |
| if (TLVError == CHIP_NO_ERROR) |
| { |
| wasHandled = |
| emberAfTestClusterClusterTestListStructArgumentRequestCallback(apCommandObj, aCommandPath, commandData); |
| } |
| break; |
| } |
| case Commands::TestListInt8UArgumentRequest::Id: { |
| Commands::TestListInt8UArgumentRequest::DecodableType commandData; |
| TLVError = DataModel::Decode(aDataTlv, commandData); |
| if (TLVError == CHIP_NO_ERROR) |
| { |
| wasHandled = emberAfTestClusterClusterTestListInt8UArgumentRequestCallback(apCommandObj, aCommandPath, commandData); |
| } |
| break; |
| } |
| case Commands::TestNestedStructListArgumentRequest::Id: { |
| Commands::TestNestedStructListArgumentRequest::DecodableType commandData; |
| TLVError = DataModel::Decode(aDataTlv, commandData); |
| if (TLVError == CHIP_NO_ERROR) |
| { |
| wasHandled = |
| emberAfTestClusterClusterTestNestedStructListArgumentRequestCallback(apCommandObj, aCommandPath, commandData); |
| } |
| break; |
| } |
| case Commands::TestListNestedStructListArgumentRequest::Id: { |
| Commands::TestListNestedStructListArgumentRequest::DecodableType commandData; |
| TLVError = DataModel::Decode(aDataTlv, commandData); |
| if (TLVError == CHIP_NO_ERROR) |
| { |
| wasHandled = emberAfTestClusterClusterTestListNestedStructListArgumentRequestCallback(apCommandObj, aCommandPath, |
| commandData); |
| } |
| break; |
| } |
| case Commands::TestListInt8UReverseRequest::Id: { |
| Commands::TestListInt8UReverseRequest::DecodableType commandData; |
| TLVError = DataModel::Decode(aDataTlv, commandData); |
| if (TLVError == CHIP_NO_ERROR) |
| { |
| wasHandled = emberAfTestClusterClusterTestListInt8UReverseRequestCallback(apCommandObj, aCommandPath, commandData); |
| } |
| break; |
| } |
| case Commands::TestEnumsRequest::Id: { |
| Commands::TestEnumsRequest::DecodableType commandData; |
| TLVError = DataModel::Decode(aDataTlv, commandData); |
| if (TLVError == CHIP_NO_ERROR) |
| { |
| wasHandled = emberAfTestClusterClusterTestEnumsRequestCallback(apCommandObj, aCommandPath, commandData); |
| } |
| break; |
| } |
| case Commands::TestNullableOptionalRequest::Id: { |
| Commands::TestNullableOptionalRequest::DecodableType commandData; |
| TLVError = DataModel::Decode(aDataTlv, commandData); |
| if (TLVError == CHIP_NO_ERROR) |
| { |
| wasHandled = emberAfTestClusterClusterTestNullableOptionalRequestCallback(apCommandObj, aCommandPath, commandData); |
| } |
| break; |
| } |
| case Commands::SimpleStructEchoRequest::Id: { |
| Commands::SimpleStructEchoRequest::DecodableType commandData; |
| TLVError = DataModel::Decode(aDataTlv, commandData); |
| if (TLVError == CHIP_NO_ERROR) |
| { |
| wasHandled = emberAfTestClusterClusterSimpleStructEchoRequestCallback(apCommandObj, aCommandPath, commandData); |
| } |
| break; |
| } |
| case Commands::TimedInvokeRequest::Id: { |
| Commands::TimedInvokeRequest::DecodableType commandData; |
| TLVError = DataModel::Decode(aDataTlv, commandData); |
| if (TLVError == CHIP_NO_ERROR) |
| { |
| wasHandled = emberAfTestClusterClusterTimedInvokeRequestCallback(apCommandObj, aCommandPath, commandData); |
| } |
| break; |
| } |
| case Commands::TestSimpleOptionalArgumentRequest::Id: { |
| Commands::TestSimpleOptionalArgumentRequest::DecodableType commandData; |
| TLVError = DataModel::Decode(aDataTlv, commandData); |
| if (TLVError == CHIP_NO_ERROR) |
| { |
| wasHandled = |
| emberAfTestClusterClusterTestSimpleOptionalArgumentRequestCallback(apCommandObj, aCommandPath, commandData); |
| } |
| break; |
| } |
| case Commands::TestEmitTestEventRequest::Id: { |
| Commands::TestEmitTestEventRequest::DecodableType commandData; |
| TLVError = DataModel::Decode(aDataTlv, commandData); |
| if (TLVError == CHIP_NO_ERROR) |
| { |
| wasHandled = emberAfTestClusterClusterTestEmitTestEventRequestCallback(apCommandObj, aCommandPath, commandData); |
| } |
| break; |
| } |
| case Commands::TestEmitTestFabricScopedEventRequest::Id: { |
| Commands::TestEmitTestFabricScopedEventRequest::DecodableType commandData; |
| TLVError = DataModel::Decode(aDataTlv, commandData); |
| if (TLVError == CHIP_NO_ERROR) |
| { |
| wasHandled = |
| emberAfTestClusterClusterTestEmitTestFabricScopedEventRequestCallback(apCommandObj, aCommandPath, commandData); |
| } |
| break; |
| } |
| default: { |
| // Unrecognized command ID, error status will apply. |
| apCommandObj->AddStatus(aCommandPath, Protocols::InteractionModel::Status::UnsupportedCommand); |
| ChipLogError(Zcl, "Unknown command " ChipLogFormatMEI " for cluster " ChipLogFormatMEI, |
| ChipLogValueMEI(aCommandPath.mCommandId), ChipLogValueMEI(aCommandPath.mClusterId)); |
| return; |
| } |
| } |
| } |
| |
| if (CHIP_NO_ERROR != TLVError || !wasHandled) |
| { |
| apCommandObj->AddStatus(aCommandPath, Protocols::InteractionModel::Status::InvalidCommand); |
| ChipLogProgress(Zcl, "Failed to dispatch command, TLVError=%" CHIP_ERROR_FORMAT, TLVError.Format()); |
| } |
| } |
| |
| } // namespace TestCluster |
| |
| namespace Thermostat { |
| |
| void DispatchServerCommand(CommandHandler * apCommandObj, const ConcreteCommandPath & aCommandPath, TLV::TLVReader & aDataTlv) |
| { |
| CHIP_ERROR TLVError = CHIP_NO_ERROR; |
| bool wasHandled = false; |
| { |
| switch (aCommandPath.mCommandId) |
| { |
| case Commands::SetpointRaiseLower::Id: { |
| Commands::SetpointRaiseLower::DecodableType commandData; |
| TLVError = DataModel::Decode(aDataTlv, commandData); |
| if (TLVError == CHIP_NO_ERROR) |
| { |
| wasHandled = emberAfThermostatClusterSetpointRaiseLowerCallback(apCommandObj, aCommandPath, commandData); |
| } |
| break; |
| } |
| default: { |
| // Unrecognized command ID, error status will apply. |
| apCommandObj->AddStatus(aCommandPath, Protocols::InteractionModel::Status::UnsupportedCommand); |
| ChipLogError(Zcl, "Unknown command " ChipLogFormatMEI " for cluster " ChipLogFormatMEI, |
| ChipLogValueMEI(aCommandPath.mCommandId), ChipLogValueMEI(aCommandPath.mClusterId)); |
| return; |
| } |
| } |
| } |
| |
| if (CHIP_NO_ERROR != TLVError || !wasHandled) |
| { |
| apCommandObj->AddStatus(aCommandPath, Protocols::InteractionModel::Status::InvalidCommand); |
| ChipLogProgress(Zcl, "Failed to dispatch command, TLVError=%" CHIP_ERROR_FORMAT, TLVError.Format()); |
| } |
| } |
| |
| } // namespace Thermostat |
| |
| namespace WindowCovering { |
| |
| void DispatchServerCommand(CommandHandler * apCommandObj, const ConcreteCommandPath & aCommandPath, TLV::TLVReader & aDataTlv) |
| { |
| CHIP_ERROR TLVError = CHIP_NO_ERROR; |
| bool wasHandled = false; |
| { |
| switch (aCommandPath.mCommandId) |
| { |
| case Commands::UpOrOpen::Id: { |
| Commands::UpOrOpen::DecodableType commandData; |
| TLVError = DataModel::Decode(aDataTlv, commandData); |
| if (TLVError == CHIP_NO_ERROR) |
| { |
| wasHandled = emberAfWindowCoveringClusterUpOrOpenCallback(apCommandObj, aCommandPath, commandData); |
| } |
| break; |
| } |
| case Commands::DownOrClose::Id: { |
| Commands::DownOrClose::DecodableType commandData; |
| TLVError = DataModel::Decode(aDataTlv, commandData); |
| if (TLVError == CHIP_NO_ERROR) |
| { |
| wasHandled = emberAfWindowCoveringClusterDownOrCloseCallback(apCommandObj, aCommandPath, commandData); |
| } |
| break; |
| } |
| case Commands::StopMotion::Id: { |
| Commands::StopMotion::DecodableType commandData; |
| TLVError = DataModel::Decode(aDataTlv, commandData); |
| if (TLVError == CHIP_NO_ERROR) |
| { |
| wasHandled = emberAfWindowCoveringClusterStopMotionCallback(apCommandObj, aCommandPath, commandData); |
| } |
| break; |
| } |
| default: { |
| // Unrecognized command ID, error status will apply. |
| apCommandObj->AddStatus(aCommandPath, Protocols::InteractionModel::Status::UnsupportedCommand); |
| ChipLogError(Zcl, "Unknown command " ChipLogFormatMEI " for cluster " ChipLogFormatMEI, |
| ChipLogValueMEI(aCommandPath.mCommandId), ChipLogValueMEI(aCommandPath.mClusterId)); |
| return; |
| } |
| } |
| } |
| |
| if (CHIP_NO_ERROR != TLVError || !wasHandled) |
| { |
| apCommandObj->AddStatus(aCommandPath, Protocols::InteractionModel::Status::InvalidCommand); |
| ChipLogProgress(Zcl, "Failed to dispatch command, TLVError=%" CHIP_ERROR_FORMAT, TLVError.Format()); |
| } |
| } |
| |
| } // namespace WindowCovering |
| |
| } // namespace Clusters |
| |
| void DispatchSingleClusterCommand(const ConcreteCommandPath & aCommandPath, TLV::TLVReader & aReader, CommandHandler * apCommandObj) |
| { |
| Compatibility::SetupEmberAfCommandHandler(apCommandObj, aCommandPath); |
| |
| switch (aCommandPath.mClusterId) |
| { |
| case Clusters::AccountLogin::Id: |
| Clusters::AccountLogin::DispatchServerCommand(apCommandObj, aCommandPath, aReader); |
| break; |
| case Clusters::AdministratorCommissioning::Id: |
| Clusters::AdministratorCommissioning::DispatchServerCommand(apCommandObj, aCommandPath, aReader); |
| break; |
| case Clusters::ApplicationLauncher::Id: |
| Clusters::ApplicationLauncher::DispatchServerCommand(apCommandObj, aCommandPath, aReader); |
| break; |
| case Clusters::AudioOutput::Id: |
| Clusters::AudioOutput::DispatchServerCommand(apCommandObj, aCommandPath, aReader); |
| break; |
| case Clusters::Channel::Id: |
| Clusters::Channel::DispatchServerCommand(apCommandObj, aCommandPath, aReader); |
| break; |
| case Clusters::DiagnosticLogs::Id: |
| Clusters::DiagnosticLogs::DispatchServerCommand(apCommandObj, aCommandPath, aReader); |
| break; |
| case Clusters::DoorLock::Id: |
| Clusters::DoorLock::DispatchServerCommand(apCommandObj, aCommandPath, aReader); |
| break; |
| case Clusters::EthernetNetworkDiagnostics::Id: |
| Clusters::EthernetNetworkDiagnostics::DispatchServerCommand(apCommandObj, aCommandPath, aReader); |
| break; |
| case Clusters::GeneralCommissioning::Id: |
| Clusters::GeneralCommissioning::DispatchServerCommand(apCommandObj, aCommandPath, aReader); |
| break; |
| case Clusters::GeneralDiagnostics::Id: |
| Clusters::GeneralDiagnostics::DispatchServerCommand(apCommandObj, aCommandPath, aReader); |
| break; |
| case Clusters::GroupKeyManagement::Id: |
| Clusters::GroupKeyManagement::DispatchServerCommand(apCommandObj, aCommandPath, aReader); |
| break; |
| case Clusters::Groups::Id: |
| Clusters::Groups::DispatchServerCommand(apCommandObj, aCommandPath, aReader); |
| break; |
| case Clusters::Identify::Id: |
| Clusters::Identify::DispatchServerCommand(apCommandObj, aCommandPath, aReader); |
| break; |
| case Clusters::KeypadInput::Id: |
| Clusters::KeypadInput::DispatchServerCommand(apCommandObj, aCommandPath, aReader); |
| break; |
| case Clusters::LevelControl::Id: |
| Clusters::LevelControl::DispatchServerCommand(apCommandObj, aCommandPath, aReader); |
| break; |
| case Clusters::LowPower::Id: |
| Clusters::LowPower::DispatchServerCommand(apCommandObj, aCommandPath, aReader); |
| break; |
| case Clusters::MediaInput::Id: |
| Clusters::MediaInput::DispatchServerCommand(apCommandObj, aCommandPath, aReader); |
| break; |
| case Clusters::MediaPlayback::Id: |
| Clusters::MediaPlayback::DispatchServerCommand(apCommandObj, aCommandPath, aReader); |
| break; |
| case Clusters::ModeSelect::Id: |
| Clusters::ModeSelect::DispatchServerCommand(apCommandObj, aCommandPath, aReader); |
| break; |
| case Clusters::NetworkCommissioning::Id: |
| Clusters::NetworkCommissioning::DispatchServerCommand(apCommandObj, aCommandPath, aReader); |
| break; |
| case Clusters::OtaSoftwareUpdateRequestor::Id: |
| Clusters::OtaSoftwareUpdateRequestor::DispatchServerCommand(apCommandObj, aCommandPath, aReader); |
| break; |
| case Clusters::OnOff::Id: |
| Clusters::OnOff::DispatchServerCommand(apCommandObj, aCommandPath, aReader); |
| break; |
| case Clusters::OperationalCredentials::Id: |
| Clusters::OperationalCredentials::DispatchServerCommand(apCommandObj, aCommandPath, aReader); |
| break; |
| case Clusters::Scenes::Id: |
| Clusters::Scenes::DispatchServerCommand(apCommandObj, aCommandPath, aReader); |
| break; |
| case Clusters::TargetNavigator::Id: |
| Clusters::TargetNavigator::DispatchServerCommand(apCommandObj, aCommandPath, aReader); |
| break; |
| case Clusters::TestCluster::Id: |
| Clusters::TestCluster::DispatchServerCommand(apCommandObj, aCommandPath, aReader); |
| break; |
| case Clusters::Thermostat::Id: |
| Clusters::Thermostat::DispatchServerCommand(apCommandObj, aCommandPath, aReader); |
| break; |
| case Clusters::WindowCovering::Id: |
| Clusters::WindowCovering::DispatchServerCommand(apCommandObj, aCommandPath, aReader); |
| break; |
| default: |
| ChipLogError(Zcl, "Unknown cluster " ChipLogFormatMEI, ChipLogValueMEI(aCommandPath.mClusterId)); |
| apCommandObj->AddStatus(aCommandPath, Protocols::InteractionModel::Status::UnsupportedCluster); |
| break; |
| } |
| |
| Compatibility::ResetEmberAfObjects(); |
| } |
| |
| } // namespace app |
| } // namespace chip |
