diff --git a/src/app/ClusterObjectCommandSenderCallback.cpp b/src/app/ClusterObjectCommandSenderCallback.cpp new file mode 100644 index 00000000000000..a939309086a63e --- /dev/null +++ b/src/app/ClusterObjectCommandSenderCallback.cpp @@ -0,0 +1,19 @@ +#include + +#include +#include +#include + +#include + +namespace chip { +namespace app { +template <> +void ClusterObjectCommandSenderCallback::OnResponse(const CommandSender * apCommandSender, + const CommandPath::Type & aCommandPath, TLV::TLVReader & aReader) +{ + mOnResponse(apCommandSender, aCommandPath); +} + +} // namespace app +} // namespace chip diff --git a/src/app/ClusterObjectCommandSenderCallback.h b/src/app/ClusterObjectCommandSenderCallback.h new file mode 100644 index 00000000000000..89fb3c29741dcd --- /dev/null +++ b/src/app/ClusterObjectCommandSenderCallback.h @@ -0,0 +1,85 @@ +/* + * + * Copyright (c) 2021 Project CHIP Authors + * All rights reserved. + * + * 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. + */ + +#pragma once + +#include +#include +#include + +#include + +namespace chip { +namespace app { + +template +class ClusterObjectCommandSenderCallback final : public CommandSender::Delegate +{ +public: + template + using OnResponseCallbackType = + std::function; + + template <> + using OnResponseCallbackType = std::function; + + using OnErrorCallbackTyoe = + std::function; + + using OnFinalCallbackType = std::function *)>; + + ClusterObjectCommandSenderCallback(OnResponseCallbackType aOnResponse, OnErrorCallbackTyoe aOnError, + OnFinalCallbackType aOnFinal) : + mOnResponse(aOnResponse), + mOnError(aOnError), mOnFinal(aOnFinal) + {} + + void OnResponse(const CommandSender * apCommandSender, const CommandPath::Type & aCommandPath, TLV::TLVReader & aReader); + void OnError(const CommandSender * apCommandSender, Protocols::InteractionModel::Status aIMStatus, CHIP_ERROR aError) + { + mOnError(apCommandSender, aIMStatus, aError); + } + void OnFinal(CommandSender * apCommandSender) { mOnFinal(apCommandSender, this); } + +private: + OnResponseCallbackType mOnResponse; + OnErrorCallbackTyoe mOnError; + OnFinalCallbackType mOnFinal; +}; + +template +void ClusterObjectCommandSenderCallback::OnResponse(const CommandSender * apCommandSender, + const CommandPath::Type & aCommandPath, + TLV::TLVReader & aReader) +{ + ClusterObjectT response; + CHIP_ERROR err = DataModel::Decode(aReader, response); + if (err != CHIP_NO_ERROR) + { + mOnError(err); + return; + } + mOnResponse(apCommandSender, aCommandPath, response); +} + +template <> +void ClusterObjectCommandSenderCallback::OnResponse(const CommandSender * apCommandSender, + const CommandPath::Type & aCommandPath, TLV::TLVReader & aReader); + +} // namespace app +} // namespace chip diff --git a/src/app/Command.cpp b/src/app/Command.cpp index a203cadda3695c..d2f337a047a555 100644 --- a/src/app/Command.cpp +++ b/src/app/Command.cpp @@ -33,7 +33,7 @@ namespace chip { namespace app { -CHIP_ERROR Command::Init(Messaging::ExchangeManager * apExchangeMgr, InteractionModelDelegate * apDelegate) +CHIP_ERROR Command::Init(Messaging::ExchangeManager * apExchangeMgr) { CHIP_ERROR err = CHIP_NO_ERROR; // Error if already initialized. @@ -41,7 +41,6 @@ CHIP_ERROR Command::Init(Messaging::ExchangeManager * apExchangeMgr, Interaction VerifyOrExit(mpExchangeMgr == nullptr, err = CHIP_ERROR_INCORRECT_STATE); mpExchangeMgr = apExchangeMgr; - mpDelegate = apDelegate; err = Reset(); SuccessOrExit(err); @@ -123,25 +122,6 @@ CHIP_ERROR Command::ProcessCommandMessage(System::PacketBufferHandle && payload, return err; } -void Command::Shutdown() -{ - VerifyOrReturn(mState != CommandState::Uninitialized); - AbortExistingExchangeContext(); - ShutdownInternal(); -} - -void Command::ShutdownInternal() -{ - mCommandMessageWriter.Reset(); - - mpExchangeMgr = nullptr; - mpExchangeCtx = nullptr; - mpDelegate = nullptr; - ClearState(); - - mCommandIndex = 0; -} - CHIP_ERROR Command::PrepareCommand(const CommandPathParams & aCommandPathParams, bool aIsStatus) { CHIP_ERROR err = CHIP_NO_ERROR; diff --git a/src/app/Command.h b/src/app/Command.h index 8ac0cc721c1b95..004d235f967d98 100644 --- a/src/app/Command.h +++ b/src/app/Command.h @@ -29,6 +29,7 @@ #include #include #include +#include #include #include #include @@ -41,6 +42,8 @@ #include #include +#include + namespace chip { namespace app { @@ -75,13 +78,10 @@ class Command * @retval #CHIP_NO_ERROR On success. * */ - CHIP_ERROR Init(Messaging::ExchangeManager * apExchangeMgr, InteractionModelDelegate * apDelegate); + CHIP_ERROR Init(Messaging::ExchangeManager * apExchangeMgr); - /** - * Shutdown the Command. This terminates this instance - * of the object and releases all held resources. - */ - void Shutdown(); + template + CHIP_ERROR EncodeFullCommand(const CommandPathParams & aCommandPathParams, const ClusterObjectT & aPayload); /** * Finalize Command Message TLV Builder and finalize command message @@ -125,23 +125,38 @@ class Command void ClearState(); const char * GetStateStr() const; - /** - * Internal shutdown method that we use when we know what's going on with - * our exchange and don't need to manually close it. - */ - void ShutdownInternal(); - InvokeCommand::Builder mInvokeCommandBuilder; Messaging::ExchangeManager * mpExchangeMgr = nullptr; Messaging::ExchangeContext * mpExchangeCtx = nullptr; - InteractionModelDelegate * mpDelegate = nullptr; uint8_t mCommandIndex = 0; CommandState mState = CommandState::Uninitialized; + chip::System::PacketBufferTLVWriter mCommandMessageWriter; private: friend class TestCommandInteraction; TLV::TLVType mDataElementContainerType = TLV::kTLVType_NotSpecified; - chip::System::PacketBufferTLVWriter mCommandMessageWriter; }; + +template +CHIP_ERROR Command::EncodeFullCommand(const CommandPathParams & aCommandPathParams, const ClusterObjectT & aPayload) +{ + CHIP_ERROR err = CHIP_NO_ERROR; + CommandDataElement::Builder commandDataElement; + + VerifyOrReturnError(mState == CommandState::Initialized || mState == CommandState::AddCommand, + err = CHIP_ERROR_INCORRECT_STATE); + + commandDataElement = mInvokeCommandBuilder.GetCommandListBuilder().CreateCommandDataElementBuilder(); + ReturnErrorOnFailure(commandDataElement.GetError()); + ReturnErrorOnFailure(ConstructCommandPath(aCommandPathParams, commandDataElement)); + ReturnErrorOnFailure( + DataModel::Encode(*commandDataElement.GetWriter(), TLV::ContextTag(CommandDataElement::kCsTag_Data), aPayload)); + + commandDataElement.EndOfCommandDataElement(); + ReturnErrorOnFailure(commandDataElement.GetError()); + MoveToState(CommandState::AddCommand); + return CHIP_NO_ERROR; +} + } // namespace app } // namespace chip diff --git a/src/app/CommandHandler.cpp b/src/app/CommandHandler.cpp index b7659f5a53b182..58366f6eb83c56 100644 --- a/src/app/CommandHandler.cpp +++ b/src/app/CommandHandler.cpp @@ -155,5 +155,23 @@ CHIP_ERROR CommandHandler::AddStatusCode(const CommandPathParams & aCommandPathP return err; } +void CommandHandler::ShutdownInternal() +{ + mCommandMessageWriter.Reset(); + + mpExchangeMgr = nullptr; + mpExchangeCtx = nullptr; + ClearState(); + + mCommandIndex = 0; +} + +void CommandHandler::Shutdown() +{ + VerifyOrReturn(mState != CommandState::Uninitialized); + AbortExistingExchangeContext(); + ShutdownInternal(); +} + } // namespace app } // namespace chip diff --git a/src/app/CommandHandler.h b/src/app/CommandHandler.h index 67c7ebca776c57..ba0bc8d9c22f38 100644 --- a/src/app/CommandHandler.h +++ b/src/app/CommandHandler.h @@ -47,9 +47,11 @@ class CommandHandler : public Command CHIP_ERROR AddStatusCode(const CommandPathParams & aCommandPathParams, const Protocols::SecureChannel::GeneralStatusCode aGeneralCode, const Protocols::Id aProtocolId, const Protocols::InteractionModel::Status aStatus) override; + void Shutdown(); private: friend class TestCommandInteraction; + void ShutdownInternal(); CHIP_ERROR SendCommandResponse(); CHIP_ERROR ProcessCommandDataElement(CommandDataElement::Parser & aCommandElement) override; }; diff --git a/src/app/CommandSender.cpp b/src/app/CommandSender.cpp index f7f549f6b54dae..02953eecef8d5d 100644 --- a/src/app/CommandSender.cpp +++ b/src/app/CommandSender.cpp @@ -27,6 +27,7 @@ #include "CommandHandler.h" #include "InteractionModelEngine.h" +#include #include using GeneralStatusCode = chip::Protocols::SecureChannel::GeneralStatusCode; @@ -77,20 +78,15 @@ CHIP_ERROR CommandSender::OnMessageReceived(Messaging::ExchangeContext * apExcha VerifyOrExit(aPayloadHeader.HasMessageType(Protocols::InteractionModel::MsgType::InvokeCommandResponse), err = CHIP_ERROR_INVALID_MESSAGE_TYPE); - err = ProcessCommandMessage(std::move(aPayload), CommandRoleId::SenderId); - SuccessOrExit(err); + SuccessOrExit(err = ProcessCommandMessage(std::move(aPayload), CommandRoleId::SenderId)); exit: - if (mpDelegate != nullptr) + if (mpCallback != nullptr) { if (err != CHIP_NO_ERROR) { - mpDelegate->CommandResponseError(this, err); - } - else - { - mpDelegate->CommandResponseProcessed(this); + mpCallback->OnError(this, Protocols::InteractionModel::Status::Failure, err); } } @@ -103,9 +99,9 @@ void CommandSender::OnResponseTimeout(Messaging::ExchangeContext * apExchangeCon ChipLogProgress(DataManagement, "Time out! failed to receive invoke command response from Exchange: " ChipLogFormatExchange, ChipLogValueExchange(apExchangeContext)); - if (mpDelegate != nullptr) + if (mpCallback != nullptr) { - mpDelegate->CommandResponseError(this, CHIP_ERROR_TIMEOUT); + mpCallback->OnError(this, Protocols::InteractionModel::Status::Failure, CHIP_ERROR_TIMEOUT); } ShutdownInternal(); @@ -114,55 +110,68 @@ void CommandSender::OnResponseTimeout(Messaging::ExchangeContext * apExchangeCon CHIP_ERROR CommandSender::ProcessCommandDataElement(CommandDataElement::Parser & aCommandElement) { CHIP_ERROR err = CHIP_NO_ERROR; - CommandPath::Parser commandPath; - chip::TLV::TLVReader commandDataReader; - chip::ClusterId clusterId; - chip::CommandId commandId; - chip::EndpointId endpointId; - Protocols::SecureChannel::GeneralStatusCode generalCode = Protocols::SecureChannel::GeneralStatusCode::kSuccess; - uint32_t protocolId = 0; - uint16_t protocolCode = 0; - StatusElement::Parser statusElementParser; - mCommandIndex++; - err = aCommandElement.GetCommandPath(&commandPath); - SuccessOrExit(err); - err = commandPath.GetClusterId(&clusterId); - SuccessOrExit(err); - err = commandPath.GetCommandId(&commandId); - SuccessOrExit(err); - - err = commandPath.GetEndpointId(&endpointId); - SuccessOrExit(err); + CommandPath::Type commandPath; + { + TLV::TLVReader commandPathReader; + SuccessOrExit( + err = aCommandElement.GetReaderOnTag(TLV::ContextTag(CommandDataElement::kCsTag_CommandPath), &commandPathReader)); + SuccessOrExit(err = commandPath.Decode(commandPathReader)); + } - err = aCommandElement.GetStatusElement(&statusElementParser); - if (CHIP_NO_ERROR == err) { - err = statusElementParser.DecodeStatusElement(&generalCode, &protocolId, &protocolCode); - SuccessOrExit(err); - if (mpDelegate != nullptr) + bool hasCommandSpecificResponse = false; + chip::TLV::TLVReader commandDataReader; + + // Default to success when command specify response is received. + StatusElement::Type statusElement{ chip::Protocols::SecureChannel::GeneralStatusCode::kSuccess, + chip::Protocols::InteractionModel::Id.ToFullyQualifiedSpecForm(), + to_underlying(Protocols::InteractionModel::Status::Success) }; + StatusElement::Parser statusElementParser; + err = aCommandElement.GetStatusElement(&statusElementParser); + if (CHIP_NO_ERROR == err) { - mpDelegate->CommandResponseStatus(this, generalCode, protocolId, protocolCode, endpointId, clusterId, commandId, - mCommandIndex); + err = statusElementParser.DecodeStatusElement(statusElement); + } + else if (CHIP_END_OF_TLV == err) + { + hasCommandSpecificResponse = true; + err = aCommandElement.GetData(&commandDataReader); } - } - else if (CHIP_END_OF_TLV == err) - { - // TODO(Spec#3258): The endpoint id in response command is not clear, so we cannot do "ClientClusterCommandExists" check. - err = aCommandElement.GetData(&commandDataReader); SuccessOrExit(err); - // TODO(#4503): Should call callbacks of cluster that sends the command. - DispatchSingleClusterResponseCommand(clusterId, commandId, endpointId, commandDataReader, this); + + if (mpCallback != nullptr) + { + if (statusElement.protocolCode == to_underlying(Protocols::InteractionModel::Status::Success)) + { + mpCallback->OnResponse(this, commandPath, hasCommandSpecificResponse ? &commandDataReader : nullptr); + } + else + { + mpCallback->OnError(this, static_cast(statusElement.protocolCode), + CHIP_NO_ERROR); + } + } } exit: - if (err != CHIP_NO_ERROR && mpDelegate != nullptr) + if (err != CHIP_NO_ERROR && mpCallback != nullptr) { - mpDelegate->CommandResponseProtocolError(this, mCommandIndex); + mpCallback->OnError(this, Protocols::InteractionModel::Status::Failure, err); } return err; } +void CommandSender::ShutdownInternal() +{ + // For CommandSender, ExchangeContext is the only thing it holds ownership by pointer. + AbortExistingExchangeContext(); + if (mpCallback != nullptr) + { + mpCallback->OnFinal(this); + } +} + } // namespace app } // namespace chip diff --git a/src/app/CommandSender.h b/src/app/CommandSender.h index 084ac9e2bd87ec..0984693f7f4d40 100644 --- a/src/app/CommandSender.h +++ b/src/app/CommandSender.h @@ -24,6 +24,8 @@ #pragma once +#include + #include #include #include @@ -36,15 +38,71 @@ #include #include +#include +#include #define COMMON_STATUS_SUCCESS 0 namespace chip { namespace app { -class CommandSender : public Command, public Messaging::ExchangeDelegate +class CommandSender final : public Command, public Messaging::ExchangeDelegate { public: + class Callback + { + public: + virtual ~Callback() = default; + + /** + * OnResponse will be called when the response from server arrived. + * - When StatusElement is received and it is Success, aData will be nullptr. + * - When command specific response is received, aData will be a valid TLVReader initialized with a struct of command + * specify response. + * - The ProtocolCode in StatusElement MUST be Success if this function is called. + * + * @param[in] apCommandSender: The command sender object that initialized the command transaction, MUST NOT be freed in this + * callback. + * @param[in] aPath: The command path field in invoke command response. + * @param[in] aData: The command data, will be nullptr if the server returns a StatusElement. + */ + virtual void OnResponse(const CommandSender * apCommandSender, const CommandPath::Type & aPath, TLV::TLVReader * aData) {} + + /** + * OnError will be called when error occurred when receiving / handling response from server: + * - CHIP_ERROR_TIMEOUT: The CommandSender failed to receive a expected response. + * - TLV Related erros: The CommandSender received a malformed response from server. + * - CHIP_NO_ERROR: The CommandSender received a legal response from server, but the protocol code indicates a error status + * presended in aInteractionModelStatus. + * + * @param[in] apCommandSender: The command sender object that initialized the command transaction, MUST NOT be freed in this + * callback. + * @param[in] aInteractionModel: The interaction model protocol status code, will be Failure if the CommandSender failed to + * recieve the response (aError != CHIP_NO_ERROR). This argument will never be Success when this function is called. + * @param[in] aProtocolError: The error occurred during the invoke command interaction, will be CHIP_NO_ERROR when the + * CommandSender received a valid response from server. + */ + virtual void OnError(const CommandSender * apCommandSender, Protocols::InteractionModel::Status aInteractionModelStatus, + CHIP_ERROR aProtocolError) + {} + + /** + * OnFinal will be called when CommandSender has finished all the works, and it is safe to release the + * allocated CommandSender object if needed. + * + * This function is marked as must be implemented to make application aware of releasing the object. + * + * This function will always be called exactly once for a single command sender. + * + * @param[in] apCommandSender: The command sender object of the terminated invoke command transaction. + */ + virtual void OnFinal(CommandSender * apCommandSender) = 0; + }; + + CommandSender(Callback * apCallback) : mpCallback(apCallback){}; + + ~CommandSender() { AbortExistingExchangeContext(); } + // TODO: issue #6792 - the secure session parameter should be made non-optional and passed by reference. // Once SendCommandRequest returns successfully, the CommandSender will // handle calling Shutdown on itself once it decides it's done with waiting @@ -66,7 +124,12 @@ class CommandSender : public Command, public Messaging::ExchangeDelegate System::PacketBufferHandle && aPayload) override; void OnResponseTimeout(Messaging::ExchangeContext * apExchangeContext) override; + // CommandSender does not have "Shutdown" method, the user will destruct it directly. + void ShutdownInternal(); + CHIP_ERROR ProcessCommandDataElement(CommandDataElement::Parser & aCommandElement) override; + + Callback * mpCallback = nullptr; }; } // namespace app diff --git a/src/app/InteractionModelDelegate.h b/src/app/InteractionModelDelegate.h index 01edc6efb1753f..0f86e64a60bff4 100644 --- a/src/app/InteractionModelDelegate.h +++ b/src/app/InteractionModelDelegate.h @@ -100,62 +100,6 @@ class InteractionModelDelegate */ virtual CHIP_ERROR ReadError(const ReadClient * apReadClient, CHIP_ERROR aError) { return CHIP_ERROR_NOT_IMPLEMENTED; } - /** - * Notification that a Command Send has received an Invoke Command Response containing a status code. - * @param[in] apCommandSender A current command sender which can identify the command sender to the consumer, particularly - * during multiple command interactions - * @param[in] aGeneralCode Status code defined by the standard - * @param[in] aProtocolId Protocol Id - * @param[in] aProtocolCode Detailed error information, protocol-specific. - * @param[in] aEndpointId Endpoint identifier - * @param[in] aClusterId Cluster identifier - * @param[in] aCommandId Command identifier - * @param[in] aCommandIndex Current processing command index which can identify command if there exists multiple commands with - * same command Id - * @retval # CHIP_ERROR_NOT_IMPLEMENTED if not implemented - */ - virtual CHIP_ERROR CommandResponseStatus(const CommandSender * apCommandSender, - const Protocols::SecureChannel::GeneralStatusCode aGeneralCode, - const uint32_t aProtocolId, const uint16_t aProtocolCode, EndpointId aEndpointId, - const ClusterId aClusterId, CommandId aCommandId, uint8_t aCommandIndex) - { - return CHIP_ERROR_NOT_IMPLEMENTED; - } - - /** - * Notification that a Command Response has already been processed. - * @param[in] apCommandSender A current command sender which can identify the command sender to the consumer, particularly - * during multiple command interactions - * @retval # CHIP_ERROR_NOT_IMPLEMENTED if not implemented - */ - virtual CHIP_ERROR CommandResponseProcessed(const CommandSender * apCommandSender) { return CHIP_ERROR_NOT_IMPLEMENTED; } - - /** - * Notification that a Command Send has received an Invoke Command Response and fails to process a command data element in that - * command response - * @param[in] apCommandSender A current command sender which can identify the command sender to the consumer, particularly - * during multiple command interactions - * @param[in] aCommandIndex Current processing command index which can identify failed command - * @retval # CHIP_ERROR_NOT_IMPLEMENTED if not implemented - */ - virtual CHIP_ERROR CommandResponseProtocolError(const CommandSender * apCommandSender, uint8_t aCommandIndex) - { - return CHIP_ERROR_NOT_IMPLEMENTED; - } - - /** - * Notification that a command sender encountered an asynchronous failure. - * @param[in] apCommandSender A current command sender which can identify the command sender to the consumer, particularly - * during multiple command interactions - * @param[in] aError A error that could be CHIP_ERROR_TIMEOUT when command sender fails to receive, or other error when - * fail to process command response. - * @retval # CHIP_ERROR_NOT_IMPLEMENTED if not implemented - */ - virtual CHIP_ERROR CommandResponseError(const CommandSender * apCommandSender, CHIP_ERROR aError) - { - return CHIP_ERROR_NOT_IMPLEMENTED; - } - /** * Notification that a WriteClient has received a Write Response containing a status code. * aAttributeIndex is processing attribute index which can identify attribute if there exists multiple attribute changes with diff --git a/src/app/InteractionModelEngine.cpp b/src/app/InteractionModelEngine.cpp index bd481ad5201db3..2b4a046b8fd58e 100644 --- a/src/app/InteractionModelEngine.cpp +++ b/src/app/InteractionModelEngine.cpp @@ -61,14 +61,6 @@ CHIP_ERROR InteractionModelEngine::Init(Messaging::ExchangeManager * apExchangeM void InteractionModelEngine::Shutdown() { - for (auto & commandSender : mCommandSenderObjs) - { - if (!commandSender.IsFree()) - { - commandSender.Shutdown(); - } - } - for (auto & commandHandler : mCommandHandlerObjs) { if (!commandHandler.IsFree()) @@ -118,26 +110,6 @@ void InteractionModelEngine::Shutdown() mpExchangeMgr->UnregisterUnsolicitedMessageHandlerForProtocol(Protocols::InteractionModel::Id); } -CHIP_ERROR InteractionModelEngine::NewCommandSender(CommandSender ** const apCommandSender) -{ - *apCommandSender = nullptr; - - for (auto & commandSender : mCommandSenderObjs) - { - if (commandSender.IsFree()) - { - const CHIP_ERROR err = commandSender.Init(mpExchangeMgr, mpDelegate); - if (err == CHIP_NO_ERROR) - { - *apCommandSender = &commandSender; - } - return err; - } - } - - return CHIP_ERROR_NO_MEMORY; -} - CHIP_ERROR InteractionModelEngine::NewReadClient(ReadClient ** const apReadClient, ReadClient::InteractionType aInteractionType, uint64_t aAppIdentifier) { @@ -210,7 +182,7 @@ CHIP_ERROR InteractionModelEngine::OnInvokeCommandRequest(Messaging::ExchangeCon { if (commandHandler.IsFree()) { - err = commandHandler.Init(mpExchangeMgr, mpDelegate); + err = commandHandler.Init(mpExchangeMgr); SuccessOrExit(err); err = commandHandler.OnInvokeCommandRequest(apExchangeContext, aPayloadHeader, std::move(aPayload)); apExchangeContext = nullptr; diff --git a/src/app/InteractionModelEngine.h b/src/app/InteractionModelEngine.h index 3e0dd9e1e30ca3..5a13a2f6209891 100644 --- a/src/app/InteractionModelEngine.h +++ b/src/app/InteractionModelEngine.h @@ -91,17 +91,6 @@ class InteractionModelEngine : public Messaging::ExchangeDelegate Messaging::ExchangeManager * GetExchangeManager(void) const { return mpExchangeMgr; }; - /** - * Retrieve a CommandSender that the SDK consumer can use to send a set of commands. If the call succeeds, - * see CommandSender documentation for lifetime handling. - * - * @param[out] apCommandSender A pointer to the CommandSender object. - * - * @retval #CHIP_ERROR_INCORRECT_STATE If there is no CommandSender available - * @retval #CHIP_NO_ERROR On success. - */ - CHIP_ERROR NewCommandSender(CommandSender ** const apCommandSender); - /** * Creates a new read client and send ReadRequest message to the node using the read client, * shutdown if fail to send it out @@ -200,7 +189,6 @@ class InteractionModelEngine : public Messaging::ExchangeDelegate // TODO(#8006): investgate if we can disable some IM functions on some compact accessories. // TODO(#8006): investgate if we can provide more flexible object management on devices with more resources. CommandHandler mCommandHandlerObjs[CHIP_IM_MAX_NUM_COMMAND_HANDLER]; - CommandSender mCommandSenderObjs[CHIP_IM_MAX_NUM_COMMAND_SENDER]; ReadClient mReadClients[CHIP_IM_MAX_NUM_READ_CLIENT]; ReadHandler mReadHandlers[CHIP_IM_MAX_NUM_READ_HANDLER]; WriteClient mWriteClients[CHIP_IM_MAX_NUM_WRITE_CLIENT]; diff --git a/src/app/MessageDef/CommandPath.cpp b/src/app/MessageDef/CommandPath.cpp index da627fe1ab693f..0ace04b4083123 100644 --- a/src/app/MessageDef/CommandPath.cpp +++ b/src/app/MessageDef/CommandPath.cpp @@ -30,12 +30,48 @@ #include #include +#include +#include using namespace chip; using namespace chip::TLV; namespace chip { namespace app { + +namespace CommandPath { +CHIP_ERROR Type::Decode(chip::TLV::TLVReader & reader) +{ + CHIP_ERROR err; + TLV::TLVType outer; + + err = reader.EnterContainer(outer); + ReturnErrorOnFailure(err); + + while ((err = reader.Next()) == CHIP_NO_ERROR) + { + uint64_t tag = reader.GetTag(); + + if (tag == TLV::ContextTag(kCsTag_EndpointId)) + { + ReturnErrorOnFailure(DataModel::Decode(reader, endpointId)); + } + else if (tag == TLV::ContextTag(kCsTag_ClusterId)) + { + ReturnErrorOnFailure(DataModel::Decode(reader, clusterId)); + } + else if (tag == TLV::ContextTag(kCsTag_CommandId)) + { + ReturnErrorOnFailure(DataModel::Decode(reader, commandId)); + } + } + + VerifyOrReturnError(err == CHIP_END_OF_TLV, err); + ReturnErrorOnFailure(reader.ExitContainer(outer)); + return CHIP_NO_ERROR; +} +} // namespace CommandPath + CHIP_ERROR CommandPath::Parser::Init(const chip::TLV::TLVReader & aReader) { CHIP_ERROR err = CHIP_NO_ERROR; diff --git a/src/app/MessageDef/CommandPath.h b/src/app/MessageDef/CommandPath.h index 41c14c434eea45..d7b9e9d3f57990 100644 --- a/src/app/MessageDef/CommandPath.h +++ b/src/app/MessageDef/CommandPath.h @@ -44,6 +44,16 @@ enum kCsTag_CommandId = 3, }; +struct Type +{ + chip::EndpointId endpointId; + chip::ClusterId clusterId; + chip::CommandId commandId; + + CHIP_ERROR Decode(TLV::TLVReader & reader); + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; + class Parser : public chip::app::Parser { public: diff --git a/src/app/MessageDef/StatusElement.h b/src/app/MessageDef/StatusElement.h index 5cd3fa301c8408..d31ade7c5e869d 100644 --- a/src/app/MessageDef/StatusElement.h +++ b/src/app/MessageDef/StatusElement.h @@ -45,6 +45,13 @@ enum kCsTag_ClusterId = 4 }; +struct Type +{ + Protocols::SecureChannel::GeneralStatusCode generalCode; + uint32_t protocolId; + uint16_t protocolCode; +}; + class Parser : public ListParser { public: @@ -87,6 +94,11 @@ class Parser : public ListParser */ CHIP_ERROR DecodeStatusElement(Protocols::SecureChannel::GeneralStatusCode * apGeneralCode, uint32_t * apProtocolId, uint16_t * apProtocolCode) const; + + inline CHIP_ERROR DecodeStatusElement(Type & aStatusElement) + { + return DecodeStatusElement(&aStatusElement.generalCode, &aStatusElement.protocolId, &aStatusElement.protocolCode); + }; }; class Builder : public ListBuilder @@ -126,6 +138,11 @@ class Builder : public ListBuilder StatusElement::Builder & EncodeStatusElement(const Protocols::SecureChannel::GeneralStatusCode aGeneralCode, const uint32_t aProtocolId, const uint16_t aProtocolCode); + inline StatusElement::Builder & EncodeStatusElement(const Type & aStatusElement) + { + return EncodeStatusElement(aStatusElement.generalCode, aStatusElement.protocolId, aStatusElement.protocolCode); + } + /** * @brief Mark the end of this StatusElement * diff --git a/src/app/chip_data_model.gni b/src/app/chip_data_model.gni index 405ddd02b87960..8d4162d03f59ca 100644 --- a/src/app/chip_data_model.gni +++ b/src/app/chip_data_model.gni @@ -186,6 +186,7 @@ template("chip_data_model") { public_deps += [ "${chip_root}/src/app", + "${chip_root}/src/app/common:cluster-objects", "${chip_root}/src/controller", "${chip_root}/src/lib/core", "${chip_root}/src/lib/support", diff --git a/src/app/common/BUILD.gn b/src/app/common/BUILD.gn index a97120b4108cbb..bc0a131dd0561f 100644 --- a/src/app/common/BUILD.gn +++ b/src/app/common/BUILD.gn @@ -17,7 +17,10 @@ import("//build_overrides/chip.gni") static_library("cluster-objects") { output_name = "libClusterObjects" - sources = [ "cluster-objects.cpp" ] + sources = [ + "${chip_root}/zzz_generated/app-common/app-common/zap-generated/cluster-objects.cpp", + "${chip_root}/zzz_generated/app-common/app-common/zap-generated/cluster-objects.h", + ] public_deps = [ "${chip_root}/src/app", diff --git a/src/app/common/StatusElement.cpp b/src/app/common/StatusElement.cpp new file mode 100644 index 00000000000000..0cc808233e4db4 --- /dev/null +++ b/src/app/common/StatusElement.cpp @@ -0,0 +1,53 @@ +#include +#include +#include +#include +#include + +namespace chip { +namespace app { +namespace Structs { +namespace StatusElement { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_List, outer)); + + { + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kGeneralCodeFieldTag), generalCode)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kProtocolIdFieldTag), protocolId)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kProtocolCodeFieldTag), protocolCode)); + } + + ReturnErrorOnFailure(writer.EndContainer(outer)); + + return CHIP_NO_ERROR; +} + +CHIP_ERROR Type::Decode(TLV::TLVReader & reader) +{ + CHIP_ERROR err; + TLV::TLVType outer; + + ReturnErrorOnFailure(reader.EnterContainer(outer)); + + // NOTE: StatusElement is a list + { + ReturnErrorOnFailure(reader.Next()); + ReturnErrorOnFailure(DataModel::Decode(reader, generalCode)); + ReturnErrorOnFailure(reader.Next()); + ReturnErrorOnFailure(DataModel::Decode(reader, protocolCode)); + ReturnErrorOnFailure(reader.Next()); + ReturnErrorOnFailure(DataModel::Decode(reader, protocolCode)); + } + + ReturnErrorOnFailure(reader.ExitContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace StatusElement +} // namespace Structs +} // namespace app +} // namespace chip diff --git a/src/app/common/StatusElement.h b/src/app/common/StatusElement.h new file mode 100644 index 00000000000000..b6e56192ef832a --- /dev/null +++ b/src/app/common/StatusElement.h @@ -0,0 +1,32 @@ +#pragma once + +#include +#include +#include + +namespace chip { +namespace app { +namespace Structs { +namespace StatusElement { + +enum FieldId +{ + kGeneralCodeFieldTag = 1, + kProtocolIdFieldTag = 2, + kProtocolCodeFieldTag = 3, +}; + +struct Type +{ + Protocols::SecureChannel::GeneralStatusCode generalCode; + uint32_t protocolId; + uint16_t protocolCode; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; + CHIP_ERROR Decode(TLV::TLVReader & reader); +}; + +} // namespace StatusElement +} // namespace Structs +} // namespace app +} // namespace chip diff --git a/src/app/common/cluster-objects.cpp b/src/app/common/cluster-objects.cpp deleted file mode 100644 index ea6a2879a8aae0..00000000000000 --- a/src/app/common/cluster-objects.cpp +++ /dev/null @@ -1,358 +0,0 @@ -#include "cluster-objects.h" - -#pragma GCC diagnostic ignored "-Wstack-usage=" - -namespace chip { -namespace app { -namespace clusters { -namespace TestCluster { -namespace TestListStructOctet { -CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const -{ - TLV::TLVType outer; - - ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); - - { - ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kFabricIndexFieldId), fabricIndex)); - ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kOperationalCertFieldId), operationalCert)); - } - - ReturnErrorOnFailure(writer.EndContainer(outer)); - - return CHIP_NO_ERROR; -} - -CHIP_ERROR Type::Decode(TLV::TLVReader & reader) -{ - CHIP_ERROR err; - TLV::TLVType outer; - - err = reader.EnterContainer(outer); - ReturnErrorOnFailure(err); - - while ((err = reader.Next()) == CHIP_NO_ERROR) - { - uint64_t tag = reader.GetTag(); - - if (tag == TLV::ContextTag(kFabricIndexFieldId)) - { - ReturnErrorOnFailure(DataModel::Decode(reader, fabricIndex)); - } - else if (tag == TLV::ContextTag(kOperationalCertFieldId)) - { - ReturnErrorOnFailure(DataModel::Decode(reader, operationalCert)); - } - } - - VerifyOrReturnError(err == CHIP_END_OF_TLV, err); - ReturnErrorOnFailure(reader.ExitContainer(outer)); - return CHIP_NO_ERROR; -} -} // namespace TestListStructOctet - -namespace SimpleStruct { -CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const -{ - TLV::TLVType outer; - - ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); - - { - ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kAFieldId), a)); - ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kBFieldId), b)); - ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kCFieldId), c)); - ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kDFieldId), d)); - ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kEFieldId), e)); - } - - ReturnErrorOnFailure(writer.EndContainer(outer)); - - return CHIP_NO_ERROR; -} - -CHIP_ERROR Type::Decode(TLV::TLVReader & reader) -{ - CHIP_ERROR err; - TLV::TLVType outer; - - err = reader.EnterContainer(outer); - ReturnErrorOnFailure(err); - - while ((err = reader.Next()) == CHIP_NO_ERROR) - { - uint64_t tag = reader.GetTag(); - - if (tag == TLV::ContextTag(kAFieldId)) - { - ReturnErrorOnFailure(DataModel::Decode(reader, a)); - } - else if (tag == TLV::ContextTag(kBFieldId)) - { - ReturnErrorOnFailure(DataModel::Decode(reader, b)); - } - else if (tag == TLV::ContextTag(kCFieldId)) - { - uint8_t v; - ReturnErrorOnFailure(DataModel::Decode(reader, v)); - c = (SimpleEnum) v; - } - else if (tag == TLV::ContextTag(kDFieldId)) - { - ReturnErrorOnFailure(DataModel::Decode(reader, d)); - } - else if (tag == TLV::ContextTag(kEFieldId)) - { - ReturnErrorOnFailure(DataModel::Decode(reader, e)); - } - } - - VerifyOrReturnError(err == CHIP_END_OF_TLV, err); - ReturnErrorOnFailure(reader.ExitContainer(outer)); - return CHIP_NO_ERROR; -} -} // namespace SimpleStruct - -namespace NestedStruct { -CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const -{ - TLV::TLVType outer; - - ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); - - { - ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kAFieldId), a)); - ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kBFieldId), b)); - ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kCFieldId), c)); - } - - ReturnErrorOnFailure(writer.EndContainer(outer)); - - return CHIP_NO_ERROR; -} - -CHIP_ERROR Type::Decode(TLV::TLVReader & reader) -{ - CHIP_ERROR err; - TLV::TLVType outer; - - err = reader.EnterContainer(outer); - ReturnErrorOnFailure(err); - - while ((err = reader.Next()) == CHIP_NO_ERROR) - { - uint64_t tag = reader.GetTag(); - - if (tag == TLV::ContextTag(kAFieldId)) - { - ReturnErrorOnFailure(DataModel::Decode(reader, a)); - } - else if (tag == TLV::ContextTag(kBFieldId)) - { - ReturnErrorOnFailure(DataModel::Decode(reader, b)); - } - else if (tag == TLV::ContextTag(kCFieldId)) - { - ReturnErrorOnFailure(DataModel::Decode(reader, c)); - } - } - - VerifyOrReturnError(err == CHIP_END_OF_TLV, err); - ReturnErrorOnFailure(reader.ExitContainer(outer)); - return CHIP_NO_ERROR; -} -} // namespace NestedStruct - -namespace NestedStructList { -CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const -{ - TLV::TLVType outer; - - ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); - - { - ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kAFieldId), a)); - ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kBFieldId), b)); - ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kCFieldId), c)); - ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kDFieldId), d)); - ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kEFieldId), e)); - ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kFFieldId), f)); - ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kGFieldId), g)); - } - - ReturnErrorOnFailure(writer.EndContainer(outer)); - - return CHIP_NO_ERROR; -} - -CHIP_ERROR Type::Decode(TLV::TLVReader & reader) -{ - CHIP_ERROR err; - TLV::TLVType outer; - - err = reader.EnterContainer(outer); - ReturnErrorOnFailure(err); - - while ((err = reader.Next()) == CHIP_NO_ERROR) - { - uint64_t tag = reader.GetTag(); - - if (tag == TLV::ContextTag(kAFieldId)) - { - ReturnErrorOnFailure(DataModel::Decode(reader, a)); - } - else if (tag == TLV::ContextTag(kBFieldId)) - { - ReturnErrorOnFailure(DataModel::Decode(reader, b)); - } - else if (tag == TLV::ContextTag(kCFieldId)) - { - ReturnErrorOnFailure(DataModel::Decode(reader, c)); - } - else if (tag == TLV::ContextTag(kDFieldId)) - { - return CHIP_ERROR_NOT_IMPLEMENTED; - } - else if (tag == TLV::ContextTag(kEFieldId)) - { - return CHIP_ERROR_NOT_IMPLEMENTED; - } - else if (tag == TLV::ContextTag(kFFieldId)) - { - return CHIP_ERROR_NOT_IMPLEMENTED; - } - } - - VerifyOrReturnError(err == CHIP_END_OF_TLV, err); - ReturnErrorOnFailure(reader.ExitContainer(outer)); - return CHIP_NO_ERROR; -} - -CHIP_ERROR DecodableType::Encode(TLV::TLVWriter & writer, uint64_t tag) const -{ - return CHIP_ERROR_BAD_REQUEST; -} - -CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader) -{ - CHIP_ERROR err; - TLV::TLVType outer; - - err = reader.EnterContainer(outer); - ReturnErrorOnFailure(err); - - while ((err = reader.Next()) == CHIP_NO_ERROR) - { - uint64_t tag = reader.GetTag(); - - if (tag == TLV::ContextTag(kAFieldId)) - { - ReturnErrorOnFailure(DataModel::Decode(reader, a)); - } - else if (tag == TLV::ContextTag(kBFieldId)) - { - ReturnErrorOnFailure(DataModel::Decode(reader, b)); - } - else if (tag == TLV::ContextTag(kCFieldId)) - { - ReturnErrorOnFailure(DataModel::Decode(reader, c)); - } - else if (tag == TLV::ContextTag(kDFieldId)) - { - ReturnErrorOnFailure(DataModel::Decode(reader, d)); - } - else if (tag == TLV::ContextTag(kEFieldId)) - { - ReturnErrorOnFailure(DataModel::Decode(reader, e)); - } - else if (tag == TLV::ContextTag(kFFieldId)) - { - ReturnErrorOnFailure(DataModel::Decode(reader, f)); - } - else if (tag == TLV::ContextTag(kGFieldId)) - { - ReturnErrorOnFailure(DataModel::Decode(reader, g)); - } - } - - VerifyOrReturnError(err == CHIP_END_OF_TLV, err); - ReturnErrorOnFailure(reader.ExitContainer(outer)); - return CHIP_NO_ERROR; -} - -} // namespace NestedStructList - -namespace DoubleNestedStructList { -CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const -{ - TLV::TLVType outer; - - ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); - - { - ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kAFieldId), a)); - } - - ReturnErrorOnFailure(writer.EndContainer(outer)); - - return CHIP_NO_ERROR; -} - -CHIP_ERROR Type::Decode(TLV::TLVReader & reader) -{ - CHIP_ERROR err; - TLV::TLVType outer; - - err = reader.EnterContainer(outer); - ReturnErrorOnFailure(err); - - while ((err = reader.Next()) == CHIP_NO_ERROR) - { - uint64_t tag = reader.GetTag(); - - if (tag == TLV::ContextTag(kAFieldId)) - { - return CHIP_ERROR_NOT_IMPLEMENTED; - } - } - - VerifyOrReturnError(err == CHIP_END_OF_TLV, err); - ReturnErrorOnFailure(reader.ExitContainer(outer)); - - return CHIP_NO_ERROR; -} - -CHIP_ERROR DecodableType::Encode(TLV::TLVWriter & writer, uint64_t tag) const -{ - return CHIP_ERROR_BAD_REQUEST; -} - -CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader) -{ - CHIP_ERROR err; - TLV::TLVType outer; - - err = reader.EnterContainer(outer); - ReturnErrorOnFailure(err); - - while ((err = reader.Next()) == CHIP_NO_ERROR) - { - uint64_t tag = reader.GetTag(); - - if (tag == TLV::ContextTag(kAFieldId)) - { - ReturnErrorOnFailure(DataModel::Decode(reader, a)); - } - } - - VerifyOrReturnError(err == CHIP_END_OF_TLV, err); - ReturnErrorOnFailure(reader.ExitContainer(outer)); - return CHIP_NO_ERROR; -} - -} // namespace DoubleNestedStructList - -} // namespace TestCluster -} // namespace clusters -} // namespace app -} // namespace chip diff --git a/src/app/common/cluster-objects.h b/src/app/common/cluster-objects.h deleted file mode 100644 index c45078699a7af8..00000000000000 --- a/src/app/common/cluster-objects.h +++ /dev/null @@ -1,156 +0,0 @@ -#pragma once - -#include -#include -#include -#include -#include - -namespace chip { -namespace app { -namespace clusters { -namespace TestCluster { -constexpr ClusterId kClusterId = 0x0000050F; - -enum class SimpleEnum : uint8_t -{ - UNSPECIFIED = 0x00, - VALUEA = 0x01, - VALUEB = 0x02, - VALUEC = 0x03 -}; - -namespace TestListStructOctet { -enum FieldId -{ - kFabricIndexFieldId = 0, - kOperationalCertFieldId = 1, -}; - -struct Type -{ - int64_t fabricIndex; - ByteSpan operationalCert; - - CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; - CHIP_ERROR Decode(TLV::TLVReader & reader); -}; -} // namespace TestListStructOctet - -namespace SimpleStruct { -enum FieldId -{ - kAFieldId = 0, - kBFieldId = 1, - kCFieldId = 2, - kDFieldId = 3, - kEFieldId = 4 -}; - -struct Type -{ - uint8_t a = 0; - bool b = false; - SimpleEnum c = SimpleEnum::UNSPECIFIED; - ByteSpan d; - Span e; - - CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; - CHIP_ERROR Decode(TLV::TLVReader & reader); -}; -} // namespace SimpleStruct - -namespace NestedStruct { -enum FieldId -{ - kAFieldId = 0, - kBFieldId = 1, - kCFieldId = 2 -}; - -class Type -{ -public: - uint8_t a = 0; - bool b = false; - SimpleStruct::Type c; - - CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; - CHIP_ERROR Decode(TLV::TLVReader & reader); -}; -} // namespace NestedStruct - -namespace NestedStructList { -enum FieldId -{ - kAFieldId = 0, - kBFieldId = 1, - kCFieldId = 2, - kDFieldId = 3, - kEFieldId = 4, - kFFieldId = 5, - kGFieldId = 6, -}; - -struct Type -{ -public: - uint8_t a = 0; - bool b = false; - SimpleStruct::Type c; - DataModel::List d; - DataModel::List e; - DataModel::List f; - DataModel::List g; - - CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; - CHIP_ERROR Decode(TLV::TLVReader & reader); -}; - -struct DecodableType -{ -public: - uint8_t a = 0; - bool b = false; - SimpleStruct::Type c; - DataModel::DecodableList d; - DataModel::DecodableList e; - DataModel::DecodableList f; - DataModel::DecodableList g; - - CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; - CHIP_ERROR Decode(TLV::TLVReader & reader); -}; - -} // namespace NestedStructList - -namespace DoubleNestedStructList { -enum FieldId -{ - kAFieldId = 0, -}; - -struct Type -{ -public: - DataModel::List a; - - CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; - CHIP_ERROR Decode(TLV::TLVReader & reader); -}; - -struct DecodableType -{ -public: - DataModel::DecodableList a; - - CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; - CHIP_ERROR Decode(TLV::TLVReader & reader); -}; - -} // namespace DoubleNestedStructList - -} // namespace TestCluster -} // namespace clusters -} // namespace app -} // namespace chip diff --git a/src/app/common/templates/templates.json b/src/app/common/templates/templates.json index 6af1ee935ffb53..974d3450003f4c 100644 --- a/src/app/common/templates/templates.json +++ b/src/app/common/templates/templates.json @@ -95,6 +95,16 @@ "path": "../../zap-templates/templates/app/ids/Commands.zapt", "name": "Commands Ids header", "output": "ids/Commands.h" + }, + { + "path": "../../zap-templates/templates/app/cluster-objects.zapt", + "name": "Cluster objects header for Interaction Model", + "output": "cluster-objects.h" + }, + { + "path": "../../zap-templates/templates/app/cluster-objects-src.zapt", + "name": "Cluster objects header for Interaction Model", + "output": "cluster-objects.cpp" } ] } diff --git a/src/app/tests/TestCommandInteraction.cpp b/src/app/tests/TestCommandInteraction.cpp index 179755a058c482..dd8ce6115d49a7 100644 --- a/src/app/tests/TestCommandInteraction.cpp +++ b/src/app/tests/TestCommandInteraction.cpp @@ -25,7 +25,9 @@ #include #include +#include #include +#include #include #include #include @@ -87,11 +89,29 @@ void DispatchSingleClusterCommand(chip::ClusterId aClusterId, chip::CommandId aC void DispatchSingleClusterResponseCommand(chip::ClusterId aClusterId, chip::CommandId aCommandId, chip::EndpointId aEndPointId, chip::TLV::TLVReader & aReader, CommandSender * apCommandObj) { - ChipLogDetail(Controller, "Received Cluster Command: Cluster=%" PRIx32 " Command=%" PRIx32 " Endpoint=%" PRIx16, aClusterId, - aCommandId, aEndPointId); // Nothing todo. } +class MockCommandSenderCallback : public CommandSender::Callback +{ +public: + void OnResponse(const chip::app::CommandSender * apCommandSender, const chip::app::CommandPath::Type & aPath, + chip::TLV::TLVReader * aData) override + { + IgnoreUnusedVariable(apCommandSender); + IgnoreUnusedVariable(aData); + ChipLogDetail(Controller, "Received Cluster Command: Cluster=%" PRIx32 " Command=%" PRIx32 " Endpoint=%" PRIx16, + aPath.clusterId, aPath.commandId, aPath.endpointId); + } + void OnError(const chip::app::CommandSender * apCommandSender, chip::Protocols::InteractionModel::Status aProtocolCode, + CHIP_ERROR aError) override + { + ChipLogError(Controller, "OnError happens with %" PRIx16 " %" CHIP_ERROR_FORMAT, to_underlying(aProtocolCode), + aError.Format()); + } + void OnFinal(chip::app::CommandSender * apCommandSender) override {} +} mockCommandSenderDelegate; + bool ServerClusterCommandExists(chip::ClusterId aClusterId, chip::CommandId aCommandId, chip::EndpointId aEndPointId) { // Mock cluster catalog, only support one command on one cluster on one endpoint. @@ -112,6 +132,7 @@ class TestCommandInteraction static void TestCommandHandlerWithSendEmptyResponse(nlTestSuite * apSuite, void * apContext); static void TestCommandHandlerWithProcessReceivedMsg(nlTestSuite * apSuite, void * apContext); static void TestCommandHandlerWithProcessReceivedEmptyDataMsg(nlTestSuite * apSuite, void * apContext); + static void TestCommandSenderWithClusterObjects(nlTestSuite * apSuite, void * apContext); private: static void GenerateReceivedCommand(nlTestSuite * apSuite, void * apContext, System::PacketBufferHandle & aPayload, @@ -221,19 +242,10 @@ void TestCommandInteraction::TestCommandSenderWithWrongState(nlTestSuite * apSui 3, // ClusterId 4, // CommandId (chip::app::CommandPathFlags::kEndpointIdValid) }; - app::CommandSender commandSender; + app::CommandSender commandSender(&mockCommandSenderDelegate); err = commandSender.PrepareCommand(commandPathParams); NL_TEST_ASSERT(apSuite, err == CHIP_ERROR_INCORRECT_STATE); - - commandSender.Shutdown(); - - System::PacketBufferHandle buf = System::PacketBufferHandle::New(System::PacketBuffer::kMaxSize); - err = commandSender.Init(&gExchangeManager, nullptr); - NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR); - - err = commandSender.SendCommandRequest(kTestDeviceNodeId, gFabricIndex, Optional::Missing()); - NL_TEST_ASSERT(apSuite, err == CHIP_ERROR_INCORRECT_STATE); } void TestCommandInteraction::TestCommandHandlerWithWrongState(nlTestSuite * apSuite, void * apContext) @@ -250,7 +262,7 @@ void TestCommandInteraction::TestCommandHandlerWithWrongState(nlTestSuite * apSu NL_TEST_ASSERT(apSuite, err == CHIP_ERROR_INCORRECT_STATE); commandHandler.Shutdown(); - err = commandHandler.Init(&chip::gExchangeManager, nullptr); + err = commandHandler.Init(&chip::gExchangeManager); NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR); commandHandler.mpExchangeCtx = gExchangeManager.NewContext(SessionHandle(0, 0, 0, 0), nullptr); TestExchangeDelegate delegate; @@ -264,10 +276,10 @@ void TestCommandInteraction::TestCommandSenderWithSendCommand(nlTestSuite * apSu { CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender commandSender; + app::CommandSender commandSender(&mockCommandSenderDelegate); System::PacketBufferHandle buf = System::PacketBufferHandle::New(System::PacketBuffer::kMaxSize); - err = commandSender.Init(&gExchangeManager, nullptr); + err = commandSender.Init(&gExchangeManager); NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR); AddCommandDataElement(apSuite, apContext, &commandSender, false); @@ -277,7 +289,6 @@ void TestCommandInteraction::TestCommandSenderWithSendCommand(nlTestSuite * apSu GenerateReceivedCommand(apSuite, apContext, buf, true /*aNeedCommandData*/); err = commandSender.ProcessCommandMessage(std::move(buf), Command::CommandRoleId::SenderId); NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR); - commandSender.Shutdown(); } void TestCommandInteraction::TestCommandHandlerWithSendEmptyCommand(nlTestSuite * apSuite, void * apContext) @@ -290,7 +301,7 @@ void TestCommandInteraction::TestCommandHandlerWithSendEmptyCommand(nlTestSuite (chip::app::CommandPathFlags::kEndpointIdValid) }; app::CommandHandler commandHandler; System::PacketBufferHandle commandDatabuf = System::PacketBufferHandle::New(System::PacketBuffer::kMaxSize); - err = commandHandler.Init(&chip::gExchangeManager, nullptr); + err = commandHandler.Init(&chip::gExchangeManager); NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR); commandHandler.mpExchangeCtx = gExchangeManager.NewContext(SessionHandle(0, 0, 0, 0), nullptr); @@ -310,16 +321,15 @@ void TestCommandInteraction::TestCommandSenderWithProcessReceivedMsg(nlTestSuite { CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender commandSender; + app::CommandSender commandSender(&mockCommandSenderDelegate); System::PacketBufferHandle buf = System::PacketBufferHandle::New(System::PacketBuffer::kMaxSize); - err = commandSender.Init(&gExchangeManager, nullptr); + err = commandSender.Init(&gExchangeManager); NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR); GenerateReceivedCommand(apSuite, apContext, buf, true /*aNeedCommandData*/); err = commandSender.ProcessCommandMessage(std::move(buf), Command::CommandRoleId::SenderId); NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR); - commandSender.Shutdown(); } void TestCommandInteraction::ValidateCommandHandlerWithSendCommand(nlTestSuite * apSuite, void * apContext, bool aNeedStatusCode) @@ -327,7 +337,7 @@ void TestCommandInteraction::ValidateCommandHandlerWithSendCommand(nlTestSuite * CHIP_ERROR err = CHIP_NO_ERROR; app::CommandHandler commandHandler; System::PacketBufferHandle commandPacket; - err = commandHandler.Init(&chip::gExchangeManager, nullptr); + err = commandHandler.Init(&chip::gExchangeManager); NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR); commandHandler.mpExchangeCtx = gExchangeManager.NewContext(SessionHandle(0, 0, 0, 0), nullptr); @@ -368,7 +378,7 @@ void TestCommandInteraction::TestCommandHandlerWithProcessReceivedMsg(nlTestSuit CHIP_ERROR err = CHIP_NO_ERROR; app::CommandHandler commandHandler; System::PacketBufferHandle commandDatabuf = System::PacketBufferHandle::New(System::PacketBuffer::kMaxSize); - err = commandHandler.Init(&chip::gExchangeManager, nullptr); + err = commandHandler.Init(&chip::gExchangeManager); NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR); GenerateReceivedCommand(apSuite, apContext, commandDatabuf, true /*aNeedCommandData*/); err = commandHandler.ProcessCommandMessage(std::move(commandDatabuf), Command::CommandRoleId::HandlerId); @@ -381,7 +391,7 @@ void TestCommandInteraction::TestCommandHandlerWithProcessReceivedNotExistComman CHIP_ERROR err = CHIP_NO_ERROR; app::CommandHandler commandHandler; System::PacketBufferHandle commandDatabuf = System::PacketBufferHandle::New(System::PacketBuffer::kMaxSize); - err = commandHandler.Init(&chip::gExchangeManager, nullptr); + err = commandHandler.Init(&chip::gExchangeManager); NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR); // Use some invalid endpoint / cluster / command. GenerateReceivedCommand(apSuite, apContext, commandDatabuf, false /*aNeedCommandData*/, 0xDE /* endpoint */, @@ -400,7 +410,7 @@ void TestCommandInteraction::TestCommandHandlerWithProcessReceivedEmptyDataMsg(n CHIP_ERROR err = CHIP_NO_ERROR; app::CommandHandler commandHandler; System::PacketBufferHandle commandDatabuf = System::PacketBufferHandle::New(System::PacketBuffer::kMaxSize); - err = commandHandler.Init(&chip::gExchangeManager, nullptr); + err = commandHandler.Init(&chip::gExchangeManager); NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR); chip::isCommandDispatched = false; GenerateReceivedCommand(apSuite, apContext, commandDatabuf, false /*aNeedCommandData*/); @@ -409,6 +419,21 @@ void TestCommandInteraction::TestCommandHandlerWithProcessReceivedEmptyDataMsg(n commandHandler.Shutdown(); } +void TestCommandInteraction::TestCommandSenderWithClusterObjects(nlTestSuite * apSuite, void * apContext) +{ + CHIP_ERROR err = CHIP_NO_ERROR; + CHIP_ERROR commandError = CHIP_NO_ERROR; + bool testSuccess = false; + app::ClusterObjectCommandSenderCallback delegate( + [&](app::CommandSender * apSender, const CommandPath::Type & aCommandPath, + const Structs::StatusElement::Type & statusElement, StatusElement & response) { testSuccess = true; }, + [&](app::CommandSender * apSender, CHIP_ERROR err) { commandError = err; }, + [&](app::CommandSender * apSender, app::ClusterObjectCommandSenderCallback * apDeleger) { + // Do nothing + }); + app::CommandSender commandSender(&delegate); +} + } // namespace app } // namespace chip @@ -451,6 +476,7 @@ const nlTest sTests[] = NL_TEST_DEF("TestCommandHandlerWithProcessReceivedMsg", chip::app::TestCommandInteraction::TestCommandHandlerWithProcessReceivedMsg), NL_TEST_DEF("TestCommandHandlerWithProcessReceivedNotExistCommand", chip::app::TestCommandInteraction::TestCommandHandlerWithProcessReceivedNotExistCommand), NL_TEST_DEF("TestCommandHandlerWithProcessReceivedEmptyDataMsg", chip::app::TestCommandInteraction::TestCommandHandlerWithProcessReceivedEmptyDataMsg), + NL_TEST_DEF("TestCommandSenderWithClusterObjects", chip::app::TestCommandInteraction::TestCommandSenderWithClusterObjects), NL_TEST_SENTINEL() }; // clang-format on diff --git a/src/app/tests/TestDataModelSerialization.cpp b/src/app/tests/TestDataModelSerialization.cpp index 61d33e0d55008a..f35cd4b4075a0e 100644 --- a/src/app/tests/TestDataModelSerialization.cpp +++ b/src/app/tests/TestDataModelSerialization.cpp @@ -22,7 +22,7 @@ * */ -#include +#include #include #include #include @@ -162,7 +162,7 @@ void TestDataModelSerialization::TestDataModelSerialization_EncAndDecSimpleStruc t.a = 20; t.b = true; - t.c = clusters::TestCluster::SimpleEnum::VALUEA; + t.c = clusters::TestCluster::SimpleEnum::SIMPLE_ENUM_VALUE_A; t.d = buf; t.e = Span{ strbuf, strlen(strbuf) }; @@ -189,7 +189,7 @@ void TestDataModelSerialization::TestDataModelSerialization_EncAndDecSimpleStruc NL_TEST_ASSERT(apSuite, t.a == 20); NL_TEST_ASSERT(apSuite, t.b == true); - NL_TEST_ASSERT(apSuite, t.c == clusters::TestCluster::SimpleEnum::VALUEA); + NL_TEST_ASSERT(apSuite, t.c == clusters::TestCluster::SimpleEnum::SIMPLE_ENUM_VALUE_A); NL_TEST_ASSERT(apSuite, t.d.size() == 4); @@ -222,7 +222,7 @@ void TestDataModelSerialization::TestDataModelSerialization_EncAndDecNestedStruc t.b = true; t.c.a = 11; t.c.b = true; - t.c.c = clusters::TestCluster::SimpleEnum::VALUEB; + t.c.c = clusters::TestCluster::SimpleEnum::SIMPLE_ENUM_VALUE_B; t.c.d = buf; t.c.e = Span{ strbuf, strlen(strbuf) }; @@ -251,7 +251,7 @@ void TestDataModelSerialization::TestDataModelSerialization_EncAndDecNestedStruc NL_TEST_ASSERT(apSuite, t.b == true); NL_TEST_ASSERT(apSuite, t.c.a == 11); NL_TEST_ASSERT(apSuite, t.c.b == true); - NL_TEST_ASSERT(apSuite, t.c.c == clusters::TestCluster::SimpleEnum::VALUEB); + NL_TEST_ASSERT(apSuite, t.c.c == clusters::TestCluster::SimpleEnum::SIMPLE_ENUM_VALUE_B); NL_TEST_ASSERT(apSuite, t.c.d.size() == 4); @@ -289,7 +289,7 @@ void TestDataModelSerialization::TestDataModelSerialization_EncAndDecDecodableNe t.b = true; t.c.a = 11; t.c.b = true; - t.c.c = clusters::TestCluster::SimpleEnum::VALUEB; + t.c.c = clusters::TestCluster::SimpleEnum::SIMPLE_ENUM_VALUE_B; t.c.d = buf; t.e = intBuf; @@ -337,7 +337,7 @@ void TestDataModelSerialization::TestDataModelSerialization_EncAndDecDecodableNe NL_TEST_ASSERT(apSuite, t.b == true); NL_TEST_ASSERT(apSuite, t.c.a == 11); NL_TEST_ASSERT(apSuite, t.c.b == true); - NL_TEST_ASSERT(apSuite, t.c.c == clusters::TestCluster::SimpleEnum::VALUEB); + NL_TEST_ASSERT(apSuite, t.c.c == clusters::TestCluster::SimpleEnum::SIMPLE_ENUM_VALUE_B); NL_TEST_ASSERT(apSuite, StringMatches(t.c.e, "chip")); { @@ -504,7 +504,7 @@ void TestDataModelSerialization::TestDataModelSerialization_OptionalFields(nlTes t.a = 20; t.b = true; - t.c = clusters::TestCluster::SimpleEnum::VALUEA; + t.c = clusters::TestCluster::SimpleEnum::SIMPLE_ENUM_VALUE_A; t.d = buf; t.e = Span{ strbuf, strlen(strbuf) }; @@ -543,7 +543,7 @@ void TestDataModelSerialization::TestDataModelSerialization_OptionalFields(nlTes NL_TEST_ASSERT(apSuite, t.a == 150); NL_TEST_ASSERT(apSuite, t.b == true); - NL_TEST_ASSERT(apSuite, t.c == clusters::TestCluster::SimpleEnum::VALUEA); + NL_TEST_ASSERT(apSuite, t.c == clusters::TestCluster::SimpleEnum::SIMPLE_ENUM_VALUE_A); NL_TEST_ASSERT(apSuite, t.d.size() == 4); @@ -574,7 +574,7 @@ void TestDataModelSerialization::TestDataModelSerialization_ExtraField(nlTestSui t.a = 20; t.b = true; - t.c = clusters::TestCluster::SimpleEnum::VALUEA; + t.c = clusters::TestCluster::SimpleEnum::SIMPLE_ENUM_VALUE_A; t.d = buf; t.e = Span{ strbuf, strlen(strbuf) }; @@ -611,7 +611,7 @@ void TestDataModelSerialization::TestDataModelSerialization_ExtraField(nlTestSui NL_TEST_ASSERT(apSuite, t.a == 20); NL_TEST_ASSERT(apSuite, t.b == true); - NL_TEST_ASSERT(apSuite, t.c == clusters::TestCluster::SimpleEnum::VALUEA); + NL_TEST_ASSERT(apSuite, t.c == clusters::TestCluster::SimpleEnum::SIMPLE_ENUM_VALUE_A); NL_TEST_ASSERT(apSuite, t.d.size() == 4); @@ -646,7 +646,7 @@ void TestDataModelSerialization::TestDataModelSerialization_InvalidSimpleFieldTy t.a = 20; t.b = true; - t.c = clusters::TestCluster::SimpleEnum::VALUEA; + t.c = clusters::TestCluster::SimpleEnum::SIMPLE_ENUM_VALUE_A; t.d = buf; t.e = Span{ strbuf, strlen(strbuf) }; @@ -697,7 +697,7 @@ void TestDataModelSerialization::TestDataModelSerialization_InvalidSimpleFieldTy t.a = 20; t.b = true; - t.c = clusters::TestCluster::SimpleEnum::VALUEA; + t.c = clusters::TestCluster::SimpleEnum::SIMPLE_ENUM_VALUE_A; t.d = buf; t.e = Span{ strbuf, strlen(strbuf) }; diff --git a/src/app/tests/integration/chip_im_initiator.cpp b/src/app/tests/integration/chip_im_initiator.cpp index 2ac627ae1b93ab..60710392e99ad0 100644 --- a/src/app/tests/integration/chip_im_initiator.cpp +++ b/src/app/tests/integration/chip_im_initiator.cpp @@ -32,6 +32,7 @@ #include #include #include +#include #include #include #include @@ -98,13 +99,111 @@ enum class TestCommandResult : uint8_t TestCommandResult gLastCommandResult = TestCommandResult::kUndefined; +void HandleReadComplete() +{ + uint32_t respTime = chip::System::Clock::GetMonotonicMilliseconds(); + uint32_t transitTime = respTime - gLastMessageTime; + + gReadRespCount++; + + printf("Read Response: %" PRIu64 "/%" PRIu64 "(%.2f%%) time=%.3fms\n", gReadRespCount, gReadCount, + static_cast(gReadRespCount) * 100 / gReadCount, static_cast(transitTime) / 1000); +} + +void HandleWriteComplete() +{ + uint32_t respTime = chip::System::Clock::GetMonotonicMilliseconds(); + uint32_t transitTime = respTime - gLastMessageTime; + + gWriteRespCount++; + + printf("Write Response: %" PRIu64 "/%" PRIu64 "(%.2f%%) time=%.3fms\n", gWriteRespCount, gWriteCount, + static_cast(gWriteRespCount) * 100 / gWriteCount, static_cast(transitTime) / 1000); +} + +void HandleSubscribeReportComplete() +{ + uint32_t respTime = chip::System::Clock::GetMonotonicMilliseconds(); + uint32_t transitTime = respTime - gLastMessageTime; + gSubRespCount++; + printf("Subscribe Complete: %" PRIu64 "/%" PRIu64 "(%.2f%%) time=%.3fms\n", gSubRespCount, gSubCount, + static_cast(gSubRespCount) * 100 / gSubCount, static_cast(transitTime) / 1000); +} + +class MockInteractionModelApp : public chip::app::InteractionModelDelegate, public ::chip::app::CommandSender::Callback +{ +public: + CHIP_ERROR WriteResponseProcessed(const chip::app::WriteClient * apWriteClient) override + { + HandleWriteComplete(); + return CHIP_NO_ERROR; + } + CHIP_ERROR EventStreamReceived(const chip::Messaging::ExchangeContext * apExchangeContext, + chip::TLV::TLVReader * apEventListReader) override + { + return CHIP_NO_ERROR; + } + CHIP_ERROR ReportProcessed(const chip::app::ReadClient * apReadClient) override + { + if (apReadClient->IsSubscriptionType()) + { + gSubReportCount++; + if (gSubReportCount == gSubMaxReport) + { + HandleSubscribeReportComplete(); + } + } + + return CHIP_NO_ERROR; + } + + CHIP_ERROR ReadError(const chip::app::ReadClient * apReadClient, CHIP_ERROR aError) override + { + printf("ReadError with err %" CHIP_ERROR_FORMAT, aError.Format()); + return CHIP_NO_ERROR; + } + CHIP_ERROR ReadDone(const chip::app::ReadClient * apReadClient) override + { + if (!apReadClient->IsSubscriptionType()) + { + HandleReadComplete(); + } + return CHIP_NO_ERROR; + } + + void OnResponse(const chip::app::CommandSender * apCommandSender, const chip::app::CommandPath::Type & aPath, + chip::TLV::TLVReader * aData) override + { + printf("Command Response Success with EndpointId %d, ClusterId %d, CommandId %d", aPath.endpointId, aPath.clusterId, + aPath.commandId); + gLastCommandResult = TestCommandResult::kSuccess; + uint32_t respTime = chip::System::Clock::GetMonotonicMilliseconds(); + uint32_t transitTime = respTime - gLastMessageTime; + + gCommandRespCount++; + + printf("Command Response: %" PRIu64 "/%" PRIu64 "(%.2f%%) time=%.3fms\n", gCommandRespCount, gCommandCount, + static_cast(gCommandRespCount) * 100 / gCommandCount, static_cast(transitTime) / 1000); + } + void OnError(const chip::app::CommandSender * apCommandSender, chip::Protocols::InteractionModel::Status aProtocolCode, + CHIP_ERROR aError) override + { + gCommandRespCount += (aError == CHIP_NO_ERROR); + gLastCommandResult = TestCommandResult::kFailure; + printf("CommandResponseError happens with %" CHIP_ERROR_FORMAT, aError.Format()); + } + void OnFinal(chip::app::CommandSender * apCommandSender) override {} +}; + +MockInteractionModelApp gMockDelegate; + void CommandRequestTimerHandler(chip::System::Layer * systemLayer, void * appState); void BadCommandRequestTimerHandler(chip::System::Layer * systemLayer, void * appState); void ReadRequestTimerHandler(chip::System::Layer * systemLayer, void * appState); void WriteRequestTimerHandler(chip::System::Layer * systemLayer, void * appState); void SubscribeRequestTimerHandler(chip::System::Layer * systemLayer, void * appState); -CHIP_ERROR SendCommandRequest(chip::app::CommandSender * commandSender) +CHIP_ERROR SendCommandRequest(std::unique_ptr && commandSender) { CHIP_ERROR err = CHIP_NO_ERROR; @@ -143,19 +242,18 @@ CHIP_ERROR SendCommandRequest(chip::app::CommandSender * commandSender) gMessageTimeoutMsec); SuccessOrExit(err); + gCommandCount++; + commandSender.release(); + exit: - if (err == CHIP_NO_ERROR) - { - gCommandCount++; - } - else + if (err != CHIP_NO_ERROR) { printf("Send invoke command request failed, err: %s\n", chip::ErrorStr(err)); } return err; } -CHIP_ERROR SendBadCommandRequest(chip::app::CommandSender * commandSender) +CHIP_ERROR SendBadCommandRequest(std::unique_ptr && commandSender) { CHIP_ERROR err = CHIP_NO_ERROR; @@ -180,13 +278,11 @@ CHIP_ERROR SendBadCommandRequest(chip::app::CommandSender * commandSender) err = commandSender->SendCommandRequest(chip::kTestDeviceNodeId, gFabricIndex, chip::Optional::Missing(), gMessageTimeoutMsec); SuccessOrExit(err); + gCommandCount++; + commandSender.release(); exit: - if (err == CHIP_NO_ERROR) - { - gCommandCount++; - } - else + if (err != CHIP_NO_ERROR) { printf("Send invoke command request failed, err: %s\n", chip::ErrorStr(err)); } @@ -343,37 +439,6 @@ CHIP_ERROR EstablishSecureSession() return err; } -void HandleReadComplete() -{ - uint32_t respTime = chip::System::Clock::GetMonotonicMilliseconds(); - uint32_t transitTime = respTime - gLastMessageTime; - - gReadRespCount++; - - printf("Read Response: %" PRIu64 "/%" PRIu64 "(%.2f%%) time=%.3fms\n", gReadRespCount, gReadCount, - static_cast(gReadRespCount) * 100 / gReadCount, static_cast(transitTime) / 1000); -} - -void HandleWriteComplete() -{ - uint32_t respTime = chip::System::Clock::GetMonotonicMilliseconds(); - uint32_t transitTime = respTime - gLastMessageTime; - - gWriteRespCount++; - - printf("Write Response: %" PRIu64 "/%" PRIu64 "(%.2f%%) time=%.3fms\n", gWriteRespCount, gWriteCount, - static_cast(gWriteRespCount) * 100 / gWriteCount, static_cast(transitTime) / 1000); -} - -void HandleSubscribeReportComplete() -{ - uint32_t respTime = chip::System::Clock::GetMonotonicMilliseconds(); - uint32_t transitTime = respTime - gLastMessageTime; - gSubRespCount++; - printf("Subscribe Complete: %" PRIu64 "/%" PRIu64 "(%.2f%%) time=%.3fms\n", gSubRespCount, gSubCount, - static_cast(gSubRespCount) * 100 / gSubCount, static_cast(transitTime) / 1000); -} - void CommandRequestTimerHandler(chip::System::Layer * systemLayer, void * appState) { CHIP_ERROR err = CHIP_NO_ERROR; @@ -388,11 +453,11 @@ void CommandRequestTimerHandler(chip::System::Layer * systemLayer, void * appSta if (gCommandRespCount < kMaxCommandMessageCount) { - chip::app::CommandSender * commandSender; - err = chip::app::InteractionModelEngine::GetInstance()->NewCommandSender(&commandSender); - SuccessOrExit(err); + auto commandSender = std::make_unique(&gMockDelegate); + VerifyOrExit(commandSender != nullptr, err = CHIP_ERROR_NO_MEMORY); + SuccessOrExit(err = commandSender->Init(&gExchangeManager)); - err = SendCommandRequest(commandSender); + err = SendCommandRequest(std::move(commandSender)); VerifyOrExit(err == CHIP_NO_ERROR, printf("Failed to send command request with error: %s\n", chip::ErrorStr(err))); err = chip::DeviceLayer::SystemLayer().StartTimer(gMessageIntervalMsec, CommandRequestTimerHandler, NULL); @@ -414,11 +479,12 @@ void CommandRequestTimerHandler(chip::System::Layer * systemLayer, void * appSta void BadCommandRequestTimerHandler(chip::System::Layer * systemLayer, void * appState) { // Test with invalid endpoint / cluster / command combination. - chip::app::CommandSender * commandSender; - CHIP_ERROR err = chip::app::InteractionModelEngine::GetInstance()->NewCommandSender(&commandSender); - SuccessOrExit(err); + CHIP_ERROR err = CHIP_NO_ERROR; + auto commandSender = std::make_unique(&gMockDelegate); + VerifyOrExit(commandSender != nullptr, err = CHIP_ERROR_NO_MEMORY); + SuccessOrExit(err = commandSender->Init(&gExchangeManager)); - err = SendBadCommandRequest(commandSender); + err = SendBadCommandRequest(std::move(commandSender)); VerifyOrExit(err == CHIP_NO_ERROR, printf("Failed to send bad command request with error: %s\n", chip::ErrorStr(err))); err = chip::DeviceLayer::SystemLayer().StartTimer(gMessageIntervalMsec, ReadRequestTimerHandler, NULL); @@ -533,88 +599,6 @@ void SubscribeRequestTimerHandler(chip::System::Layer * systemLayer, void * appS chip::DeviceLayer::PlatformMgr().StopEventLoopTask(); } } - -class MockInteractionModelApp : public chip::app::InteractionModelDelegate -{ -public: - CHIP_ERROR WriteResponseProcessed(const chip::app::WriteClient * apWriteClient) override - { - HandleWriteComplete(); - return CHIP_NO_ERROR; - } - CHIP_ERROR EventStreamReceived(const chip::Messaging::ExchangeContext * apExchangeContext, - chip::TLV::TLVReader * apEventListReader) override - { - return CHIP_NO_ERROR; - } - CHIP_ERROR ReportProcessed(const chip::app::ReadClient * apReadClient) override - { - if (apReadClient->IsSubscriptionType()) - { - gSubReportCount++; - if (gSubReportCount == gSubMaxReport) - { - HandleSubscribeReportComplete(); - } - } - - return CHIP_NO_ERROR; - } - - CHIP_ERROR ReadError(const chip::app::ReadClient * apReadClient, CHIP_ERROR aError) override - { - printf("ReadError with err %" CHIP_ERROR_FORMAT, aError.Format()); - return CHIP_NO_ERROR; - } - CHIP_ERROR ReadDone(const chip::app::ReadClient * apReadClient) override - { - if (!apReadClient->IsSubscriptionType()) - { - HandleReadComplete(); - } - return CHIP_NO_ERROR; - } - CHIP_ERROR CommandResponseStatus(const chip::app::CommandSender * apCommandSender, - const chip::Protocols::SecureChannel::GeneralStatusCode aGeneralCode, - const uint32_t aProtocolId, const uint16_t aProtocolCode, const chip::EndpointId aEndpointId, - const chip::ClusterId aClusterId, const chip::CommandId aCommandId, - uint8_t aCommandIndex) override - { - printf("CommandResponseStatus with GeneralCode %d, ProtocolId %d, ProtocolCode %d, EndpointId %d, ClusterId %d, CommandId " - "%d, CommandIndex %d", - static_cast(aGeneralCode), aProtocolId, aProtocolCode, aEndpointId, aClusterId, aCommandId, aCommandIndex); - gLastCommandResult = (aGeneralCode == chip::Protocols::SecureChannel::GeneralStatusCode::kSuccess && aProtocolCode == 0) - ? TestCommandResult::kSuccess - : TestCommandResult::kFailure; - return CHIP_NO_ERROR; - } - - CHIP_ERROR CommandResponseProcessed(const chip::app::CommandSender * apCommandSender) override - { - - uint32_t respTime = chip::System::Clock::GetMonotonicMilliseconds(); - uint32_t transitTime = respTime - gLastMessageTime; - - gCommandRespCount++; - - printf("Command Response: %" PRIu64 "/%" PRIu64 "(%.2f%%) time=%.3fms\n", gCommandRespCount, gCommandCount, - static_cast(gCommandRespCount) * 100 / gCommandCount, static_cast(transitTime) / 1000); - return CHIP_NO_ERROR; - } - - CHIP_ERROR CommandResponseProtocolError(const chip::app::CommandSender * apCommandSender, uint8_t aCommandIndex) override - { - printf("CommandResponseProtocolError happens with CommandIndex %d", aCommandIndex); - return CHIP_NO_ERROR; - } - - CHIP_ERROR CommandResponseError(const chip::app::CommandSender * apCommandSender, CHIP_ERROR aError) override - { - printf("CommandResponseError happens with %" CHIP_ERROR_FORMAT, aError.Format()); - return aError; - } -}; - } // namespace namespace chip { @@ -678,7 +662,6 @@ int main(int argc, char * argv[]) std::mutex mutex; std::unique_lock lock(mutex); - MockInteractionModelApp mockDelegate; chip::Transport::FabricTable fabrics; if (argc <= 1) @@ -711,7 +694,7 @@ int main(int argc, char * argv[]) err = gMessageCounterManager.Init(&gExchangeManager); SuccessOrExit(err); - err = chip::app::InteractionModelEngine::GetInstance()->Init(&gExchangeManager, &mockDelegate); + err = chip::app::InteractionModelEngine::GetInstance()->Init(&gExchangeManager, &gMockDelegate); SuccessOrExit(err); // Start the CHIP connection to the CHIP im responder. diff --git a/src/app/zap-templates/app-templates.json b/src/app/zap-templates/app-templates.json index 09a05783977f14..be12d5781bd11b 100644 --- a/src/app/zap-templates/app-templates.json +++ b/src/app/zap-templates/app-templates.json @@ -34,6 +34,16 @@ "name": "ZCL attribute-size", "output": "attribute-size.cpp" }, + { + "path": "templates/app/command-cluster-objects.zapt", + "name": "Command Cluster Objects", + "output": "cluster_objects_commands.h" + }, + { + "path": "templates/app/command-cluster-objects-src.zapt", + "name": "Command Cluster Objects", + "output": "cluster_objects_commands.cpp" + }, { "path": "templates/app/callback-stub-src.zapt", "name": "ZCL callback-stub source", diff --git a/src/app/zap-templates/templates/app/CHIPClusters-src.zapt b/src/app/zap-templates/templates/app/CHIPClusters-src.zapt index d9239f0358da46..e430622285a9ed 100644 --- a/src/app/zap-templates/templates/app/CHIPClusters-src.zapt +++ b/src/app/zap-templates/templates/app/CHIPClusters-src.zapt @@ -9,17 +9,25 @@ #include #include #include +#include +#include +#include #include +#include #include #include #include +#include #include #include #include +#include namespace chip { +using namespace app; using namespace app::Clusters; +using namespace app::clusters; using namespace System; using namespace Encoding::LittleEndian; @@ -29,14 +37,47 @@ namespace Controller { // TODO(#4503): length should be passed to commands when byte string is in argument list. // TODO(#4503): Commands should take group id as an argument. +namespace { +void onClusterObjectCommandSenderFinal(CommandSender * sender, app::ClusterObjectCommandSenderCallback * _this) { + Platform::Delete(sender); + Platform::Delete(_this); +} +} + {{#chip_client_clusters}} // {{asUpperCamelCase name}} Cluster Commands {{#chip_cluster_commands}} +CHIP_ERROR {{asUpperCamelCase clusterName}}Cluster::{{asUpperCamelCase name}}(On{{asUpperCamelCase name}}CommandResponseCallbackFunct onSuccess, OnCommandErrorCallbackFunct onFailure, const app::clusters::{{asUpperCamelCase parent.name}}::{{name}}CommandParams::Type& params) +{ + {{#if hasSpecificResponse}} + using ResponseCallbackType = clusters::{{asUpperCamelCase parent.name}}::{{asUpperCamelCase responseName}}CommandParams::Type; + {{else}} + using ResponseCallbackType = void; + {{/if}} + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, {{asUpperCamelCase parent.name}}::Commands::Ids::{{asUpperCamelCase name}}, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR {{asUpperCamelCase clusterName}}Cluster::{{asUpperCamelCase name}}(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback{{#chip_cluster_command_arguments}}, {{chipType}} {{asLowerCamelCase label}}{{/chip_cluster_command_arguments}}) { CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; TLV::TLVWriter * writer = nullptr; uint8_t argSeqNumber = 0; @@ -49,8 +90,11 @@ CHIP_ERROR {{asUpperCamelCase clusterName}}Cluster::{{asUpperCamelCase name}}(Ca app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, {{asUpperCamelCase parent.name}}::Commands::Ids::{{asUpperCamelCase name}}, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); {{#chip_cluster_command_arguments}} @@ -66,16 +110,13 @@ CHIP_ERROR {{asUpperCamelCase clusterName}}Cluster::{{asUpperCamelCase name}}(Ca SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } diff --git a/src/app/zap-templates/templates/app/CHIPClusters.zapt b/src/app/zap-templates/templates/app/CHIPClusters.zapt index 3ee75d9c6da3db..bc272f04de174d 100644 --- a/src/app/zap-templates/templates/app/CHIPClusters.zapt +++ b/src/app/zap-templates/templates/app/CHIPClusters.zapt @@ -7,10 +7,14 @@ #include #include +#include + #include #include #include +#include + namespace chip { namespace Controller { @@ -28,6 +32,21 @@ public: CHIP_ERROR {{asUpperCamelCase name}}(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback{{#chip_cluster_command_arguments}}, {{chipType}} {{asLowerCamelCase label}}{{/chip_cluster_command_arguments}}); {{/chip_cluster_commands}} + {{#chip_cluster_commands}} + {{#first}} + + // Cluster Commands (Cluster Object Implementation) + using OnCommandErrorCallbackFunct = std::function; + {{/first}} + using On{{asUpperCamelCase name}}CommandResponseCallbackFunct = + {{#if hasSpecificResponse}} + std::function; + {{else}} + std::function; + {{/if}} + CHIP_ERROR {{asUpperCamelCase name}}(On{{asUpperCamelCase name}}CommandResponseCallbackFunct, OnCommandErrorCallbackFunct, const app::clusters::{{asUpperCamelCase parent.name}}::{{name}}CommandParams::Type& params); + {{/chip_cluster_commands}} + // Cluster Attributes {{#chip_server_cluster_attributes}} CHIP_ERROR ReadAttribute{{asUpperCamelCase name}}(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); diff --git a/src/app/zap-templates/templates/app/cluster-objects-src.zapt b/src/app/zap-templates/templates/app/cluster-objects-src.zapt new file mode 100644 index 00000000000000..ee2d3b58dcc1eb --- /dev/null +++ b/src/app/zap-templates/templates/app/cluster-objects-src.zapt @@ -0,0 +1,99 @@ +{{> header}} + +#include + +#pragma GCC diagnostic ignored "-Wstack-usage=" + +namespace chip { +namespace app { +namespace clusters { +{{#all_user_clusters}} +{{#if (user_cluster_has_enabled_command name side)}} +namespace {{asCamelCased name false}} { +{{#zcl_structs}} +namespace {{asType label}} { +CHIP_ERROR Type::Encode(TLV::TLVWriter &writer, uint64_t tag) const{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + {{#zcl_struct_items}} + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(k{{asUpperCamelCase label}}FieldId), {{asLowerCamelCase label}})); + {{/zcl_struct_items}} + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +CHIP_ERROR Type::Decode(TLV::TLVReader &reader) { + CHIP_ERROR err; + TLV::TLVType outer; + err = reader.EnterContainer(outer); + ReturnErrorOnFailure(err); + while ((err = reader.Next()) == CHIP_NO_ERROR) { + switch (chip::TLV::TagNumFromTag(reader.GetTag())) + { + {{#zcl_struct_items}} + case k{{asUpperCamelCase label}}FieldId: + {{#if_is_enum type}} + uint8_t v; + ReturnErrorOnFailure(DataModel::Decode(reader, v)); + {{asLowerCamelCase label}} = static_cast<{{type}}>(v); + break; + {{else if isArray}} + return CHIP_ERROR_NOT_IMPLEMENTED; + {{else}} + ReturnErrorOnFailure(DataModel::Decode(reader, {{asLowerCamelCase label}})); + break; + {{/if_is_enum}} + {{/zcl_struct_items}} + default: + break; + } + } + VerifyOrReturnError(err == CHIP_END_OF_TLV, err); + ReturnErrorOnFailure(reader.ExitContainer(outer)); + return CHIP_NO_ERROR; +} +{{#if struct_contains_array}} +CHIP_ERROR DecodableType::Encode(TLV::TLVWriter &writer, uint64_t tag) const{ + return CHIP_ERROR_BAD_REQUEST; +} + +CHIP_ERROR DecodableType::Decode(TLV::TLVReader &reader) { + CHIP_ERROR err; + TLV::TLVType outer; + err = reader.EnterContainer(outer); + ReturnErrorOnFailure(err); + + while ((err = reader.Next()) == CHIP_NO_ERROR) { + switch (chip::TLV::TagNumFromTag(reader.GetTag())) + { + {{#zcl_struct_items}} + case k{{asUpperCamelCase label}}FieldId: + {{#if_is_enum type}} + uint8_t v; + ReturnErrorOnFailure(DataModel::Decode(reader, v)); + {{asLowerCamelCase label}} = static_cast<{{type}}>(v); + {{else}} + ReturnErrorOnFailure(DataModel::Decode(reader, {{asLowerCamelCase label}})); + {{/if_is_enum}} + break; + {{/zcl_struct_items}} + default: + break; + } + } + + VerifyOrReturnError(err == CHIP_END_OF_TLV, err); + ReturnErrorOnFailure(reader.ExitContainer(outer)); + return CHIP_NO_ERROR; +} +{{/if}} +} +{{/zcl_structs}} +} + +{{/if}} +{{/all_user_clusters}} + +} // namespace clusters +} // namespace app +} // namespace chip diff --git a/src/app/zap-templates/templates/app/cluster-objects.zapt b/src/app/zap-templates/templates/app/cluster-objects.zapt new file mode 100644 index 00000000000000..a5c90deac36459 --- /dev/null +++ b/src/app/zap-templates/templates/app/cluster-objects.zapt @@ -0,0 +1,72 @@ +{{> header}} + +#pragma once + +#include +#include +#include +#include +#include + +namespace chip { +namespace app { +namespace clusters { + +{{#all_user_clusters}} +namespace {{asCamelCased name false}} { +constexpr ClusterId kClusterId = {{asHex code 2}}; +{{#zcl_enums}} +// Enum for {{label}} +enum class {{asType label}} : {{asUnderlyingZclType type}} { +{{#zcl_enum_items}} +{{ident}}{{asDelimitedMacro parent.label}}_{{asDelimitedMacro label}} = {{asHex value 2}}, +{{/zcl_enum_items}} +}; +{{/zcl_enums}} + +{{#zcl_structs}} +namespace {{name}} { + enum FieldId { + {{#zcl_struct_items}} + k{{asUpperCamelCase label}}FieldId = {{index}}, + {{/zcl_struct_items}} + }; + + struct Type { + public: + {{#zcl_struct_items}} + {{#if isArray}} + DataModel::List<{{#if_is_enum type}}{{type}}{{else}}{{asChipZapType type}}{{/if_is_enum}}> {{asLowerCamelCase label}}; + {{else}} + {{#if_is_enum type}}{{type}}{{else}}{{asChipZapType type}}{{/if_is_enum}} {{asLowerCamelCase label}}; + {{/if}} + {{/zcl_struct_items}} + + CHIP_ERROR Encode(TLV::TLVWriter &writer, uint64_t tag) const; + CHIP_ERROR Decode(TLV::TLVReader &reader); + }; + + {{#if struct_contains_array}} + struct DecodableType { + public: + {{#zcl_struct_items checkForDoubleNestedArray="true"}} + {{#if isArray}} + DataModel::DecodableList<{{#if struct_item_contains_nested_array}}{{type}}::DecodableType{{else}}{{#if_is_enum type}}{{type}}{{else}}{{asChipZapType type}}{{/if_is_enum}}{{/if}}> {{asLowerCamelCase label}}; + {{else}} + {{#if struct_item_contains_nested_array}}{{type}}::DecodableType{{else}}{{#if_is_enum type}}{{type}}{{else}}{{asChipZapType type}}{{/if_is_enum}}{{/if}} {{asLowerCamelCase label}}; + {{/if}} + {{/zcl_struct_items}} + CHIP_ERROR Encode(TLV::TLVWriter &writer, uint64_t tag) const; + CHIP_ERROR Decode(TLV::TLVReader &reader); + }; + {{/if}} + +}// namespace for {{name}} +{{/zcl_structs}} + +}// namespace for {{name}} +{{/all_user_clusters}} + +} // namespace clusters +} // namespace app +} // namespace chip diff --git a/src/app/zap-templates/templates/app/command-cluster-objects-src.zapt b/src/app/zap-templates/templates/app/command-cluster-objects-src.zapt new file mode 100644 index 00000000000000..6d3747900608e6 --- /dev/null +++ b/src/app/zap-templates/templates/app/command-cluster-objects-src.zapt @@ -0,0 +1,42 @@ +{{> header}} + +#include "cluster_objects_commands.h" + +#include + +#pragma GCC diagnostic ignored "-Wstack-usage=" + +namespace chip { +namespace app { +namespace clusters { + +{{#chip_client_clusters}} +namespace {{asCamelCased name false}} { +{{#chip_cluster_commands}} +namespace {{name}}CommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter &writer, uint64_t tag) const{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + {{#chip_cluster_command_arguments}} + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(k{{asUpperCamelCase label}}FieldId), {{asLowerCamelCase label}})); + {{/chip_cluster_command_arguments}} + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} +{{/chip_cluster_commands}} + +{{#chip_cluster_responses}} +namespace {{name}}CommandParams { +CHIP_ERROR Type::Decode(TLV::TLVReader &reader) { return CHIP_ERROR_NOT_IMPLEMENTED; } +}// namespace for {{name}} +{{/chip_cluster_responses}} + +} +{{/chip_client_clusters}} + +} // namespace clusters +} // namespace app +} // namespace chip diff --git a/src/app/zap-templates/templates/app/command-cluster-objects.zapt b/src/app/zap-templates/templates/app/command-cluster-objects.zapt new file mode 100644 index 00000000000000..a36b366fe945b5 --- /dev/null +++ b/src/app/zap-templates/templates/app/command-cluster-objects.zapt @@ -0,0 +1,66 @@ +{{> header}} + +#pragma once + +#include +#include +#include +#include +#include +#include + +namespace chip { +namespace app { +namespace clusters { + +{{#chip_client_clusters}} + +// {{asUpperCamelCase name}} Cluster Commands +namespace {{asCamelCased name false}} { + +{{#chip_cluster_commands}} +namespace {{name}}CommandParams { + enum FieldId { + {{#chip_cluster_command_arguments}} + k{{asUpperCamelCase label}}FieldId = {{index}}, + {{/chip_cluster_command_arguments}} + }; + + struct Type { + public: + {{#chip_cluster_command_arguments}} + {{#if isArray}} + DataModel::List<{{#if_is_enum type}}{{type}}{{else}}{{asChipZapType type}}{{/if_is_enum}}> {{asLowerCamelCase label}}; + {{else}} + {{#if_is_enum type}}{{type}}{{else}}{{asChipZapType type}}{{/if_is_enum}} {{asLowerCamelCase label}}; + {{/if}} + {{/chip_cluster_command_arguments}} + + CHIP_ERROR Encode(TLV::TLVWriter &writer, uint64_t tag) const; + }; +}// namespace for {{name}} +{{/chip_cluster_commands}} + +{{#chip_cluster_responses}} +namespace {{name}}CommandParams { + enum FieldId { + {{#chip_cluster_response_arguments}} + k{{asUpperCamelCase label}}FieldId = {{index}}, + {{/chip_cluster_response_arguments}} + }; + + struct Type { + public: + // TODO + + CHIP_ERROR Decode(TLV::TLVWriter &writer, uint64_t tag) const; + }; +}// namespace for {{name}} +{{/chip_cluster_responses}} + +}// namespace for {{name}} +{{/chip_client_clusters}} + +} // namespace clusters +} // namespace app +} // namespace chip diff --git a/src/app/zap-templates/templates/app/helper.js b/src/app/zap-templates/templates/app/helper.js index 9fe1a4ae1857ca..81cf891e12de81 100644 --- a/src/app/zap-templates/templates/app/helper.js +++ b/src/app/zap-templates/templates/app/helper.js @@ -336,6 +336,72 @@ function asMEI(prefix, suffix) return cHelper.asHex((prefix << 16) + suffix, 8); } +function asChipZapType(type) +{ + if (StringHelper.isOctetString(type)) { + return 'chip::ByteSpan'; + } + + if (StringHelper.isCharString(type)) { + return 'Span'; + } + + switch (type) { + case 'BOOLEAN': + return 'bool'; + case 'INT8S': + return 'int8_t'; + case 'INT16S': + return 'int16_t'; + case 'INT24S': + return 'int24_t'; + case 'INT32S': + return 'int32_t'; + case 'INT64S': + return 'int64_t'; + case 'INT8U': + return 'uint8_t'; + case 'INT16U': + return 'uint16_t'; + case 'INT24U': + return 'uint24_t'; + case 'INT32U': + return 'uint32_t'; + case 'INT64U': + return 'uint64_t'; + } + + function fn(pkgId) + { + const options = { 'hash' : {} }; + return zclHelper.asUnderlyingZclType.call(this, type, options).then(zclType => { + const basicType = ChipTypesHelper.asBasicType(zclType); + switch (basicType) { + case 'bool': + case 'int8_t': + case 'uint8_t': + case 'int16_t': + case 'uint16_t': + case 'int24_t': + case 'uint24_t': + case 'int32_t': + case 'uint32_t': + case 'int64_t': + case 'uint64_t': + return basicType; + default: + return type + '::Type' + } + }) + } + + const promise = templateUtil.ensureZclPackageId(this).then(fn.bind(this)).catch(err => { + console.log(err); + throw err; + }); + return templateUtil.templatePromise(this.global, promise) +} + // // Module exports // @@ -349,3 +415,4 @@ exports.asLowerCamelCase = asLowerCamelCase; exports.asUpperCamelCase = asUpperCamelCase; exports.hasSpecificAttributes = hasSpecificAttributes; exports.asMEI = asMEI; +exports.asChipZapType = asChipZapType; diff --git a/src/controller/CHIPDevice.cpp b/src/controller/CHIPDevice.cpp index f23c4aa873d11e..425e20e074cc28 100644 --- a/src/controller/CHIPDevice.cpp +++ b/src/controller/CHIPDevice.cpp @@ -60,6 +60,8 @@ using namespace chip::Inet; using namespace chip::System; using namespace chip::Callback; +using namespace chip::app; + namespace chip { namespace Controller { CHIP_ERROR Device::LoadSecureSessionParametersIfNeeded(bool & didLoad) diff --git a/src/controller/CHIPDevice.h b/src/controller/CHIPDevice.h index b9a256f959810a..b5a406a6de83e0 100644 --- a/src/controller/CHIPDevice.h +++ b/src/controller/CHIPDevice.h @@ -443,6 +443,8 @@ class DLL_EXPORT Device : public Messaging::ExchangeDelegate, public SessionEsta CHIP_ERROR EstablishConnectivity(Callback::Callback * onConnection, Callback::Callback * onFailure); + DeviceControllerInteractionModelDelegate * GetInteractionModelDelegate() { return mpIMDelegate; }; + private: enum class ConnectionState { diff --git a/src/controller/CHIPDeviceController.cpp b/src/controller/CHIPDeviceController.cpp index f7d2e908445425..b8715b20663eac 100644 --- a/src/controller/CHIPDeviceController.cpp +++ b/src/controller/CHIPDeviceController.cpp @@ -1806,55 +1806,40 @@ void DeviceCommissioner::OnNodeDiscoveryComplete(const chip::Mdns::DiscoveredNod #endif // CHIP_DEVICE_CONFIG_ENABLE_COMMISSIONER_DISCOVERY -CHIP_ERROR DeviceControllerInteractionModelDelegate::CommandResponseStatus( - const app::CommandSender * apCommandSender, const Protocols::SecureChannel::GeneralStatusCode aGeneralCode, - const uint32_t aProtocolId, const uint16_t aProtocolCode, chip::EndpointId aEndpointId, const chip::ClusterId aClusterId, - chip::CommandId aCommandId, uint8_t aCommandIndex) +void DeviceControllerInteractionModelDelegate::OnResponse(const app::CommandSender * apCommandSender, + const app::CommandPath::Type & aPath, TLV::TLVReader * aData) { // Generally IM has more detailed errors than ember library, here we always use the, the actual handling of the // commands should implement full IMDelegate. // #6308 By implement app side IM delegate, we should be able to accept detailed error codes. // Note: The IMDefaultResponseCallback is a bridge to the old CallbackMgr before IM is landed, so it still accepts EmberAfStatus // instead of IM status code. - IMDefaultResponseCallback(apCommandSender, - (aProtocolCode == 0 && aGeneralCode == Protocols::SecureChannel::GeneralStatusCode::kSuccess) - ? EMBER_ZCL_STATUS_SUCCESS - : EMBER_ZCL_STATUS_FAILURE); - - return CHIP_NO_ERROR; -} - -CHIP_ERROR DeviceControllerInteractionModelDelegate::CommandResponseProtocolError(const app::CommandSender * apCommandSender, - uint8_t aCommandIndex) -{ - // Generally IM has more detailed errors than ember library, here we always use EMBER_ZCL_STATUS_FAILURE before #6308 is landed - // and the app can take care of these error codes, the actual handling of the commands should implement full IMDelegate. - // #6308: By implement app side IM delegate, we should be able to accept detailed error codes. - // Note: The IMDefaultResponseCallback is a bridge to the old CallbackMgr before IM is landed, so it still accepts EmberAfStatus - // instead of IM status code. - IMDefaultResponseCallback(apCommandSender, EMBER_ZCL_STATUS_FAILURE); - - return CHIP_NO_ERROR; + if (aData != nullptr) + { + // TODO: We are using const_cast, this line will be removed by implementing #8971 + chip::app::DispatchSingleClusterResponseCommand(aPath.clusterId, aPath.commandId, aPath.endpointId, *aData, + const_cast(apCommandSender)); + } + else + { + IMDefaultResponseCallback(apCommandSender, EMBER_ZCL_STATUS_SUCCESS); + } } -CHIP_ERROR DeviceControllerInteractionModelDelegate::CommandResponseError(const app::CommandSender * apCommandSender, - CHIP_ERROR aError) +void DeviceControllerInteractionModelDelegate::OnError(const app::CommandSender * apCommandSender, + Protocols::InteractionModel::Status aProtocolCode, CHIP_ERROR aError) { // Generally IM has more detailed errors than ember library, here we always use EMBER_ZCL_STATUS_FAILURE before #6308 is landed // and the app can take care of these error codes, the actual handling of the commands should implement full IMDelegate. // #6308: By implement app side IM delegate, we should be able to accept detailed error codes. // Note: The IMDefaultResponseCallback is a bridge to the old CallbackMgr before IM is landed, so it still accepts EmberAfStatus // instead of IM status code. - IMDefaultResponseCallback(apCommandSender, EMBER_ZCL_STATUS_FAILURE); - - return CHIP_NO_ERROR; + IMDefaultResponseCallback(apCommandSender, app::ToEmberAfStatus(aProtocolCode)); } -CHIP_ERROR DeviceControllerInteractionModelDelegate::CommandResponseProcessed(const app::CommandSender * apCommandSender) +void DeviceControllerInteractionModelDelegate::OnFinal(app::CommandSender * apCommandSender) { - // No thing is needed in this case. The success callback is called in CommandResponseStatus, and failure callback is called in - // CommandResponseStatus, CommandResponseProtocolError and CommandResponseError. - return CHIP_NO_ERROR; + return chip::Platform::Delete(apCommandSender); } void DeviceControllerInteractionModelDelegate::OnReportData(const app::ReadClient * apReadClient, const app::ClusterInfo & aPath, diff --git a/src/controller/CommandSenderAllocator.h b/src/controller/CommandSenderAllocator.h new file mode 100644 index 00000000000000..29434c7a9e3dc0 --- /dev/null +++ b/src/controller/CommandSenderAllocator.h @@ -0,0 +1,38 @@ +/* + * + * Copyright (c) 2020-2021 Project CHIP Authors + * All rights reserved. + * + * 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. + */ + +#pragma once + +#include + +#include +#include + +namespace chip { +namespace Controller { + +class CommandSenderPlatformDeleter +{ +public: + void operator()(app::CommandSender * commandSender) const { chip::Platform::Delete(commandSender); } +}; + +using CommandSenderHandler = std::unique_ptr; + +} // namespace Controller +} // namespace chip diff --git a/src/controller/DeviceControllerInteractionModelDelegate.h b/src/controller/DeviceControllerInteractionModelDelegate.h index a6564f9ee9bb42..07f20fae1f8df3 100644 --- a/src/controller/DeviceControllerInteractionModelDelegate.h +++ b/src/controller/DeviceControllerInteractionModelDelegate.h @@ -10,20 +10,20 @@ namespace Controller { * @brief * Used for make current OnSuccessCallback & OnFailureCallback works when interaction model landed, it will be removed * after #6308 is landed. + * + * TODO:(#8967) Implementation of CommandSender::Callback should be removed after switching to ClusterObjects. */ -class DeviceControllerInteractionModelDelegate : public chip::app::InteractionModelDelegate +class DeviceControllerInteractionModelDelegate : public chip::app::InteractionModelDelegate, + public chip::app::CommandSender::Callback { public: - CHIP_ERROR CommandResponseStatus(const app::CommandSender * apCommandSender, - const Protocols::SecureChannel::GeneralStatusCode aGeneralCode, const uint32_t aProtocolId, - const uint16_t aProtocolCode, chip::EndpointId aEndpointId, const chip::ClusterId aClusterId, - chip::CommandId aCommandId, uint8_t aCommandIndex) override; + void OnResponse(const app::CommandSender * apCommandSender, const app::CommandPath::Type & aPath, + TLV::TLVReader * aData) override; + void OnError(const app::CommandSender * apCommandSender, Protocols::InteractionModel::Status aInteractionModelStatus, + CHIP_ERROR aProtocolError) override; + void OnFinal(app::CommandSender * apCommandSender) override; - CHIP_ERROR CommandResponseProtocolError(const app::CommandSender * apCommandSender, uint8_t aCommandIndex) override; - - CHIP_ERROR CommandResponseError(const app::CommandSender * apCommandSender, CHIP_ERROR aError) override; - - CHIP_ERROR CommandResponseProcessed(const app::CommandSender * apCommandSender) override; + app::CommandSender * NewCommandSender(); void OnReportData(const app::ReadClient * apReadClient, const app::ClusterInfo & aPath, TLV::TLVReader * apData, Protocols::InteractionModel::Status status) override; diff --git a/src/controller/python/chip/interaction_model/Delegate.cpp b/src/controller/python/chip/interaction_model/Delegate.cpp index 55354fcef415d3..179de509acc4d6 100644 --- a/src/controller/python/chip/interaction_model/Delegate.cpp +++ b/src/controller/python/chip/interaction_model/Delegate.cpp @@ -32,52 +32,43 @@ namespace Controller { PythonInteractionModelDelegate gPythonInteractionModelDelegate; -CHIP_ERROR PythonInteractionModelDelegate::CommandResponseStatus(const CommandSender * apCommandSender, - const Protocols::SecureChannel::GeneralStatusCode aGeneralCode, - const uint32_t aProtocolId, const uint16_t aProtocolCode, - chip::EndpointId aEndpointId, const chip::ClusterId aClusterId, - chip::CommandId aCommandId, uint8_t aCommandIndex) +void PythonInteractionModelDelegate::OnResponse(const app::CommandSender * apCommandSender, const app::CommandPath::Type & aPath, + TLV::TLVReader * aData) { - CommandStatus status{ aProtocolId, aProtocolCode, aEndpointId, aClusterId, aCommandId, aCommandIndex }; + CommandStatus status{ Protocols::InteractionModel::Id.ToFullyQualifiedSpecForm(), + to_underlying(Protocols::InteractionModel::Status::Success), + aPath.endpointId, + aPath.clusterId, + aPath.commandId, + 1 }; if (commandResponseStatusFunct != nullptr) { commandResponseStatusFunct(reinterpret_cast(apCommandSender), &status, sizeof(status)); } - // For OpCred callbacks. - DeviceControllerInteractionModelDelegate::CommandResponseStatus(apCommandSender, aGeneralCode, aProtocolId, aProtocolCode, - aEndpointId, aClusterId, aCommandId, aCommandIndex); - return CHIP_NO_ERROR; -} -CHIP_ERROR PythonInteractionModelDelegate::CommandResponseProtocolError(const CommandSender * apCommandSender, - uint8_t aCommandIndex) -{ - if (commandResponseProtocolErrorFunct != nullptr) + DeviceControllerInteractionModelDelegate::OnResponse(apCommandSender, aPath, aData); + + if (commandResponseErrorFunct != nullptr) { - commandResponseProtocolErrorFunct(reinterpret_cast(apCommandSender), aCommandIndex); + commandResponseErrorFunct(reinterpret_cast(apCommandSender), CHIP_NO_ERROR.AsInteger()); } - DeviceControllerInteractionModelDelegate::CommandResponseProtocolError(apCommandSender, aCommandIndex); - return CHIP_NO_ERROR; } -CHIP_ERROR PythonInteractionModelDelegate::CommandResponseError(const CommandSender * apCommandSender, CHIP_ERROR aError) +void PythonInteractionModelDelegate::OnError(const app::CommandSender * apCommandSender, + Protocols::InteractionModel::Status aProtocolCode, CHIP_ERROR aError) { - if (commandResponseErrorFunct != nullptr) + CommandStatus status{ Protocols::InteractionModel::Id.ToFullyQualifiedSpecForm(), to_underlying(aProtocolCode), 0, 0, 0, 1 }; + + if (commandResponseStatusFunct != nullptr) { - commandResponseErrorFunct(reinterpret_cast(apCommandSender), aError.AsInteger()); + commandResponseStatusFunct(reinterpret_cast(apCommandSender), &status, sizeof(status)); } - if (aError != CHIP_NO_ERROR) + + if (commandResponseErrorFunct != nullptr) { - DeviceControllerInteractionModelDelegate::CommandResponseError(apCommandSender, aError); + commandResponseErrorFunct(reinterpret_cast(apCommandSender), aError.AsInteger()); } - return CHIP_NO_ERROR; -} - -CHIP_ERROR PythonInteractionModelDelegate::CommandResponseProcessed(const app::CommandSender * apCommandSender) -{ - this->CommandResponseError(apCommandSender, CHIP_NO_ERROR); - DeviceControllerInteractionModelDelegate::CommandResponseProcessed(apCommandSender); - return CHIP_NO_ERROR; + DeviceControllerInteractionModelDelegate::OnError(apCommandSender, aProtocolCode, aError); } CHIP_ERROR PythonInteractionModelDelegate::WriteResponseStatus(const app::WriteClient * apWriteClient, @@ -183,8 +174,8 @@ chip::ChipError::StorageType pychip_InteractionModel_GetCommandSenderHandle(uint { chip::app::CommandSender * commandSenderObj = nullptr; VerifyOrReturnError(commandSender != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger()); - CHIP_ERROR err = chip::app::InteractionModelEngine::GetInstance()->NewCommandSender(&commandSenderObj); - VerifyOrReturnError(err == CHIP_NO_ERROR, err.AsInteger()); + commandSenderObj = new chip::app::CommandSender(nullptr); + VerifyOrReturnError(commandSenderObj != nullptr, (CHIP_ERROR_NO_MEMORY).AsInteger()); *commandSender = reinterpret_cast(commandSenderObj); return CHIP_NO_ERROR.AsInteger(); } diff --git a/src/controller/python/chip/interaction_model/Delegate.h b/src/controller/python/chip/interaction_model/Delegate.h index 8cc1309f87a1d5..812591d34a62e5 100644 --- a/src/controller/python/chip/interaction_model/Delegate.h +++ b/src/controller/python/chip/interaction_model/Delegate.h @@ -95,16 +95,10 @@ void pychip_InteractionModelDelegate_SetOnWriteResponseStatusCallback(PythonInte class PythonInteractionModelDelegate : public chip::Controller::DeviceControllerInteractionModelDelegate { public: - CHIP_ERROR CommandResponseStatus(const app::CommandSender * apCommandSender, - const Protocols::SecureChannel::GeneralStatusCode aGeneralCode, const uint32_t aProtocolId, - const uint16_t aProtocolCode, chip::EndpointId aEndpointId, const chip::ClusterId aClusterId, - chip::CommandId aCommandId, uint8_t aCommandIndex) override; - - CHIP_ERROR CommandResponseProtocolError(const app::CommandSender * apCommandSender, uint8_t aCommandIndex) override; - - CHIP_ERROR CommandResponseError(const app::CommandSender * apCommandSender, CHIP_ERROR aError) override; - - CHIP_ERROR CommandResponseProcessed(const app::CommandSender * apCommandSender) override; + void OnResponse(const app::CommandSender * apCommandSender, const app::CommandPath::Type & aPath, + TLV::TLVReader * aData) override; + void OnError(const app::CommandSender * apCommandSender, Protocols::InteractionModel::Status aProtocolCode, + CHIP_ERROR aError) override; CHIP_ERROR WriteResponseStatus(const app::WriteClient * apWriteClient, const Protocols::SecureChannel::GeneralStatusCode aGeneralCode, const uint32_t aProtocolId, diff --git a/src/lib/support/CHIPMem.h b/src/lib/support/CHIPMem.h index f509a252eff798..221264f6c05869 100644 --- a/src/lib/support/CHIPMem.h +++ b/src/lib/support/CHIPMem.h @@ -27,6 +27,7 @@ #include #include +#include #include #include @@ -163,6 +164,21 @@ inline void Delete(T * p) MemoryFree(p); } +template +struct Deleter +{ + void operator()(T * p) { Delete(p); } +}; + +template +using UniquePtr = std::unique_ptr>; + +template +UniquePtr MakeUnique(Args &&... args) +{ + return std::move(UniquePtr(New(std::forward(args)...))); +} + // See MemoryDebugCheckPointer(). extern bool MemoryInternalCheckPointer(const void * p, size_t min_size); diff --git a/zzz_generated/all-clusters-app/zap-generated/cluster_objects_commands.cpp b/zzz_generated/all-clusters-app/zap-generated/cluster_objects_commands.cpp new file mode 100644 index 00000000000000..93855c49854709 --- /dev/null +++ b/zzz_generated/all-clusters-app/zap-generated/cluster_objects_commands.cpp @@ -0,0 +1,32 @@ +/* + * + * 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 "cluster_objects_commands.h" + +#include + +#pragma GCC diagnostic ignored "-Wstack-usage=" + +namespace chip { +namespace app { +namespace clusters { + +} // namespace clusters +} // namespace app +} // namespace chip diff --git a/zzz_generated/all-clusters-app/zap-generated/cluster_objects_commands.h b/zzz_generated/all-clusters-app/zap-generated/cluster_objects_commands.h new file mode 100644 index 00000000000000..b9f9a986dc7233 --- /dev/null +++ b/zzz_generated/all-clusters-app/zap-generated/cluster_objects_commands.h @@ -0,0 +1,35 @@ +/* + * + * 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 + +#pragma once + +#include +#include +#include +#include +#include +#include + +namespace chip { +namespace app { +namespace clusters { + +} // namespace clusters +} // namespace app +} // namespace chip diff --git a/zzz_generated/app-common/app-common/zap-generated/cluster-objects.cpp b/zzz_generated/app-common/app-common/zap-generated/cluster-objects.cpp new file mode 100644 index 00000000000000..e07a7a74ed694a --- /dev/null +++ b/zzz_generated/app-common/app-common/zap-generated/cluster-objects.cpp @@ -0,0 +1,1009 @@ +/* + * + * 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 + +#pragma GCC diagnostic ignored "-Wstack-usage=" + +namespace chip { +namespace app { +namespace clusters { +namespace AccountLogin { +} + +namespace ApplicationLauncher { +namespace ApplicationLauncherApp { +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kCatalogVendorIdFieldId), catalogVendorId)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kApplicationIdFieldId), applicationId)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +CHIP_ERROR Type::Decode(TLV::TLVReader & reader) +{ + CHIP_ERROR err; + TLV::TLVType outer; + err = reader.EnterContainer(outer); + ReturnErrorOnFailure(err); + while ((err = reader.Next()) == CHIP_NO_ERROR) + { + switch (chip::TLV::TagNumFromTag(reader.GetTag())) + { + case kCatalogVendorIdFieldId: + ReturnErrorOnFailure(DataModel::Decode(reader, catalogVendorId)); + break; + case kApplicationIdFieldId: + ReturnErrorOnFailure(DataModel::Decode(reader, applicationId)); + break; + default: + break; + } + } + VerifyOrReturnError(err == CHIP_END_OF_TLV, err); + ReturnErrorOnFailure(reader.ExitContainer(outer)); + return CHIP_NO_ERROR; +} +} // namespace ApplicationLauncherApp +} // namespace ApplicationLauncher + +namespace ContentLauncher { +namespace ContentLaunchAdditionalInfo { +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kNameFieldId), name)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kValueFieldId), value)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +CHIP_ERROR Type::Decode(TLV::TLVReader & reader) +{ + CHIP_ERROR err; + TLV::TLVType outer; + err = reader.EnterContainer(outer); + ReturnErrorOnFailure(err); + while ((err = reader.Next()) == CHIP_NO_ERROR) + { + switch (chip::TLV::TagNumFromTag(reader.GetTag())) + { + case kNameFieldId: + ReturnErrorOnFailure(DataModel::Decode(reader, name)); + break; + case kValueFieldId: + ReturnErrorOnFailure(DataModel::Decode(reader, value)); + break; + default: + break; + } + } + VerifyOrReturnError(err == CHIP_END_OF_TLV, err); + ReturnErrorOnFailure(reader.ExitContainer(outer)); + return CHIP_NO_ERROR; +} +} // namespace ContentLaunchAdditionalInfo +namespace ContentLaunchParamater { +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kTypeFieldId), type)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kValueFieldId), value)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kExternalIDListFieldId), externalIDList)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +CHIP_ERROR Type::Decode(TLV::TLVReader & reader) +{ + CHIP_ERROR err; + TLV::TLVType outer; + err = reader.EnterContainer(outer); + ReturnErrorOnFailure(err); + while ((err = reader.Next()) == CHIP_NO_ERROR) + { + switch (chip::TLV::TagNumFromTag(reader.GetTag())) + { + case kTypeFieldId: + uint8_t v; + ReturnErrorOnFailure(DataModel::Decode(reader, v)); + type = static_cast(v); + break; + case kValueFieldId: + ReturnErrorOnFailure(DataModel::Decode(reader, value)); + break; + case kExternalIDListFieldId: + return CHIP_ERROR_NOT_IMPLEMENTED; + default: + break; + } + } + VerifyOrReturnError(err == CHIP_END_OF_TLV, err); + ReturnErrorOnFailure(reader.ExitContainer(outer)); + return CHIP_NO_ERROR; +} +CHIP_ERROR DecodableType::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + return CHIP_ERROR_BAD_REQUEST; +} + +CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader) +{ + CHIP_ERROR err; + TLV::TLVType outer; + err = reader.EnterContainer(outer); + ReturnErrorOnFailure(err); + + while ((err = reader.Next()) == CHIP_NO_ERROR) + { + switch (chip::TLV::TagNumFromTag(reader.GetTag())) + { + case kTypeFieldId: + uint8_t v; + ReturnErrorOnFailure(DataModel::Decode(reader, v)); + type = static_cast(v); + break; + case kValueFieldId: + ReturnErrorOnFailure(DataModel::Decode(reader, value)); + break; + case kExternalIDListFieldId: + ReturnErrorOnFailure(DataModel::Decode(reader, externalIDList)); + break; + default: + break; + } + } + + VerifyOrReturnError(err == CHIP_END_OF_TLV, err); + ReturnErrorOnFailure(reader.ExitContainer(outer)); + return CHIP_NO_ERROR; +} +} // namespace ContentLaunchParamater +namespace ContentLaunchBrandingInformation { +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kProviderNameFieldId), providerName)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kBackgroundFieldId), background)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kLogoFieldId), logo)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kProgressBarFieldId), progressBar)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kSplashFieldId), splash)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kWaterMarkFieldId), waterMark)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +CHIP_ERROR Type::Decode(TLV::TLVReader & reader) +{ + CHIP_ERROR err; + TLV::TLVType outer; + err = reader.EnterContainer(outer); + ReturnErrorOnFailure(err); + while ((err = reader.Next()) == CHIP_NO_ERROR) + { + switch (chip::TLV::TagNumFromTag(reader.GetTag())) + { + case kProviderNameFieldId: + ReturnErrorOnFailure(DataModel::Decode(reader, providerName)); + break; + case kBackgroundFieldId: + ReturnErrorOnFailure(DataModel::Decode(reader, background)); + break; + case kLogoFieldId: + ReturnErrorOnFailure(DataModel::Decode(reader, logo)); + break; + case kProgressBarFieldId: + ReturnErrorOnFailure(DataModel::Decode(reader, progressBar)); + break; + case kSplashFieldId: + ReturnErrorOnFailure(DataModel::Decode(reader, splash)); + break; + case kWaterMarkFieldId: + ReturnErrorOnFailure(DataModel::Decode(reader, waterMark)); + break; + default: + break; + } + } + VerifyOrReturnError(err == CHIP_END_OF_TLV, err); + ReturnErrorOnFailure(reader.ExitContainer(outer)); + return CHIP_NO_ERROR; +} +} // namespace ContentLaunchBrandingInformation +namespace ContentLaunchDimension { +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kWidthFieldId), width)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kHeightFieldId), height)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kMetricFieldId), metric)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +CHIP_ERROR Type::Decode(TLV::TLVReader & reader) +{ + CHIP_ERROR err; + TLV::TLVType outer; + err = reader.EnterContainer(outer); + ReturnErrorOnFailure(err); + while ((err = reader.Next()) == CHIP_NO_ERROR) + { + switch (chip::TLV::TagNumFromTag(reader.GetTag())) + { + case kWidthFieldId: + ReturnErrorOnFailure(DataModel::Decode(reader, width)); + break; + case kHeightFieldId: + ReturnErrorOnFailure(DataModel::Decode(reader, height)); + break; + case kMetricFieldId: + uint8_t v; + ReturnErrorOnFailure(DataModel::Decode(reader, v)); + metric = static_cast(v); + break; + default: + break; + } + } + VerifyOrReturnError(err == CHIP_END_OF_TLV, err); + ReturnErrorOnFailure(reader.ExitContainer(outer)); + return CHIP_NO_ERROR; +} +} // namespace ContentLaunchDimension +namespace ContentLaunchStyleInformation { +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kImageUrlFieldId), imageUrl)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kColorFieldId), color)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kSizeFieldId), size)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +CHIP_ERROR Type::Decode(TLV::TLVReader & reader) +{ + CHIP_ERROR err; + TLV::TLVType outer; + err = reader.EnterContainer(outer); + ReturnErrorOnFailure(err); + while ((err = reader.Next()) == CHIP_NO_ERROR) + { + switch (chip::TLV::TagNumFromTag(reader.GetTag())) + { + case kImageUrlFieldId: + ReturnErrorOnFailure(DataModel::Decode(reader, imageUrl)); + break; + case kColorFieldId: + ReturnErrorOnFailure(DataModel::Decode(reader, color)); + break; + case kSizeFieldId: + ReturnErrorOnFailure(DataModel::Decode(reader, size)); + break; + default: + break; + } + } + VerifyOrReturnError(err == CHIP_END_OF_TLV, err); + ReturnErrorOnFailure(reader.ExitContainer(outer)); + return CHIP_NO_ERROR; +} +} // namespace ContentLaunchStyleInformation +} // namespace ContentLauncher + +namespace DoorLock { +} + +namespace GeneralCommissioning { +namespace BasicCommissioningInfoType { +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kFailSafeExpiryLengthMsFieldId), failSafeExpiryLengthMs)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +CHIP_ERROR Type::Decode(TLV::TLVReader & reader) +{ + CHIP_ERROR err; + TLV::TLVType outer; + err = reader.EnterContainer(outer); + ReturnErrorOnFailure(err); + while ((err = reader.Next()) == CHIP_NO_ERROR) + { + switch (chip::TLV::TagNumFromTag(reader.GetTag())) + { + case kFailSafeExpiryLengthMsFieldId: + ReturnErrorOnFailure(DataModel::Decode(reader, failSafeExpiryLengthMs)); + break; + default: + break; + } + } + VerifyOrReturnError(err == CHIP_END_OF_TLV, err); + ReturnErrorOnFailure(reader.ExitContainer(outer)); + return CHIP_NO_ERROR; +} +} // namespace BasicCommissioningInfoType +} // namespace GeneralCommissioning + +namespace Groups { +} + +namespace Identify { +} + +namespace KeypadInput { +} + +namespace MediaPlayback { +namespace MediaPlaybackPosition { +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kUpdatedAtFieldId), updatedAt)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kPositionFieldId), position)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +CHIP_ERROR Type::Decode(TLV::TLVReader & reader) +{ + CHIP_ERROR err; + TLV::TLVType outer; + err = reader.EnterContainer(outer); + ReturnErrorOnFailure(err); + while ((err = reader.Next()) == CHIP_NO_ERROR) + { + switch (chip::TLV::TagNumFromTag(reader.GetTag())) + { + case kUpdatedAtFieldId: + ReturnErrorOnFailure(DataModel::Decode(reader, updatedAt)); + break; + case kPositionFieldId: + ReturnErrorOnFailure(DataModel::Decode(reader, position)); + break; + default: + break; + } + } + VerifyOrReturnError(err == CHIP_END_OF_TLV, err); + ReturnErrorOnFailure(reader.ExitContainer(outer)); + return CHIP_NO_ERROR; +} +} // namespace MediaPlaybackPosition +} // namespace MediaPlayback + +namespace NetworkCommissioning { +namespace ThreadInterfaceScanResult { +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kDiscoveryResponseFieldId), discoveryResponse)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +CHIP_ERROR Type::Decode(TLV::TLVReader & reader) +{ + CHIP_ERROR err; + TLV::TLVType outer; + err = reader.EnterContainer(outer); + ReturnErrorOnFailure(err); + while ((err = reader.Next()) == CHIP_NO_ERROR) + { + switch (chip::TLV::TagNumFromTag(reader.GetTag())) + { + case kDiscoveryResponseFieldId: + ReturnErrorOnFailure(DataModel::Decode(reader, discoveryResponse)); + break; + default: + break; + } + } + VerifyOrReturnError(err == CHIP_END_OF_TLV, err); + ReturnErrorOnFailure(reader.ExitContainer(outer)); + return CHIP_NO_ERROR; +} +} // namespace ThreadInterfaceScanResult +namespace WiFiInterfaceScanResult { +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kSecurityFieldId), security)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kSsidFieldId), ssid)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kBssidFieldId), bssid)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kChannelFieldId), channel)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kFrequencyBandFieldId), frequencyBand)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +CHIP_ERROR Type::Decode(TLV::TLVReader & reader) +{ + CHIP_ERROR err; + TLV::TLVType outer; + err = reader.EnterContainer(outer); + ReturnErrorOnFailure(err); + while ((err = reader.Next()) == CHIP_NO_ERROR) + { + switch (chip::TLV::TagNumFromTag(reader.GetTag())) + { + case kSecurityFieldId: + ReturnErrorOnFailure(DataModel::Decode(reader, security)); + break; + case kSsidFieldId: + ReturnErrorOnFailure(DataModel::Decode(reader, ssid)); + break; + case kBssidFieldId: + ReturnErrorOnFailure(DataModel::Decode(reader, bssid)); + break; + case kChannelFieldId: + ReturnErrorOnFailure(DataModel::Decode(reader, channel)); + break; + case kFrequencyBandFieldId: + ReturnErrorOnFailure(DataModel::Decode(reader, frequencyBand)); + break; + default: + break; + } + } + VerifyOrReturnError(err == CHIP_END_OF_TLV, err); + ReturnErrorOnFailure(reader.ExitContainer(outer)); + return CHIP_NO_ERROR; +} +} // namespace WiFiInterfaceScanResult +} // namespace NetworkCommissioning + +namespace OtaSoftwareUpdateProvider { +} + +namespace OperationalCredentials { +namespace FabricDescriptor { +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kFabricIndexFieldId), fabricIndex)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kRootPublicKeyFieldId), rootPublicKey)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kVendorIdFieldId), vendorId)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kFabricIdFieldId), fabricId)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kNodeIdFieldId), nodeId)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kLabelFieldId), label)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +CHIP_ERROR Type::Decode(TLV::TLVReader & reader) +{ + CHIP_ERROR err; + TLV::TLVType outer; + err = reader.EnterContainer(outer); + ReturnErrorOnFailure(err); + while ((err = reader.Next()) == CHIP_NO_ERROR) + { + switch (chip::TLV::TagNumFromTag(reader.GetTag())) + { + case kFabricIndexFieldId: + ReturnErrorOnFailure(DataModel::Decode(reader, fabricIndex)); + break; + case kRootPublicKeyFieldId: + ReturnErrorOnFailure(DataModel::Decode(reader, rootPublicKey)); + break; + case kVendorIdFieldId: + ReturnErrorOnFailure(DataModel::Decode(reader, vendorId)); + break; + case kFabricIdFieldId: + ReturnErrorOnFailure(DataModel::Decode(reader, fabricId)); + break; + case kNodeIdFieldId: + ReturnErrorOnFailure(DataModel::Decode(reader, nodeId)); + break; + case kLabelFieldId: + ReturnErrorOnFailure(DataModel::Decode(reader, label)); + break; + default: + break; + } + } + VerifyOrReturnError(err == CHIP_END_OF_TLV, err); + ReturnErrorOnFailure(reader.ExitContainer(outer)); + return CHIP_NO_ERROR; +} +} // namespace FabricDescriptor +namespace NOCStruct { +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kFabricIndexFieldId), fabricIndex)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kNocFieldId), noc)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +CHIP_ERROR Type::Decode(TLV::TLVReader & reader) +{ + CHIP_ERROR err; + TLV::TLVType outer; + err = reader.EnterContainer(outer); + ReturnErrorOnFailure(err); + while ((err = reader.Next()) == CHIP_NO_ERROR) + { + switch (chip::TLV::TagNumFromTag(reader.GetTag())) + { + case kFabricIndexFieldId: + ReturnErrorOnFailure(DataModel::Decode(reader, fabricIndex)); + break; + case kNocFieldId: + ReturnErrorOnFailure(DataModel::Decode(reader, noc)); + break; + default: + break; + } + } + VerifyOrReturnError(err == CHIP_END_OF_TLV, err); + ReturnErrorOnFailure(reader.ExitContainer(outer)); + return CHIP_NO_ERROR; +} +} // namespace NOCStruct +} // namespace OperationalCredentials + +namespace Scenes { +} + +namespace TvChannel { +namespace TvChannelInfo { +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kMajorNumberFieldId), majorNumber)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kMinorNumberFieldId), minorNumber)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kNameFieldId), name)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kCallSignFieldId), callSign)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kAffiliateCallSignFieldId), affiliateCallSign)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +CHIP_ERROR Type::Decode(TLV::TLVReader & reader) +{ + CHIP_ERROR err; + TLV::TLVType outer; + err = reader.EnterContainer(outer); + ReturnErrorOnFailure(err); + while ((err = reader.Next()) == CHIP_NO_ERROR) + { + switch (chip::TLV::TagNumFromTag(reader.GetTag())) + { + case kMajorNumberFieldId: + ReturnErrorOnFailure(DataModel::Decode(reader, majorNumber)); + break; + case kMinorNumberFieldId: + ReturnErrorOnFailure(DataModel::Decode(reader, minorNumber)); + break; + case kNameFieldId: + ReturnErrorOnFailure(DataModel::Decode(reader, name)); + break; + case kCallSignFieldId: + ReturnErrorOnFailure(DataModel::Decode(reader, callSign)); + break; + case kAffiliateCallSignFieldId: + ReturnErrorOnFailure(DataModel::Decode(reader, affiliateCallSign)); + break; + default: + break; + } + } + VerifyOrReturnError(err == CHIP_END_OF_TLV, err); + ReturnErrorOnFailure(reader.ExitContainer(outer)); + return CHIP_NO_ERROR; +} +} // namespace TvChannelInfo +namespace TvChannelLineupInfo { +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kOperatorNameFieldId), operatorName)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kLineupNameFieldId), lineupName)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kPostalCodeFieldId), postalCode)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kLineupInfoTypeFieldId), lineupInfoType)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +CHIP_ERROR Type::Decode(TLV::TLVReader & reader) +{ + CHIP_ERROR err; + TLV::TLVType outer; + err = reader.EnterContainer(outer); + ReturnErrorOnFailure(err); + while ((err = reader.Next()) == CHIP_NO_ERROR) + { + switch (chip::TLV::TagNumFromTag(reader.GetTag())) + { + case kOperatorNameFieldId: + ReturnErrorOnFailure(DataModel::Decode(reader, operatorName)); + break; + case kLineupNameFieldId: + ReturnErrorOnFailure(DataModel::Decode(reader, lineupName)); + break; + case kPostalCodeFieldId: + ReturnErrorOnFailure(DataModel::Decode(reader, postalCode)); + break; + case kLineupInfoTypeFieldId: + uint8_t v; + ReturnErrorOnFailure(DataModel::Decode(reader, v)); + lineupInfoType = static_cast(v); + break; + default: + break; + } + } + VerifyOrReturnError(err == CHIP_END_OF_TLV, err); + ReturnErrorOnFailure(reader.ExitContainer(outer)); + return CHIP_NO_ERROR; +} +} // namespace TvChannelLineupInfo +} // namespace TvChannel + +namespace TargetNavigator { +namespace NavigateTargetTargetInfo { +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kIdentifierFieldId), identifier)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kNameFieldId), name)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +CHIP_ERROR Type::Decode(TLV::TLVReader & reader) +{ + CHIP_ERROR err; + TLV::TLVType outer; + err = reader.EnterContainer(outer); + ReturnErrorOnFailure(err); + while ((err = reader.Next()) == CHIP_NO_ERROR) + { + switch (chip::TLV::TagNumFromTag(reader.GetTag())) + { + case kIdentifierFieldId: + ReturnErrorOnFailure(DataModel::Decode(reader, identifier)); + break; + case kNameFieldId: + ReturnErrorOnFailure(DataModel::Decode(reader, name)); + break; + default: + break; + } + } + VerifyOrReturnError(err == CHIP_END_OF_TLV, err); + ReturnErrorOnFailure(reader.ExitContainer(outer)); + return CHIP_NO_ERROR; +} +} // namespace NavigateTargetTargetInfo +} // namespace TargetNavigator + +namespace TestCluster { +namespace SimpleStruct { +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kAFieldId), a)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kBFieldId), b)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kCFieldId), c)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kDFieldId), d)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kEFieldId), e)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +CHIP_ERROR Type::Decode(TLV::TLVReader & reader) +{ + CHIP_ERROR err; + TLV::TLVType outer; + err = reader.EnterContainer(outer); + ReturnErrorOnFailure(err); + while ((err = reader.Next()) == CHIP_NO_ERROR) + { + switch (chip::TLV::TagNumFromTag(reader.GetTag())) + { + case kAFieldId: + ReturnErrorOnFailure(DataModel::Decode(reader, a)); + break; + case kBFieldId: + ReturnErrorOnFailure(DataModel::Decode(reader, b)); + break; + case kCFieldId: + uint8_t v; + ReturnErrorOnFailure(DataModel::Decode(reader, v)); + c = static_cast(v); + break; + case kDFieldId: + ReturnErrorOnFailure(DataModel::Decode(reader, d)); + break; + case kEFieldId: + ReturnErrorOnFailure(DataModel::Decode(reader, e)); + break; + default: + break; + } + } + VerifyOrReturnError(err == CHIP_END_OF_TLV, err); + ReturnErrorOnFailure(reader.ExitContainer(outer)); + return CHIP_NO_ERROR; +} +} // namespace SimpleStruct +namespace NestedStruct { +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kAFieldId), a)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kBFieldId), b)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kCFieldId), c)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +CHIP_ERROR Type::Decode(TLV::TLVReader & reader) +{ + CHIP_ERROR err; + TLV::TLVType outer; + err = reader.EnterContainer(outer); + ReturnErrorOnFailure(err); + while ((err = reader.Next()) == CHIP_NO_ERROR) + { + switch (chip::TLV::TagNumFromTag(reader.GetTag())) + { + case kAFieldId: + ReturnErrorOnFailure(DataModel::Decode(reader, a)); + break; + case kBFieldId: + ReturnErrorOnFailure(DataModel::Decode(reader, b)); + break; + case kCFieldId: + ReturnErrorOnFailure(DataModel::Decode(reader, c)); + break; + default: + break; + } + } + VerifyOrReturnError(err == CHIP_END_OF_TLV, err); + ReturnErrorOnFailure(reader.ExitContainer(outer)); + return CHIP_NO_ERROR; +} +} // namespace NestedStruct +namespace NestedStructList { +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kAFieldId), a)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kBFieldId), b)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kCFieldId), c)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kDFieldId), d)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kEFieldId), e)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kFFieldId), f)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kGFieldId), g)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +CHIP_ERROR Type::Decode(TLV::TLVReader & reader) +{ + CHIP_ERROR err; + TLV::TLVType outer; + err = reader.EnterContainer(outer); + ReturnErrorOnFailure(err); + while ((err = reader.Next()) == CHIP_NO_ERROR) + { + switch (chip::TLV::TagNumFromTag(reader.GetTag())) + { + case kAFieldId: + ReturnErrorOnFailure(DataModel::Decode(reader, a)); + break; + case kBFieldId: + ReturnErrorOnFailure(DataModel::Decode(reader, b)); + break; + case kCFieldId: + ReturnErrorOnFailure(DataModel::Decode(reader, c)); + break; + case kDFieldId: + return CHIP_ERROR_NOT_IMPLEMENTED; + case kEFieldId: + return CHIP_ERROR_NOT_IMPLEMENTED; + case kFFieldId: + return CHIP_ERROR_NOT_IMPLEMENTED; + case kGFieldId: + return CHIP_ERROR_NOT_IMPLEMENTED; + default: + break; + } + } + VerifyOrReturnError(err == CHIP_END_OF_TLV, err); + ReturnErrorOnFailure(reader.ExitContainer(outer)); + return CHIP_NO_ERROR; +} +CHIP_ERROR DecodableType::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + return CHIP_ERROR_BAD_REQUEST; +} + +CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader) +{ + CHIP_ERROR err; + TLV::TLVType outer; + err = reader.EnterContainer(outer); + ReturnErrorOnFailure(err); + + while ((err = reader.Next()) == CHIP_NO_ERROR) + { + switch (chip::TLV::TagNumFromTag(reader.GetTag())) + { + case kAFieldId: + ReturnErrorOnFailure(DataModel::Decode(reader, a)); + break; + case kBFieldId: + ReturnErrorOnFailure(DataModel::Decode(reader, b)); + break; + case kCFieldId: + ReturnErrorOnFailure(DataModel::Decode(reader, c)); + break; + case kDFieldId: + ReturnErrorOnFailure(DataModel::Decode(reader, d)); + break; + case kEFieldId: + ReturnErrorOnFailure(DataModel::Decode(reader, e)); + break; + case kFFieldId: + ReturnErrorOnFailure(DataModel::Decode(reader, f)); + break; + case kGFieldId: + ReturnErrorOnFailure(DataModel::Decode(reader, g)); + break; + default: + break; + } + } + + VerifyOrReturnError(err == CHIP_END_OF_TLV, err); + ReturnErrorOnFailure(reader.ExitContainer(outer)); + return CHIP_NO_ERROR; +} +} // namespace NestedStructList +namespace DoubleNestedStructList { +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kAFieldId), a)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +CHIP_ERROR Type::Decode(TLV::TLVReader & reader) +{ + CHIP_ERROR err; + TLV::TLVType outer; + err = reader.EnterContainer(outer); + ReturnErrorOnFailure(err); + while ((err = reader.Next()) == CHIP_NO_ERROR) + { + switch (chip::TLV::TagNumFromTag(reader.GetTag())) + { + case kAFieldId: + return CHIP_ERROR_NOT_IMPLEMENTED; + default: + break; + } + } + VerifyOrReturnError(err == CHIP_END_OF_TLV, err); + ReturnErrorOnFailure(reader.ExitContainer(outer)); + return CHIP_NO_ERROR; +} +CHIP_ERROR DecodableType::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + return CHIP_ERROR_BAD_REQUEST; +} + +CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader) +{ + CHIP_ERROR err; + TLV::TLVType outer; + err = reader.EnterContainer(outer); + ReturnErrorOnFailure(err); + + while ((err = reader.Next()) == CHIP_NO_ERROR) + { + switch (chip::TLV::TagNumFromTag(reader.GetTag())) + { + case kAFieldId: + ReturnErrorOnFailure(DataModel::Decode(reader, a)); + break; + default: + break; + } + } + + VerifyOrReturnError(err == CHIP_END_OF_TLV, err); + ReturnErrorOnFailure(reader.ExitContainer(outer)); + return CHIP_NO_ERROR; +} +} // namespace DoubleNestedStructList +namespace TestListStructOctet { +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kFabricIndexFieldId), fabricIndex)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kOperationalCertFieldId), operationalCert)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +CHIP_ERROR Type::Decode(TLV::TLVReader & reader) +{ + CHIP_ERROR err; + TLV::TLVType outer; + err = reader.EnterContainer(outer); + ReturnErrorOnFailure(err); + while ((err = reader.Next()) == CHIP_NO_ERROR) + { + switch (chip::TLV::TagNumFromTag(reader.GetTag())) + { + case kFabricIndexFieldId: + ReturnErrorOnFailure(DataModel::Decode(reader, fabricIndex)); + break; + case kOperationalCertFieldId: + ReturnErrorOnFailure(DataModel::Decode(reader, operationalCert)); + break; + default: + break; + } + } + VerifyOrReturnError(err == CHIP_END_OF_TLV, err); + ReturnErrorOnFailure(reader.ExitContainer(outer)); + return CHIP_NO_ERROR; +} +} // namespace TestListStructOctet +} // namespace TestCluster + +} // namespace clusters +} // namespace app +} // namespace chip diff --git a/zzz_generated/app-common/app-common/zap-generated/cluster-objects.h b/zzz_generated/app-common/app-common/zap-generated/cluster-objects.h new file mode 100644 index 00000000000000..f6091d6fa6b7a4 --- /dev/null +++ b/zzz_generated/app-common/app-common/zap-generated/cluster-objects.h @@ -0,0 +1,1529 @@ +/* + * + * 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 + +#pragma once + +#include +#include +#include +#include +#include + +namespace chip { +namespace app { +namespace clusters { + +namespace AccountLogin { +constexpr ClusterId kClusterId = 0x50E; + +} // namespace AccountLogin +namespace AdministratorCommissioning { +constexpr ClusterId kClusterId = 0x3C; +// Enum for StatusCode +enum class StatusCode : uint8_t +{ + STATUS_CODE_SUCCESS = 0x00, + STATUS_CODE_BUSY = 0x01, + STATUS_CODE_GENERAL_ERROR = 0x02, +}; + +} // namespace AdministratorCommissioning +namespace ApplicationBasic { +constexpr ClusterId kClusterId = 0x50D; +// Enum for ApplicationBasicStatus +enum class ApplicationBasicStatus : uint8_t +{ + APPLICATION_BASIC_STATUS_STOPPED = 0x00, + APPLICATION_BASIC_STATUS_ACTIVE_VISIBLE_FOCUS = 0x01, + APPLICATION_BASIC_STATUS_ACTIVE_HIDDEN = 0x02, + APPLICATION_BASIC_STATUS_ACTIVE_VISIBLE_NOT_FOCUS = 0x03, +}; + +} // namespace ApplicationBasic +namespace ApplicationLauncher { +constexpr ClusterId kClusterId = 0x50C; +// Enum for ApplicationLauncherStatus +enum class ApplicationLauncherStatus : uint8_t +{ + APPLICATION_LAUNCHER_STATUS_SUCCESS = 0x00, + APPLICATION_LAUNCHER_STATUS_APP_NOT_AVAILABLE = 0x01, + APPLICATION_LAUNCHER_STATUS_SYSTEM_BUSY = 0x02, +}; + +namespace ApplicationLauncherApp { +enum FieldId +{ + kCatalogVendorIdFieldId = 0, + kApplicationIdFieldId = 1, +}; + +struct Type +{ +public: + uint16_t catalogVendorId; + Span applicationId; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; + CHIP_ERROR Decode(TLV::TLVReader & reader); +}; + +} // namespace ApplicationLauncherApp + +} // namespace ApplicationLauncher +namespace AudioOutput { +constexpr ClusterId kClusterId = 0x50B; +// Enum for AudioOutputType +enum class AudioOutputType : uint8_t +{ + AUDIO_OUTPUT_TYPE_HDMI = 0x00, + AUDIO_OUTPUT_TYPE_BT = 0x01, + AUDIO_OUTPUT_TYPE_OPTICAL = 0x02, + AUDIO_OUTPUT_TYPE_HEADPHONE = 0x03, + AUDIO_OUTPUT_TYPE_INTERNAL = 0x04, + AUDIO_OUTPUT_TYPE_OTHER = 0x05, +}; + +namespace AudioOutputInfo { +enum FieldId +{ + kIndexFieldId = 0, + kOutputTypeFieldId = 1, + kNameFieldId = 2, +}; + +struct Type +{ +public: + uint8_t index; + AudioOutputType outputType; + chip::ByteSpan name; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; + CHIP_ERROR Decode(TLV::TLVReader & reader); +}; + +} // namespace AudioOutputInfo + +} // namespace AudioOutput +namespace BarrierControl { +constexpr ClusterId kClusterId = 0x103; + +} // namespace BarrierControl +namespace Basic { +constexpr ClusterId kClusterId = 0x28; + +} // namespace Basic +namespace BinaryInputBasic { +constexpr ClusterId kClusterId = 0x0F; + +} // namespace BinaryInputBasic +namespace Binding { +constexpr ClusterId kClusterId = 0xF000; + +} // namespace Binding +namespace BridgedDeviceBasic { +constexpr ClusterId kClusterId = 0x39; + +} // namespace BridgedDeviceBasic +namespace ColorControl { +constexpr ClusterId kClusterId = 0x300; + +} // namespace ColorControl +namespace ContentLauncher { +constexpr ClusterId kClusterId = 0x50A; +// Enum for ContentLaunchMetricType +enum class ContentLaunchMetricType : uint8_t +{ + CONTENT_LAUNCH_METRIC_TYPE_PIXELS = 0x00, + CONTENT_LAUNCH_METRIC_TYPE_PERCENTAGE = 0x01, +}; +// Enum for ContentLaunchParameterEnum +enum class ContentLaunchParameterEnum : uint8_t +{ + CONTENT_LAUNCH_PARAMETER_ENUM_ACTOR = 0x00, + CONTENT_LAUNCH_PARAMETER_ENUM_CHANNEL = 0x01, + CONTENT_LAUNCH_PARAMETER_ENUM_CHARACTER = 0x02, + CONTENT_LAUNCH_PARAMETER_ENUM_EVENT = 0x03, + CONTENT_LAUNCH_PARAMETER_ENUM_FRANCHISE = 0x04, + CONTENT_LAUNCH_PARAMETER_ENUM_GENRE = 0x05, + CONTENT_LAUNCH_PARAMETER_ENUM_LEAGUE = 0x06, + CONTENT_LAUNCH_PARAMETER_ENUM_POPULARITY = 0x07, + CONTENT_LAUNCH_PARAMETER_ENUM_SPORT = 0x08, + CONTENT_LAUNCH_PARAMETER_ENUM_SPORTS_TEAM = 0x09, + CONTENT_LAUNCH_PARAMETER_ENUM_VIDEO = 0x0A, +}; +// Enum for ContentLaunchStatus +enum class ContentLaunchStatus : uint8_t +{ + CONTENT_LAUNCH_STATUS_SUCCESS = 0x00, + CONTENT_LAUNCH_STATUS_URL_NOT_AVAILABLE = 0x01, + CONTENT_LAUNCH_STATUS_AUTH_FAILED = 0x02, +}; +// Enum for ContentLaunchStreamingType +enum class ContentLaunchStreamingType : uint8_t +{ + CONTENT_LAUNCH_STREAMING_TYPE_DASH = 0x00, + CONTENT_LAUNCH_STREAMING_TYPE_HLS = 0x01, +}; + +namespace ContentLaunchAdditionalInfo { +enum FieldId +{ + kNameFieldId = 0, + kValueFieldId = 1, +}; + +struct Type +{ +public: + Span name; + Span value; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; + CHIP_ERROR Decode(TLV::TLVReader & reader); +}; + +} // namespace ContentLaunchAdditionalInfo +namespace ContentLaunchParamater { +enum FieldId +{ + kTypeFieldId = 0, + kValueFieldId = 1, + kExternalIDListFieldId = 2, +}; + +struct Type +{ +public: + ContentLaunchParameterEnum type; + Span value; + DataModel::List externalIDList; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; + CHIP_ERROR Decode(TLV::TLVReader & reader); +}; + +struct DecodableType +{ +public: + ContentLaunchParameterEnum type; + Span value; + DataModel::DecodableList externalIDList; + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; + CHIP_ERROR Decode(TLV::TLVReader & reader); +}; + +} // namespace ContentLaunchParamater +namespace ContentLaunchBrandingInformation { +enum FieldId +{ + kProviderNameFieldId = 0, + kBackgroundFieldId = 1, + kLogoFieldId = 2, + kProgressBarFieldId = 3, + kSplashFieldId = 4, + kWaterMarkFieldId = 5, +}; + +struct Type +{ +public: + Span providerName; + uint8_t background; + uint8_t logo; + uint8_t progressBar; + uint8_t splash; + uint8_t waterMark; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; + CHIP_ERROR Decode(TLV::TLVReader & reader); +}; + +} // namespace ContentLaunchBrandingInformation +namespace ContentLaunchDimension { +enum FieldId +{ + kWidthFieldId = 0, + kHeightFieldId = 1, + kMetricFieldId = 2, +}; + +struct Type +{ +public: + Span width; + Span height; + ContentLaunchMetricType metric; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; + CHIP_ERROR Decode(TLV::TLVReader & reader); +}; + +} // namespace ContentLaunchDimension +namespace ContentLaunchStyleInformation { +enum FieldId +{ + kImageUrlFieldId = 0, + kColorFieldId = 1, + kSizeFieldId = 2, +}; + +struct Type +{ +public: + Span imageUrl; + Span color; + uint8_t size; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; + CHIP_ERROR Decode(TLV::TLVReader & reader); +}; + +} // namespace ContentLaunchStyleInformation + +} // namespace ContentLauncher +namespace Descriptor { +constexpr ClusterId kClusterId = 0x1D; + +namespace DeviceType { +enum FieldId +{ + kTypeFieldId = 0, + kRevisionFieldId = 1, +}; + +struct Type +{ +public: + uint32_t type; + uint16_t revision; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; + CHIP_ERROR Decode(TLV::TLVReader & reader); +}; + +} // namespace DeviceType + +} // namespace Descriptor +namespace DiagnosticLogs { +constexpr ClusterId kClusterId = 0x32; +// Enum for LogsIntent +enum class LogsIntent : uint8_t +{ + LOGS_INTENT_END_USER_SUPPORT = 0x00, + LOGS_INTENT_NETWORK_DIAG = 0x01, + LOGS_INTENT_CRASH_LOGS = 0x02, +}; +// Enum for LogsStatus +enum class LogsStatus : uint8_t +{ + LOGS_STATUS_SUCCESS = 0x00, + LOGS_STATUS_EXHAUSTED = 0x01, + LOGS_STATUS_NO_LOGS = 0x02, + LOGS_STATUS_BUSY = 0x03, + LOGS_STATUS_DENIED = 0x04, +}; +// Enum for LogsTransferProtocol +enum class LogsTransferProtocol : uint8_t +{ + LOGS_TRANSFER_PROTOCOL_RESPONSE_PAYLOAD = 0x00, + LOGS_TRANSFER_PROTOCOL_BDX = 0x01, +}; + +} // namespace DiagnosticLogs +namespace DoorLock { +constexpr ClusterId kClusterId = 0x101; + +} // namespace DoorLock +namespace ElectricalMeasurement { +constexpr ClusterId kClusterId = 0xB04; + +} // namespace ElectricalMeasurement +namespace EthernetNetworkDiagnostics { +constexpr ClusterId kClusterId = 0x37; +// Enum for PHYRateType +enum class PHYRateType : uint8_t +{ + PHY_RATE_TYPE_10_M = 0x00, + PHY_RATE_TYPE_100_M = 0x01, + PHY_RATE_TYPE_1000_M = 0x02, + PHY_RATE_TYPE_2__5_G = 0x03, + PHY_RATE_TYPE_5_G = 0x04, + PHY_RATE_TYPE_10_G = 0x05, + PHY_RATE_TYPE_40_G = 0x06, + PHY_RATE_TYPE_100_G = 0x07, + PHY_RATE_TYPE_200_G = 0x08, + PHY_RATE_TYPE_400_G = 0x09, +}; + +} // namespace EthernetNetworkDiagnostics +namespace FixedLabel { +constexpr ClusterId kClusterId = 0x40; + +namespace LabelStruct { +enum FieldId +{ + kLabelFieldId = 0, + kValueFieldId = 1, +}; + +struct Type +{ +public: + chip::ByteSpan label; + chip::ByteSpan value; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; + CHIP_ERROR Decode(TLV::TLVReader & reader); +}; + +} // namespace LabelStruct + +} // namespace FixedLabel +namespace FlowMeasurement { +constexpr ClusterId kClusterId = 0x404; + +} // namespace FlowMeasurement +namespace GeneralCommissioning { +constexpr ClusterId kClusterId = 0x30; +// Enum for GeneralCommissioningError +enum class GeneralCommissioningError : uint8_t +{ + GENERAL_COMMISSIONING_ERROR_OK = 0x00, + GENERAL_COMMISSIONING_ERROR_VALUE_OUTSIDE_RANGE = 0x01, + GENERAL_COMMISSIONING_ERROR_INVALID_AUTHENTICATION = 0x02, +}; +// Enum for RegulatoryLocationType +enum class RegulatoryLocationType : uint8_t +{ + REGULATORY_LOCATION_TYPE_INDOOR = 0x00, + REGULATORY_LOCATION_TYPE_OUTDOOR = 0x01, + REGULATORY_LOCATION_TYPE_INDOOR_OUTDOOR = 0x02, +}; + +namespace BasicCommissioningInfoType { +enum FieldId +{ + kFailSafeExpiryLengthMsFieldId = 0, +}; + +struct Type +{ +public: + uint32_t failSafeExpiryLengthMs; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; + CHIP_ERROR Decode(TLV::TLVReader & reader); +}; + +} // namespace BasicCommissioningInfoType + +} // namespace GeneralCommissioning +namespace GeneralDiagnostics { +constexpr ClusterId kClusterId = 0x33; +// Enum for BootReasonType +enum class BootReasonType : uint8_t +{ + BOOT_REASON_TYPE_UNSPECIFIED = 0x00, + BOOT_REASON_TYPE_POWER_ON_REBOOT = 0x01, + BOOT_REASON_TYPE_BROWN_OUT_RESET = 0x02, + BOOT_REASON_TYPE_SOFTWARE_WATCHDOG_RESET = 0x03, + BOOT_REASON_TYPE_HARDWARE_WATCHDOG_RESET = 0x04, + BOOT_REASON_TYPE_SOFTWARE_UPDATE_COMPLETED = 0x05, + BOOT_REASON_TYPE_SOFTWARE_RESET = 0x06, +}; +// Enum for HardwareFaultType +enum class HardwareFaultType : uint8_t +{ + HARDWARE_FAULT_TYPE_UNSPECIFIED = 0x00, + HARDWARE_FAULT_TYPE_RADIO = 0x01, + HARDWARE_FAULT_TYPE_SENSOR = 0x02, + HARDWARE_FAULT_TYPE_RESETTABLE_OVER_TEMP = 0x03, + HARDWARE_FAULT_TYPE_NON_RESETTABLE_OVER_TEMP = 0x04, + HARDWARE_FAULT_TYPE_POWER_SOURCE = 0x05, + HARDWARE_FAULT_TYPE_VISUAL_DISPLAY_FAULT = 0x06, + HARDWARE_FAULT_TYPE_AUDIO_OUTPUT_FAULT = 0x07, + HARDWARE_FAULT_TYPE_USER_INTERFACE_FAULT = 0x08, + HARDWARE_FAULT_TYPE_NON_VOLATILE_MEMORY_ERROR = 0x09, + HARDWARE_FAULT_TYPE_TAMPER_DETECTED = 0x0A, +}; +// Enum for InterfaceType +enum class InterfaceType : uint8_t +{ + INTERFACE_TYPE_UNSPECIFIED = 0x00, + INTERFACE_TYPE_WI_FI = 0x01, + INTERFACE_TYPE_ETHERNET = 0x02, + INTERFACE_TYPE_CELLULAR = 0x03, + INTERFACE_TYPE_THREAD = 0x04, +}; +// Enum for NetworkFaultType +enum class NetworkFaultType : uint8_t +{ + NETWORK_FAULT_TYPE_UNSPECIFIED = 0x00, + NETWORK_FAULT_TYPE_HARDWARE_FAILURE = 0x01, + NETWORK_FAULT_TYPE_NETWORK_JAMMED = 0x02, + NETWORK_FAULT_TYPE_CONNECTION_FAILED = 0x03, +}; +// Enum for RadioFaultType +enum class RadioFaultType : uint8_t +{ + RADIO_FAULT_TYPE_UNSPECIFIED = 0x00, + RADIO_FAULT_TYPE_WI_FI_FAULT = 0x01, + RADIO_FAULT_TYPE_CELLULAR_FAULT = 0x02, + RADIO_FAULT_TYPE_THREAD_FAULT = 0x03, + RADIO_FAULT_TYPE_NFC_FAULT = 0x04, + RADIO_FAULT_TYPE_BLE_FAULT = 0x05, + RADIO_FAULT_TYPE_ETHERNET_FAULT = 0x06, +}; + +namespace NetworkInterfaceType { +enum FieldId +{ + kNameFieldId = 0, + kFabricConnectedFieldId = 1, + kOffPremiseServicesReachableIPv4FieldId = 2, + kOffPremiseServicesReachableIPv6FieldId = 3, + kHardwareAddressFieldId = 4, + kTypeFieldId = 5, +}; + +struct Type +{ +public: + chip::ByteSpan name; + bool fabricConnected; + bool offPremiseServicesReachableIPv4; + bool offPremiseServicesReachableIPv6; + chip::ByteSpan hardwareAddress; + InterfaceType type; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; + CHIP_ERROR Decode(TLV::TLVReader & reader); +}; + +} // namespace NetworkInterfaceType + +} // namespace GeneralDiagnostics +namespace GroupKeyManagement { +constexpr ClusterId kClusterId = 0xF004; +// Enum for GroupKeySecurityPolicy +enum class GroupKeySecurityPolicy : uint8_t +{ + GROUP_KEY_SECURITY_POLICY_STANDARD = 0x00, + GROUP_KEY_SECURITY_POLICY_LOW_LATENCY = 0x01, +}; + +namespace GroupKey { +enum FieldId +{ + kVendorIdFieldId = 0, + kGroupKeyIndexFieldId = 1, + kGroupKeyRootFieldId = 2, + kGroupKeyEpochStartTimeFieldId = 3, + kGroupKeySecurityPolicyFieldId = 4, +}; + +struct Type +{ +public: + uint16_t vendorId; + uint16_t groupKeyIndex; + chip::ByteSpan groupKeyRoot; + uint64_t groupKeyEpochStartTime; + GroupKeySecurityPolicy groupKeySecurityPolicy; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; + CHIP_ERROR Decode(TLV::TLVReader & reader); +}; + +} // namespace GroupKey +namespace GroupState { +enum FieldId +{ + kVendorIdFieldId = 0, + kVendorGroupIdFieldId = 1, + kGroupKeySetIndexFieldId = 2, +}; + +struct Type +{ +public: + uint16_t vendorId; + uint16_t vendorGroupId; + uint16_t groupKeySetIndex; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; + CHIP_ERROR Decode(TLV::TLVReader & reader); +}; + +} // namespace GroupState + +} // namespace GroupKeyManagement +namespace Groups { +constexpr ClusterId kClusterId = 0x04; + +} // namespace Groups +namespace Identify { +constexpr ClusterId kClusterId = 0x03; + +} // namespace Identify +namespace KeypadInput { +constexpr ClusterId kClusterId = 0x509; +// Enum for KeypadInputCecKeyCode +enum class KeypadInputCecKeyCode : uint8_t +{ + KEYPAD_INPUT_CEC_KEY_CODE_SELECT = 0x00, + KEYPAD_INPUT_CEC_KEY_CODE_UP = 0x01, + KEYPAD_INPUT_CEC_KEY_CODE_DOWN = 0x02, + KEYPAD_INPUT_CEC_KEY_CODE_LEFT = 0x03, + KEYPAD_INPUT_CEC_KEY_CODE_RIGHT = 0x04, + KEYPAD_INPUT_CEC_KEY_CODE_RIGHT_UP = 0x05, + KEYPAD_INPUT_CEC_KEY_CODE_RIGHT_DOWN = 0x06, + KEYPAD_INPUT_CEC_KEY_CODE_LEFT_UP = 0x07, + KEYPAD_INPUT_CEC_KEY_CODE_LEFT_DOWN = 0x08, + KEYPAD_INPUT_CEC_KEY_CODE_ROOT_MENU = 0x09, + KEYPAD_INPUT_CEC_KEY_CODE_SETUP_MENU = 0x0A, + KEYPAD_INPUT_CEC_KEY_CODE_CONTENTS_MENU = 0x0B, + KEYPAD_INPUT_CEC_KEY_CODE_FAVORITE_MENU = 0x0C, + KEYPAD_INPUT_CEC_KEY_CODE_EXIT = 0x0D, + KEYPAD_INPUT_CEC_KEY_CODE_MEDIA_TOP_MENU = 0x10, + KEYPAD_INPUT_CEC_KEY_CODE_MEDIA_CONTEXT_SENSITIVE_MENU = 0x11, + KEYPAD_INPUT_CEC_KEY_CODE_NUMBER_ENTRY_MODE = 0x1D, + KEYPAD_INPUT_CEC_KEY_CODE_NUMBER11 = 0x1E, + KEYPAD_INPUT_CEC_KEY_CODE_NUMBER12 = 0x1F, + KEYPAD_INPUT_CEC_KEY_CODE_NUMBER0_OR_NUMBER10 = 0x20, + KEYPAD_INPUT_CEC_KEY_CODE_NUMBERS1 = 0x21, + KEYPAD_INPUT_CEC_KEY_CODE_NUMBERS2 = 0x22, + KEYPAD_INPUT_CEC_KEY_CODE_NUMBERS3 = 0x23, + KEYPAD_INPUT_CEC_KEY_CODE_NUMBERS4 = 0x24, + KEYPAD_INPUT_CEC_KEY_CODE_NUMBERS5 = 0x25, + KEYPAD_INPUT_CEC_KEY_CODE_NUMBERS6 = 0x26, + KEYPAD_INPUT_CEC_KEY_CODE_NUMBERS7 = 0x27, + KEYPAD_INPUT_CEC_KEY_CODE_NUMBERS8 = 0x28, + KEYPAD_INPUT_CEC_KEY_CODE_NUMBERS9 = 0x29, + KEYPAD_INPUT_CEC_KEY_CODE_DOT = 0x2A, + KEYPAD_INPUT_CEC_KEY_CODE_ENTER = 0x2B, + KEYPAD_INPUT_CEC_KEY_CODE_CLEAR = 0x2C, + KEYPAD_INPUT_CEC_KEY_CODE_NEXT_FAVORITE = 0x2F, + KEYPAD_INPUT_CEC_KEY_CODE_CHANNEL_UP = 0x30, + KEYPAD_INPUT_CEC_KEY_CODE_CHANNEL_DOWN = 0x31, + KEYPAD_INPUT_CEC_KEY_CODE_PREVIOUS_CHANNEL = 0x32, + KEYPAD_INPUT_CEC_KEY_CODE_SOUND_SELECT = 0x33, + KEYPAD_INPUT_CEC_KEY_CODE_INPUT_SELECT = 0x34, + KEYPAD_INPUT_CEC_KEY_CODE_DISPLAY_INFORMATION = 0x35, + KEYPAD_INPUT_CEC_KEY_CODE_HELP = 0x36, + KEYPAD_INPUT_CEC_KEY_CODE_PAGE_UP = 0x37, + KEYPAD_INPUT_CEC_KEY_CODE_PAGE_DOWN = 0x38, + KEYPAD_INPUT_CEC_KEY_CODE_POWER = 0x40, + KEYPAD_INPUT_CEC_KEY_CODE_VOLUME_UP = 0x41, + KEYPAD_INPUT_CEC_KEY_CODE_VOLUME_DOWN = 0x42, + KEYPAD_INPUT_CEC_KEY_CODE_MUTE = 0x43, + KEYPAD_INPUT_CEC_KEY_CODE_PLAY = 0x44, + KEYPAD_INPUT_CEC_KEY_CODE_STOP = 0x45, + KEYPAD_INPUT_CEC_KEY_CODE_PAUSE = 0x46, + KEYPAD_INPUT_CEC_KEY_CODE_RECORD = 0x47, + KEYPAD_INPUT_CEC_KEY_CODE_REWIND = 0x48, + KEYPAD_INPUT_CEC_KEY_CODE_FAST_FORWARD = 0x49, + KEYPAD_INPUT_CEC_KEY_CODE_EJECT = 0x4A, + KEYPAD_INPUT_CEC_KEY_CODE_FORWARD = 0x4B, + KEYPAD_INPUT_CEC_KEY_CODE_BACKWARD = 0x4C, + KEYPAD_INPUT_CEC_KEY_CODE_STOP_RECORD = 0x4D, + KEYPAD_INPUT_CEC_KEY_CODE_PAUSE_RECORD = 0x4E, + KEYPAD_INPUT_CEC_KEY_CODE_RESERVED = 0x4F, + KEYPAD_INPUT_CEC_KEY_CODE_ANGLE = 0x50, + KEYPAD_INPUT_CEC_KEY_CODE_SUB_PICTURE = 0x51, + KEYPAD_INPUT_CEC_KEY_CODE_VIDEO_ON_DEMAND = 0x52, + KEYPAD_INPUT_CEC_KEY_CODE_ELECTRONIC_PROGRAM_GUIDE = 0x53, + KEYPAD_INPUT_CEC_KEY_CODE_TIMER_PROGRAMMING = 0x54, + KEYPAD_INPUT_CEC_KEY_CODE_INITIAL_CONFIGURATION = 0x55, + KEYPAD_INPUT_CEC_KEY_CODE_SELECT_BROADCAST_TYPE = 0x56, + KEYPAD_INPUT_CEC_KEY_CODE_SELECT_SOUND_PRESENTATION = 0x57, + KEYPAD_INPUT_CEC_KEY_CODE_PLAY_FUNCTION = 0x60, + KEYPAD_INPUT_CEC_KEY_CODE_PAUSE_PLAY_FUNCTION = 0x61, + KEYPAD_INPUT_CEC_KEY_CODE_RECORD_FUNCTION = 0x62, + KEYPAD_INPUT_CEC_KEY_CODE_PAUSE_RECORD_FUNCTION = 0x63, + KEYPAD_INPUT_CEC_KEY_CODE_STOP_FUNCTION = 0x64, + KEYPAD_INPUT_CEC_KEY_CODE_MUTE_FUNCTION = 0x65, + KEYPAD_INPUT_CEC_KEY_CODE_RESTORE_VOLUME_FUNCTION = 0x66, + KEYPAD_INPUT_CEC_KEY_CODE_TUNE_FUNCTION = 0x67, + KEYPAD_INPUT_CEC_KEY_CODE_SELECT_MEDIA_FUNCTION = 0x68, + KEYPAD_INPUT_CEC_KEY_CODE_SELECT_AV_INPUT_FUNCTION = 0x69, + KEYPAD_INPUT_CEC_KEY_CODE_SELECT_AUDIO_INPUT_FUNCTION = 0x6A, + KEYPAD_INPUT_CEC_KEY_CODE_POWER_TOGGLE_FUNCTION = 0x6B, + KEYPAD_INPUT_CEC_KEY_CODE_POWER_OFF_FUNCTION = 0x6C, + KEYPAD_INPUT_CEC_KEY_CODE_POWER_ON_FUNCTION = 0x6D, + KEYPAD_INPUT_CEC_KEY_CODE_F1_BLUE = 0x71, + KEYPAD_INPUT_CEC_KEY_CODE_F2_RED = 0x72, + KEYPAD_INPUT_CEC_KEY_CODE_F3_GREEN = 0x73, + KEYPAD_INPUT_CEC_KEY_CODE_F4_YELLOW = 0x74, + KEYPAD_INPUT_CEC_KEY_CODE_F5 = 0x75, + KEYPAD_INPUT_CEC_KEY_CODE_DATA = 0x76, +}; +// Enum for KeypadInputStatus +enum class KeypadInputStatus : uint8_t +{ + KEYPAD_INPUT_STATUS_SUCCESS = 0x00, + KEYPAD_INPUT_STATUS_UNSUPPORTED_KEY = 0x01, + KEYPAD_INPUT_STATUS_INVALID_KEY_IN_CURRENT_STATE = 0x02, +}; + +} // namespace KeypadInput +namespace LevelControl { +constexpr ClusterId kClusterId = 0x08; + +} // namespace LevelControl +namespace LowPower { +constexpr ClusterId kClusterId = 0x508; + +} // namespace LowPower +namespace MediaInput { +constexpr ClusterId kClusterId = 0x507; +// Enum for MediaInputType +enum class MediaInputType : uint8_t +{ + MEDIA_INPUT_TYPE_INTERNAL = 0x00, + MEDIA_INPUT_TYPE_AUX = 0x01, + MEDIA_INPUT_TYPE_COAX = 0x02, + MEDIA_INPUT_TYPE_COMPOSITE = 0x03, + MEDIA_INPUT_TYPE_HDMI = 0x04, + MEDIA_INPUT_TYPE_INPUT = 0x05, + MEDIA_INPUT_TYPE_LINE = 0x06, + MEDIA_INPUT_TYPE_OPTICAL = 0x07, + MEDIA_INPUT_TYPE_VIDEO = 0x08, + MEDIA_INPUT_TYPE_SCART = 0x09, + MEDIA_INPUT_TYPE_USB = 0x0A, + MEDIA_INPUT_TYPE_OTHER = 0x0B, +}; + +namespace MediaInputInfo { +enum FieldId +{ + kIndexFieldId = 0, + kInputTypeFieldId = 1, + kNameFieldId = 2, + kDescriptionFieldId = 3, +}; + +struct Type +{ +public: + uint8_t index; + MediaInputType inputType; + chip::ByteSpan name; + chip::ByteSpan description; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; + CHIP_ERROR Decode(TLV::TLVReader & reader); +}; + +} // namespace MediaInputInfo + +} // namespace MediaInput +namespace MediaPlayback { +constexpr ClusterId kClusterId = 0x506; +// Enum for MediaPlaybackState +enum class MediaPlaybackState : uint8_t +{ + MEDIA_PLAYBACK_STATE_PLAYING = 0x00, + MEDIA_PLAYBACK_STATE_PAUSED = 0x01, + MEDIA_PLAYBACK_STATE_NOT_PLAYING = 0x02, + MEDIA_PLAYBACK_STATE_BUFFERING = 0x03, +}; +// Enum for MediaPlaybackStatus +enum class MediaPlaybackStatus : uint8_t +{ + MEDIA_PLAYBACK_STATUS_SUCCESS = 0x00, + MEDIA_PLAYBACK_STATUS_INVALID_STATE_FOR_COMMAND = 0x01, + MEDIA_PLAYBACK_STATUS_NOT_ALLOWED = 0x02, + MEDIA_PLAYBACK_STATUS_NOT_ACTIVE = 0x03, + MEDIA_PLAYBACK_STATUS_SPEED_OUT_OF_RANGE = 0x04, + MEDIA_PLAYBACK_STATUS_SEEK_OUT_OF_RANGE = 0x05, +}; + +namespace MediaPlaybackPosition { +enum FieldId +{ + kUpdatedAtFieldId = 0, + kPositionFieldId = 1, +}; + +struct Type +{ +public: + uint64_t updatedAt; + uint64_t position; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; + CHIP_ERROR Decode(TLV::TLVReader & reader); +}; + +} // namespace MediaPlaybackPosition + +} // namespace MediaPlayback +namespace NetworkCommissioning { +constexpr ClusterId kClusterId = 0x31; +// Enum for NetworkCommissioningError +enum class NetworkCommissioningError : uint8_t +{ + NETWORK_COMMISSIONING_ERROR_SUCCESS = 0x00, + NETWORK_COMMISSIONING_ERROR_OUT_OF_RANGE = 0x01, + NETWORK_COMMISSIONING_ERROR_BOUNDS_EXCEEDED = 0x02, + NETWORK_COMMISSIONING_ERROR_NETWORK_ID_NOT_FOUND = 0x03, + NETWORK_COMMISSIONING_ERROR_DUPLICATE_NETWORK_ID = 0x04, + NETWORK_COMMISSIONING_ERROR_NETWORK_NOT_FOUND = 0x05, + NETWORK_COMMISSIONING_ERROR_REGULATORY_ERROR = 0x06, + NETWORK_COMMISSIONING_ERROR_AUTH_FAILURE = 0x07, + NETWORK_COMMISSIONING_ERROR_UNSUPPORTED_SECURITY = 0x08, + NETWORK_COMMISSIONING_ERROR_OTHER_CONNECTION_FAILURE = 0x09, + NETWORK_COMMISSIONING_ERROR_IPV6_FAILED = 0x0A, + NETWORK_COMMISSIONING_ERROR_IP_BIND_FAILED = 0x0B, + NETWORK_COMMISSIONING_ERROR_LABEL9 = 0x0C, + NETWORK_COMMISSIONING_ERROR_LABEL10 = 0x0D, + NETWORK_COMMISSIONING_ERROR_LABEL11 = 0x0E, + NETWORK_COMMISSIONING_ERROR_LABEL12 = 0x0F, + NETWORK_COMMISSIONING_ERROR_LABEL13 = 0x10, + NETWORK_COMMISSIONING_ERROR_LABEL14 = 0x11, + NETWORK_COMMISSIONING_ERROR_LABEL15 = 0x12, + NETWORK_COMMISSIONING_ERROR_UNKNOWN_ERROR = 0x13, +}; + +namespace ThreadInterfaceScanResult { +enum FieldId +{ + kDiscoveryResponseFieldId = 0, +}; + +struct Type +{ +public: + chip::ByteSpan discoveryResponse; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; + CHIP_ERROR Decode(TLV::TLVReader & reader); +}; + +} // namespace ThreadInterfaceScanResult +namespace WiFiInterfaceScanResult { +enum FieldId +{ + kSecurityFieldId = 0, + kSsidFieldId = 1, + kBssidFieldId = 2, + kChannelFieldId = 3, + kFrequencyBandFieldId = 4, +}; + +struct Type +{ +public: + uint8_t security; + chip::ByteSpan ssid; + chip::ByteSpan bssid; + uint8_t channel; + uint32_t frequencyBand; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; + CHIP_ERROR Decode(TLV::TLVReader & reader); +}; + +} // namespace WiFiInterfaceScanResult + +} // namespace NetworkCommissioning +namespace OtaSoftwareUpdateProvider { +constexpr ClusterId kClusterId = 0x29; +// Enum for OTAApplyUpdateAction +enum class OTAApplyUpdateAction : uint8_t +{ + OTA_APPLY_UPDATE_ACTION_PROCEED = 0x00, + OTA_APPLY_UPDATE_ACTION_AWAIT_NEXT_ACTION = 0x01, + OTA_APPLY_UPDATE_ACTION_DISCONTINUE = 0x02, +}; +// Enum for OTADownloadProtocol +enum class OTADownloadProtocol : uint8_t +{ + OTA_DOWNLOAD_PROTOCOL_BDX_SYNCHRONOUS = 0x00, + OTA_DOWNLOAD_PROTOCOL_BDX_ASYNCHRONOUS = 0x01, + OTA_DOWNLOAD_PROTOCOL_HTTPS = 0x02, + OTA_DOWNLOAD_PROTOCOL_VENDOR_SPECIFIC = 0x03, +}; +// Enum for OTAQueryStatus +enum class OTAQueryStatus : uint8_t +{ + OTA_QUERY_STATUS_UPDATE_AVAILABLE = 0x00, + OTA_QUERY_STATUS_BUSY = 0x01, + OTA_QUERY_STATUS_NOT_AVAILABLE = 0x02, +}; + +} // namespace OtaSoftwareUpdateProvider +namespace OtaSoftwareUpdateRequestor { +constexpr ClusterId kClusterId = 0x2A; +// Enum for OTAAnnouncementReason +enum class OTAAnnouncementReason : uint8_t +{ + OTA_ANNOUNCEMENT_REASON_SIMPLE_ANNOUNCEMENT = 0x00, + OTA_ANNOUNCEMENT_REASON_UPDATE_AVAILABLE = 0x01, + OTA_ANNOUNCEMENT_REASON_CRITICAL_UPDATE_AVAILABLE = 0x02, +}; + +} // namespace OtaSoftwareUpdateRequestor +namespace OccupancySensing { +constexpr ClusterId kClusterId = 0x406; + +} // namespace OccupancySensing +namespace OnOff { +constexpr ClusterId kClusterId = 0x06; +// Enum for OnOffDelayedAllOffEffectVariant +enum class OnOffDelayedAllOffEffectVariant : uint8_t +{ + ON_OFF_DELAYED_ALL_OFF_EFFECT_VARIANT_FADE_TO_OFF_IN_0P8_SECONDS = 0x00, + ON_OFF_DELAYED_ALL_OFF_EFFECT_VARIANT_NO_FADE = 0x01, + ON_OFF_DELAYED_ALL_OFF_EFFECT_VARIANT_50_PERCENT_DIM_DOWN_IN_0P8_SECONDS_THEN_FADE_TO_OFF_IN_12_SECONDS = 0x02, +}; +// Enum for OnOffDyingLightEffectVariant +enum class OnOffDyingLightEffectVariant : uint8_t +{ + ON_OFF_DYING_LIGHT_EFFECT_VARIANT_20_PERCENTER_DIM_UP_IN_0P5_SECONDS_THEN_FADE_TO_OFF_IN_1_SECOND = 0x00, +}; +// Enum for OnOffEffectIdentifier +enum class OnOffEffectIdentifier : uint8_t +{ + ON_OFF_EFFECT_IDENTIFIER_DELAYED_ALL_OFF = 0x00, + ON_OFF_EFFECT_IDENTIFIER_DYING_LIGHT = 0x01, +}; + +} // namespace OnOff +namespace OnOffSwitchConfiguration { +constexpr ClusterId kClusterId = 0x07; + +} // namespace OnOffSwitchConfiguration +namespace OperationalCredentials { +constexpr ClusterId kClusterId = 0x3E; +// Enum for NodeOperationalCertStatus +enum class NodeOperationalCertStatus : uint8_t +{ + NODE_OPERATIONAL_CERT_STATUS_SUCCESS = 0x00, + NODE_OPERATIONAL_CERT_STATUS_INVALID_PUBLIC_KEY = 0x01, + NODE_OPERATIONAL_CERT_STATUS_INVALID_NODE_OP_ID = 0x02, + NODE_OPERATIONAL_CERT_STATUS_INVALID_NOC = 0x03, + NODE_OPERATIONAL_CERT_STATUS_MISSING_CSR = 0x04, + NODE_OPERATIONAL_CERT_STATUS_TABLE_FULL = 0x05, + NODE_OPERATIONAL_CERT_STATUS_INSUFFICIENT_PRIVILEGE = 0x08, + NODE_OPERATIONAL_CERT_STATUS_FABRIC_CONFLICT = 0x09, + NODE_OPERATIONAL_CERT_STATUS_LABEL_CONFLICT = 0x0A, + NODE_OPERATIONAL_CERT_STATUS_INVALID_FABRIC_INDEX = 0x0B, +}; + +namespace FabricDescriptor { +enum FieldId +{ + kFabricIndexFieldId = 0, + kRootPublicKeyFieldId = 1, + kVendorIdFieldId = 2, + kFabricIdFieldId = 3, + kNodeIdFieldId = 4, + kLabelFieldId = 5, +}; + +struct Type +{ +public: + uint8_t fabricIndex; + chip::ByteSpan rootPublicKey; + uint16_t vendorId; + uint64_t fabricId; + uint64_t nodeId; + chip::ByteSpan label; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; + CHIP_ERROR Decode(TLV::TLVReader & reader); +}; + +} // namespace FabricDescriptor +namespace NOCStruct { +enum FieldId +{ + kFabricIndexFieldId = 0, + kNocFieldId = 1, +}; + +struct Type +{ +public: + uint8_t fabricIndex; + chip::ByteSpan noc; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; + CHIP_ERROR Decode(TLV::TLVReader & reader); +}; + +} // namespace NOCStruct + +} // namespace OperationalCredentials +namespace PowerSource { +constexpr ClusterId kClusterId = 0x2F; + +} // namespace PowerSource +namespace PressureMeasurement { +constexpr ClusterId kClusterId = 0x403; + +} // namespace PressureMeasurement +namespace PumpConfigurationAndControl { +constexpr ClusterId kClusterId = 0x200; +// Enum for PumpControlMode +enum class PumpControlMode : uint8_t +{ + PUMP_CONTROL_MODE_CONSTANT_SPEED = 0x00, + PUMP_CONTROL_MODE_CONSTANT_PRESSURE = 0x01, + PUMP_CONTROL_MODE_PROPORTIONAL_PRESSURE = 0x02, + PUMP_CONTROL_MODE_CONSTANT_FLOW = 0x03, + PUMP_CONTROL_MODE_CONSTANT_TEMPERATURE = 0x05, + PUMP_CONTROL_MODE_AUTOMATIC = 0x07, +}; +// Enum for PumpOperationMode +enum class PumpOperationMode : uint8_t +{ + PUMP_OPERATION_MODE_NORMAL = 0x00, + PUMP_OPERATION_MODE_MINIMUM = 0x01, + PUMP_OPERATION_MODE_MAXIMUM = 0x02, + PUMP_OPERATION_MODE_LOCAL = 0x03, +}; + +} // namespace PumpConfigurationAndControl +namespace RelativeHumidityMeasurement { +constexpr ClusterId kClusterId = 0x405; + +} // namespace RelativeHumidityMeasurement +namespace Scenes { +constexpr ClusterId kClusterId = 0x05; + +} // namespace Scenes +namespace SoftwareDiagnostics { +constexpr ClusterId kClusterId = 0x34; + +namespace ThreadMetrics { +enum FieldId +{ + kIdFieldId = 0, + kNameFieldId = 1, + kStackFreeCurrentFieldId = 2, + kStackFreeMinimumFieldId = 3, + kStackSizeFieldId = 4, +}; + +struct Type +{ +public: + uint64_t id; + chip::ByteSpan name; + uint32_t stackFreeCurrent; + uint32_t stackFreeMinimum; + uint32_t stackSize; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; + CHIP_ERROR Decode(TLV::TLVReader & reader); +}; + +} // namespace ThreadMetrics + +} // namespace SoftwareDiagnostics +namespace Switch { +constexpr ClusterId kClusterId = 0x3B; + +} // namespace Switch +namespace TvChannel { +constexpr ClusterId kClusterId = 0x504; +// Enum for TvChannelErrorType +enum class TvChannelErrorType : uint8_t +{ + TV_CHANNEL_ERROR_TYPE_MULTIPLE_MATCHES = 0x00, + TV_CHANNEL_ERROR_TYPE_NO_MATCHES = 0x01, +}; +// Enum for TvChannelLineupInfoType +enum class TvChannelLineupInfoType : uint8_t +{ + TV_CHANNEL_LINEUP_INFO_TYPE_MSO = 0x00, +}; + +namespace TvChannelInfo { +enum FieldId +{ + kMajorNumberFieldId = 0, + kMinorNumberFieldId = 1, + kNameFieldId = 2, + kCallSignFieldId = 3, + kAffiliateCallSignFieldId = 4, +}; + +struct Type +{ +public: + uint16_t majorNumber; + uint16_t minorNumber; + chip::ByteSpan name; + chip::ByteSpan callSign; + chip::ByteSpan affiliateCallSign; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; + CHIP_ERROR Decode(TLV::TLVReader & reader); +}; + +} // namespace TvChannelInfo +namespace TvChannelLineupInfo { +enum FieldId +{ + kOperatorNameFieldId = 0, + kLineupNameFieldId = 1, + kPostalCodeFieldId = 2, + kLineupInfoTypeFieldId = 3, +}; + +struct Type +{ +public: + Span operatorName; + Span lineupName; + Span postalCode; + TvChannelLineupInfoType lineupInfoType; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; + CHIP_ERROR Decode(TLV::TLVReader & reader); +}; + +} // namespace TvChannelLineupInfo + +} // namespace TvChannel +namespace TargetNavigator { +constexpr ClusterId kClusterId = 0x505; +// Enum for NavigateTargetStatus +enum class NavigateTargetStatus : uint8_t +{ + NAVIGATE_TARGET_STATUS_SUCCESS = 0x00, + NAVIGATE_TARGET_STATUS_APP_NOT_AVAILABLE = 0x01, + NAVIGATE_TARGET_STATUS_SYSTEM_BUSY = 0x02, +}; + +namespace NavigateTargetTargetInfo { +enum FieldId +{ + kIdentifierFieldId = 0, + kNameFieldId = 1, +}; + +struct Type +{ +public: + uint8_t identifier; + chip::ByteSpan name; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; + CHIP_ERROR Decode(TLV::TLVReader & reader); +}; + +} // namespace NavigateTargetTargetInfo + +} // namespace TargetNavigator +namespace TemperatureMeasurement { +constexpr ClusterId kClusterId = 0x402; + +} // namespace TemperatureMeasurement +namespace TestCluster { +constexpr ClusterId kClusterId = 0x50F; +// Enum for SimpleEnum +enum class SimpleEnum : uint8_t +{ + SIMPLE_ENUM_UNSPECIFIED = 0x00, + SIMPLE_ENUM_VALUE_A = 0x01, + SIMPLE_ENUM_VALUE_B = 0x02, + SIMPLE_ENUM_VALUE_C = 0x03, +}; + +namespace SimpleStruct { +enum FieldId +{ + kAFieldId = 0, + kBFieldId = 1, + kCFieldId = 2, + kDFieldId = 3, + kEFieldId = 4, +}; + +struct Type +{ +public: + uint8_t a; + bool b; + SimpleEnum c; + chip::ByteSpan d; + Span e; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; + CHIP_ERROR Decode(TLV::TLVReader & reader); +}; + +} // namespace SimpleStruct +namespace NestedStruct { +enum FieldId +{ + kAFieldId = 0, + kBFieldId = 1, + kCFieldId = 2, +}; + +struct Type +{ +public: + uint8_t a; + bool b; + SimpleStruct::Type c; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; + CHIP_ERROR Decode(TLV::TLVReader & reader); +}; + +} // namespace NestedStruct +namespace NestedStructList { +enum FieldId +{ + kAFieldId = 0, + kBFieldId = 1, + kCFieldId = 2, + kDFieldId = 3, + kEFieldId = 4, + kFFieldId = 5, + kGFieldId = 6, +}; + +struct Type +{ +public: + uint8_t a; + bool b; + SimpleStruct::Type c; + DataModel::List d; + DataModel::List e; + DataModel::List f; + DataModel::List g; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; + CHIP_ERROR Decode(TLV::TLVReader & reader); +}; + +struct DecodableType +{ +public: + uint8_t a; + bool b; + SimpleStruct::Type c; + DataModel::DecodableList d; + DataModel::DecodableList e; + DataModel::DecodableList f; + DataModel::DecodableList g; + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; + CHIP_ERROR Decode(TLV::TLVReader & reader); +}; + +} // namespace NestedStructList +namespace DoubleNestedStructList { +enum FieldId +{ + kAFieldId = 0, +}; + +struct Type +{ +public: + DataModel::List a; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; + CHIP_ERROR Decode(TLV::TLVReader & reader); +}; + +struct DecodableType +{ +public: + DataModel::DecodableList a; + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; + CHIP_ERROR Decode(TLV::TLVReader & reader); +}; + +} // namespace DoubleNestedStructList +namespace TestListStructOctet { +enum FieldId +{ + kFabricIndexFieldId = 0, + kOperationalCertFieldId = 1, +}; + +struct Type +{ +public: + uint64_t fabricIndex; + chip::ByteSpan operationalCert; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; + CHIP_ERROR Decode(TLV::TLVReader & reader); +}; + +} // namespace TestListStructOctet + +} // namespace TestCluster +namespace Thermostat { +constexpr ClusterId kClusterId = 0x201; + +} // namespace Thermostat +namespace ThermostatUserInterfaceConfiguration { +constexpr ClusterId kClusterId = 0x204; + +} // namespace ThermostatUserInterfaceConfiguration +namespace ThreadNetworkDiagnostics { +constexpr ClusterId kClusterId = 0x35; +// Enum for NetworkFault +enum class NetworkFault : uint8_t +{ + NETWORK_FAULT_UNSPECIFIED = 0x00, + NETWORK_FAULT_LINK_DOWN = 0x01, + NETWORK_FAULT_HARDWARE_FAILURE = 0x02, + NETWORK_FAULT_NETWORK_JAMMED = 0x03, +}; +// Enum for RoutingRole +enum class RoutingRole : uint8_t +{ + ROUTING_ROLE_UNSPECIFIED = 0x00, + ROUTING_ROLE_UNASSIGNED = 0x01, + ROUTING_ROLE_SLEEPY_END_DEVICE = 0x02, + ROUTING_ROLE_END_DEVICE = 0x03, + ROUTING_ROLE_REED = 0x04, + ROUTING_ROLE_ROUTER = 0x05, + ROUTING_ROLE_LEADER = 0x06, +}; + +namespace NeighborTable { +enum FieldId +{ + kExtAddressFieldId = 0, + kAgeFieldId = 1, + kRloc16FieldId = 2, + kLinkFrameCounterFieldId = 3, + kMleFrameCounterFieldId = 4, + kLqiFieldId = 5, + kAverageRssiFieldId = 6, + kLastRssiFieldId = 7, + kFrameErrorRateFieldId = 8, + kMessageErrorRateFieldId = 9, + kRxOnWhenIdleFieldId = 10, + kFullThreadDeviceFieldId = 11, + kFullNetworkDataFieldId = 12, + kIsChildFieldId = 13, +}; + +struct Type +{ +public: + uint64_t extAddress; + uint32_t age; + uint16_t rloc16; + uint32_t linkFrameCounter; + uint32_t mleFrameCounter; + uint8_t lqi; + int8_t averageRssi; + int8_t lastRssi; + uint8_t frameErrorRate; + uint8_t messageErrorRate; + bool rxOnWhenIdle; + bool fullThreadDevice; + bool fullNetworkData; + bool isChild; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; + CHIP_ERROR Decode(TLV::TLVReader & reader); +}; + +} // namespace NeighborTable +namespace OperationalDatasetComponents { +enum FieldId +{ + kActiveTimestampPresentFieldId = 0, + kPendingTimestampPresentFieldId = 1, + kMasterKeyPresentFieldId = 2, + kNetworkNamePresentFieldId = 3, + kExtendedPanIdPresentFieldId = 4, + kMeshLocalPrefixPresentFieldId = 5, + kDelayPresentFieldId = 6, + kPanIdPresentFieldId = 7, + kChannelPresentFieldId = 8, + kPskcPresentFieldId = 9, + kSecurityPolicyPresentFieldId = 10, + kChannelMaskPresentFieldId = 11, +}; + +struct Type +{ +public: + bool activeTimestampPresent; + bool pendingTimestampPresent; + bool masterKeyPresent; + bool networkNamePresent; + bool extendedPanIdPresent; + bool meshLocalPrefixPresent; + bool delayPresent; + bool panIdPresent; + bool channelPresent; + bool pskcPresent; + bool securityPolicyPresent; + bool channelMaskPresent; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; + CHIP_ERROR Decode(TLV::TLVReader & reader); +}; + +} // namespace OperationalDatasetComponents +namespace RouteTable { +enum FieldId +{ + kExtAddressFieldId = 0, + kRloc16FieldId = 1, + kRouterIdFieldId = 2, + kNextHopFieldId = 3, + kPathCostFieldId = 4, + kLQIInFieldId = 5, + kLQIOutFieldId = 6, + kAgeFieldId = 7, + kAllocatedFieldId = 8, + kLinkEstablishedFieldId = 9, +}; + +struct Type +{ +public: + uint64_t extAddress; + uint16_t rloc16; + uint8_t routerId; + uint8_t nextHop; + uint8_t pathCost; + uint8_t lQIIn; + uint8_t lQIOut; + uint8_t age; + bool allocated; + bool linkEstablished; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; + CHIP_ERROR Decode(TLV::TLVReader & reader); +}; + +} // namespace RouteTable +namespace SecurityPolicy { +enum FieldId +{ + kRotationTimeFieldId = 0, + kFlagsFieldId = 1, +}; + +struct Type +{ +public: + uint16_t rotationTime; + uint16_t flags; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; + CHIP_ERROR Decode(TLV::TLVReader & reader); +}; + +} // namespace SecurityPolicy + +} // namespace ThreadNetworkDiagnostics +namespace WakeOnLan { +constexpr ClusterId kClusterId = 0x503; + +} // namespace WakeOnLan +namespace WiFiNetworkDiagnostics { +constexpr ClusterId kClusterId = 0x36; +// Enum for SecurityType +enum class SecurityType : uint8_t +{ + SECURITY_TYPE_UNSPECIFIED = 0x00, + SECURITY_TYPE_NONE = 0x01, + SECURITY_TYPE_WEP = 0x02, + SECURITY_TYPE_WPA = 0x03, + SECURITY_TYPE_WPA2 = 0x04, + SECURITY_TYPE_WPA3 = 0x05, +}; +// Enum for WiFiVersionType +enum class WiFiVersionType : uint8_t +{ + WI_FI_VERSION_TYPE_802__11A = 0x00, + WI_FI_VERSION_TYPE_802__11B = 0x01, + WI_FI_VERSION_TYPE_802__11G = 0x02, + WI_FI_VERSION_TYPE_802__11N = 0x03, + WI_FI_VERSION_TYPE_802__11AC = 0x04, + WI_FI_VERSION_TYPE_802__11AX = 0x05, +}; + +} // namespace WiFiNetworkDiagnostics +namespace WindowCovering { +constexpr ClusterId kClusterId = 0x102; +// Enum for WcEndProductType +enum class WcEndProductType : uint8_t +{ + WC_END_PRODUCT_TYPE_ROLLER_SHADE = 0x00, + WC_END_PRODUCT_TYPE_ROMAN_SHADE = 0x01, + WC_END_PRODUCT_TYPE_BALLOON_SHADE = 0x02, + WC_END_PRODUCT_TYPE_WOVEN_WOOD = 0x03, + WC_END_PRODUCT_TYPE_PLEATED_SHADE = 0x04, + WC_END_PRODUCT_TYPE_CELLULAR_SHADE = 0x05, + WC_END_PRODUCT_TYPE_LAYERED_SHADE = 0x06, + WC_END_PRODUCT_TYPE_LAYERED_SHADE2_D = 0x07, + WC_END_PRODUCT_TYPE_SHEER_SHADE = 0x08, + WC_END_PRODUCT_TYPE_TILT_ONLY_INTERIOR_BLIND = 0x09, + WC_END_PRODUCT_TYPE_INTERIOR_BLIND = 0x0A, + WC_END_PRODUCT_TYPE_VERTICAL_BLIND_STRIP_CURTAIN = 0x0B, + WC_END_PRODUCT_TYPE_INTERIOR_VENETIAN_BLIND = 0x0C, + WC_END_PRODUCT_TYPE_EXTERIOR_VENETIAN_BLIND = 0x0D, + WC_END_PRODUCT_TYPE_LATERAL_LEFT_CURTAIN = 0x0E, + WC_END_PRODUCT_TYPE_LATERAL_RIGHT_CURTAIN = 0x0F, + WC_END_PRODUCT_TYPE_CENTRAL_CURTAIN = 0x10, + WC_END_PRODUCT_TYPE_ROLLER_SHUTTER = 0x11, + WC_END_PRODUCT_TYPE_EXTERIOR_VERTICAL_SCREEN = 0x12, + WC_END_PRODUCT_TYPE_AWNING_TERRACE_PATIO = 0x13, + WC_END_PRODUCT_TYPE_AWNING_VERTICAL_SCREEN = 0x14, + WC_END_PRODUCT_TYPE_TILT_ONLY_PERGOLA = 0x15, + WC_END_PRODUCT_TYPE_SWINGING_SHUTTER = 0x16, + WC_END_PRODUCT_TYPE_SLIDING_SHUTTER = 0x17, + WC_END_PRODUCT_TYPE_UNKNOWN = 0xFF, +}; +// Enum for WcType +enum class WcType : uint8_t +{ + WC_TYPE_ROLLERSHADE = 0x00, + WC_TYPE_ROLLERSHADE2_MOTOR = 0x01, + WC_TYPE_ROLLERSHADE_EXTERIOR = 0x02, + WC_TYPE_ROLLERSHADE_EXTERIOR2_MOTOR = 0x03, + WC_TYPE_DRAPERY = 0x04, + WC_TYPE_AWNING = 0x05, + WC_TYPE_SHUTTER = 0x06, + WC_TYPE_TILT_BLIND_TILT_ONLY = 0x07, + WC_TYPE_TILT_BLIND_LIFT_AND_TILT = 0x08, + WC_TYPE_PROJECTOR_SCREEN = 0x09, + WC_TYPE_UNKNOWN = 0xFF, +}; + +} // namespace WindowCovering + +} // namespace clusters +} // namespace app +} // namespace chip diff --git a/zzz_generated/bridge-app/zap-generated/cluster_objects_commands.cpp b/zzz_generated/bridge-app/zap-generated/cluster_objects_commands.cpp new file mode 100644 index 00000000000000..93855c49854709 --- /dev/null +++ b/zzz_generated/bridge-app/zap-generated/cluster_objects_commands.cpp @@ -0,0 +1,32 @@ +/* + * + * 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 "cluster_objects_commands.h" + +#include + +#pragma GCC diagnostic ignored "-Wstack-usage=" + +namespace chip { +namespace app { +namespace clusters { + +} // namespace clusters +} // namespace app +} // namespace chip diff --git a/zzz_generated/bridge-app/zap-generated/cluster_objects_commands.h b/zzz_generated/bridge-app/zap-generated/cluster_objects_commands.h new file mode 100644 index 00000000000000..b9f9a986dc7233 --- /dev/null +++ b/zzz_generated/bridge-app/zap-generated/cluster_objects_commands.h @@ -0,0 +1,35 @@ +/* + * + * 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 + +#pragma once + +#include +#include +#include +#include +#include +#include + +namespace chip { +namespace app { +namespace clusters { + +} // namespace clusters +} // namespace app +} // namespace chip diff --git a/zzz_generated/controller-clusters/zap-generated/CHIPClusters.cpp b/zzz_generated/controller-clusters/zap-generated/CHIPClusters.cpp index 320083ba999c95..73de9fc40a348c 100644 --- a/zzz_generated/controller-clusters/zap-generated/CHIPClusters.cpp +++ b/zzz_generated/controller-clusters/zap-generated/CHIPClusters.cpp @@ -21,20 +21,28 @@ #include +#include #include +#include +#include #include #include #include +#include #include +#include #include #include #include #include #include +#include namespace chip { +using namespace app; using namespace app::Clusters; +using namespace app::clusters; using namespace System; using namespace Encoding::LittleEndian; @@ -44,14 +52,47 @@ namespace Controller { // TODO(#4503): length should be passed to commands when byte string is in argument list. // TODO(#4503): Commands should take group id as an argument. +namespace { +void onClusterObjectCommandSenderFinal(CommandSender * sender, + app::ClusterObjectCommandSenderCallback * _this) +{ + Platform::Delete(sender); + Platform::Delete(_this); +} +} // namespace + // AccountLogin Cluster Commands +CHIP_ERROR AccountLoginCluster::GetSetupPIN(OnGetSetupPINCommandResponseCallbackFunct onSuccess, + OnCommandErrorCallbackFunct onFailure, + const app::clusters::AccountLogin::GetSetupPINCommandParams::Type & params) +{ + using ResponseCallbackType = clusters::AccountLogin::GetSetupPINResponseCommandParams::Type; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, AccountLogin::Commands::Ids::GetSetupPIN, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR AccountLoginCluster::GetSetupPIN(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, chip::ByteSpan tempAccountIdentifier) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -62,8 +103,11 @@ CHIP_ERROR AccountLoginCluster::GetSetupPIN(Callback::Cancelable * onSuccessCall app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, AccountLogin::Commands::Ids::GetSetupPIN, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -73,26 +117,47 @@ CHIP_ERROR AccountLoginCluster::GetSetupPIN(Callback::Cancelable * onSuccessCall SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR AccountLoginCluster::Login(OnLoginCommandResponseCallbackFunct onSuccess, OnCommandErrorCallbackFunct onFailure, + const app::clusters::AccountLogin::LoginCommandParams::Type & params) +{ + using ResponseCallbackType = void; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, AccountLogin::Commands::Ids::Login, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR AccountLoginCluster::Login(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, chip::ByteSpan tempAccountIdentifier, chip::ByteSpan setupPIN) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -103,8 +168,11 @@ CHIP_ERROR AccountLoginCluster::Login(Callback::Cancelable * onSuccessCallback, app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, AccountLogin::Commands::Ids::Login, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -116,16 +184,14 @@ CHIP_ERROR AccountLoginCluster::Login(Callback::Cancelable * onSuccessCallback, SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } @@ -143,14 +209,39 @@ CHIP_ERROR AccountLoginCluster::ReadAttributeClusterRevision(Callback::Cancelabl } // AdministratorCommissioning Cluster Commands +CHIP_ERROR AdministratorCommissioningCluster::OpenBasicCommissioningWindow( + OnOpenBasicCommissioningWindowCommandResponseCallbackFunct onSuccess, OnCommandErrorCallbackFunct onFailure, + const app::clusters::AdministratorCommissioning::OpenBasicCommissioningWindowCommandParams::Type & params) +{ + using ResponseCallbackType = void; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, + AdministratorCommissioning::Commands::Ids::OpenBasicCommissioningWindow, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR AdministratorCommissioningCluster::OpenBasicCommissioningWindow(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t commissioningTimeout) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -162,8 +253,11 @@ CHIP_ERROR AdministratorCommissioningCluster::OpenBasicCommissioningWindow(Callb AdministratorCommissioning::Commands::Ids::OpenBasicCommissioningWindow, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -173,29 +267,52 @@ CHIP_ERROR AdministratorCommissioningCluster::OpenBasicCommissioningWindow(Callb SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR AdministratorCommissioningCluster::OpenCommissioningWindow( + OnOpenCommissioningWindowCommandResponseCallbackFunct onSuccess, OnCommandErrorCallbackFunct onFailure, + const app::clusters::AdministratorCommissioning::OpenCommissioningWindowCommandParams::Type & params) +{ + using ResponseCallbackType = void; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, + AdministratorCommissioning::Commands::Ids::OpenCommissioningWindow, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR AdministratorCommissioningCluster::OpenCommissioningWindow(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t commissioningTimeout, chip::ByteSpan pAKEVerifier, uint16_t discriminator, uint32_t iterations, chip::ByteSpan salt, uint16_t passcodeID) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -207,8 +324,11 @@ CHIP_ERROR AdministratorCommissioningCluster::OpenCommissioningWindow(Callback:: AdministratorCommissioning::Commands::Ids::OpenCommissioningWindow, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -228,26 +348,49 @@ CHIP_ERROR AdministratorCommissioningCluster::OpenCommissioningWindow(Callback:: SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR AdministratorCommissioningCluster::RevokeCommissioning( + OnRevokeCommissioningCommandResponseCallbackFunct onSuccess, OnCommandErrorCallbackFunct onFailure, + const app::clusters::AdministratorCommissioning::RevokeCommissioningCommandParams::Type & params) +{ + using ResponseCallbackType = void; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, + AdministratorCommissioning::Commands::Ids::RevokeCommissioning, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR AdministratorCommissioningCluster::RevokeCommissioning(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -259,8 +402,11 @@ CHIP_ERROR AdministratorCommissioningCluster::RevokeCommissioning(Callback::Canc AdministratorCommissioning::Commands::Ids::RevokeCommissioning, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); // Command takes no arguments. @@ -268,16 +414,14 @@ CHIP_ERROR AdministratorCommissioningCluster::RevokeCommissioning(Callback::Canc SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } @@ -295,13 +439,37 @@ CHIP_ERROR AdministratorCommissioningCluster::ReadAttributeClusterRevision(Callb } // ApplicationBasic Cluster Commands +CHIP_ERROR ApplicationBasicCluster::ChangeStatus(OnChangeStatusCommandResponseCallbackFunct onSuccess, + OnCommandErrorCallbackFunct onFailure, + const app::clusters::ApplicationBasic::ChangeStatusCommandParams::Type & params) +{ + using ResponseCallbackType = void; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, ApplicationBasic::Commands::Ids::ChangeStatus, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR ApplicationBasicCluster::ChangeStatus(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint8_t status) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -312,8 +480,11 @@ CHIP_ERROR ApplicationBasicCluster::ChangeStatus(Callback::Cancelable * onSucces app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, ApplicationBasic::Commands::Ids::ChangeStatus, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -323,16 +494,14 @@ CHIP_ERROR ApplicationBasicCluster::ChangeStatus(Callback::Cancelable * onSucces SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } @@ -434,13 +603,37 @@ CHIP_ERROR ApplicationBasicCluster::ReadAttributeClusterRevision(Callback::Cance } // ApplicationLauncher Cluster Commands +CHIP_ERROR ApplicationLauncherCluster::LaunchApp(OnLaunchAppCommandResponseCallbackFunct onSuccess, + OnCommandErrorCallbackFunct onFailure, + const app::clusters::ApplicationLauncher::LaunchAppCommandParams::Type & params) +{ + using ResponseCallbackType = clusters::ApplicationLauncher::LaunchAppResponseCommandParams::Type; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, ApplicationLauncher::Commands::Ids::LaunchApp, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR ApplicationLauncherCluster::LaunchApp(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, chip::ByteSpan data, uint16_t catalogVendorId, chip::ByteSpan applicationId) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -451,8 +644,11 @@ CHIP_ERROR ApplicationLauncherCluster::LaunchApp(Callback::Cancelable * onSucces app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, ApplicationLauncher::Commands::Ids::LaunchApp, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -466,16 +662,14 @@ CHIP_ERROR ApplicationLauncherCluster::LaunchApp(Callback::Cancelable * onSucces SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } @@ -529,13 +723,37 @@ CHIP_ERROR ApplicationLauncherCluster::ReadAttributeClusterRevision(Callback::Ca } // AudioOutput Cluster Commands +CHIP_ERROR AudioOutputCluster::RenameOutput(OnRenameOutputCommandResponseCallbackFunct onSuccess, + OnCommandErrorCallbackFunct onFailure, + const app::clusters::AudioOutput::RenameOutputCommandParams::Type & params) +{ + using ResponseCallbackType = void; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, AudioOutput::Commands::Ids::RenameOutput, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR AudioOutputCluster::RenameOutput(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint8_t index, chip::ByteSpan name) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -546,8 +764,11 @@ CHIP_ERROR AudioOutputCluster::RenameOutput(Callback::Cancelable * onSuccessCall app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, AudioOutput::Commands::Ids::RenameOutput, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -559,26 +780,48 @@ CHIP_ERROR AudioOutputCluster::RenameOutput(Callback::Cancelable * onSuccessCall SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR AudioOutputCluster::SelectOutput(OnSelectOutputCommandResponseCallbackFunct onSuccess, + OnCommandErrorCallbackFunct onFailure, + const app::clusters::AudioOutput::SelectOutputCommandParams::Type & params) +{ + using ResponseCallbackType = void; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, AudioOutput::Commands::Ids::SelectOutput, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR AudioOutputCluster::SelectOutput(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint8_t index) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -589,8 +832,11 @@ CHIP_ERROR AudioOutputCluster::SelectOutput(Callback::Cancelable * onSuccessCall app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, AudioOutput::Commands::Ids::SelectOutput, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -600,16 +846,14 @@ CHIP_ERROR AudioOutputCluster::SelectOutput(Callback::Cancelable * onSuccessCall SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } @@ -651,13 +895,38 @@ CHIP_ERROR AudioOutputCluster::ReadAttributeClusterRevision(Callback::Cancelable } // BarrierControl Cluster Commands +CHIP_ERROR BarrierControlCluster::BarrierControlGoToPercent( + OnBarrierControlGoToPercentCommandResponseCallbackFunct onSuccess, OnCommandErrorCallbackFunct onFailure, + const app::clusters::BarrierControl::BarrierControlGoToPercentCommandParams::Type & params) +{ + using ResponseCallbackType = void; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, + BarrierControl::Commands::Ids::BarrierControlGoToPercent, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR BarrierControlCluster::BarrierControlGoToPercent(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint8_t percentOpen) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -669,8 +938,11 @@ CHIP_ERROR BarrierControlCluster::BarrierControlGoToPercent(Callback::Cancelable BarrierControl::Commands::Ids::BarrierControlGoToPercent, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -680,26 +952,49 @@ CHIP_ERROR BarrierControlCluster::BarrierControlGoToPercent(Callback::Cancelable SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR +BarrierControlCluster::BarrierControlStop(OnBarrierControlStopCommandResponseCallbackFunct onSuccess, + OnCommandErrorCallbackFunct onFailure, + const app::clusters::BarrierControl::BarrierControlStopCommandParams::Type & params) +{ + using ResponseCallbackType = void; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, BarrierControl::Commands::Ids::BarrierControlStop, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR BarrierControlCluster::BarrierControlStop(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -710,8 +1005,11 @@ CHIP_ERROR BarrierControlCluster::BarrierControlStop(Callback::Cancelable * onSu app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, BarrierControl::Commands::Ids::BarrierControlStop, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); // Command takes no arguments. @@ -719,16 +1017,14 @@ CHIP_ERROR BarrierControlCluster::BarrierControlStop(Callback::Cancelable * onSu SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } @@ -794,12 +1090,36 @@ CHIP_ERROR BarrierControlCluster::ReadAttributeClusterRevision(Callback::Cancela } // Basic Cluster Commands +CHIP_ERROR BasicCluster::MfgSpecificPing(OnMfgSpecificPingCommandResponseCallbackFunct onSuccess, + OnCommandErrorCallbackFunct onFailure, + const app::clusters::Basic::MfgSpecificPingCommandParams::Type & params) +{ + using ResponseCallbackType = void; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, Basic::Commands::Ids::MfgSpecificPing, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR BasicCluster::MfgSpecificPing(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -810,8 +1130,11 @@ CHIP_ERROR BasicCluster::MfgSpecificPing(Callback::Cancelable * onSuccessCallbac app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, Basic::Commands::Ids::MfgSpecificPing, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); // Command takes no arguments. @@ -819,16 +1142,14 @@ CHIP_ERROR BasicCluster::MfgSpecificPing(Callback::Cancelable * onSuccessCallbac SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } @@ -1227,13 +1548,36 @@ CHIP_ERROR BinaryInputBasicCluster::ReadAttributeClusterRevision(Callback::Cance } // Binding Cluster Commands +CHIP_ERROR BindingCluster::Bind(OnBindCommandResponseCallbackFunct onSuccess, OnCommandErrorCallbackFunct onFailure, + const app::clusters::Binding::BindCommandParams::Type & params) +{ + using ResponseCallbackType = void; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, Binding::Commands::Ids::Bind, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR BindingCluster::Bind(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, chip::NodeId nodeId, chip::GroupId groupId, chip::EndpointId endpointId, chip::ClusterId clusterId) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -1244,8 +1588,11 @@ CHIP_ERROR BindingCluster::Bind(Callback::Cancelable * onSuccessCallback, Callba app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, Binding::Commands::Ids::Bind, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -1261,27 +1608,48 @@ CHIP_ERROR BindingCluster::Bind(Callback::Cancelable * onSuccessCallback, Callba SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR BindingCluster::Unbind(OnUnbindCommandResponseCallbackFunct onSuccess, OnCommandErrorCallbackFunct onFailure, + const app::clusters::Binding::UnbindCommandParams::Type & params) +{ + using ResponseCallbackType = void; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, Binding::Commands::Ids::Unbind, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR BindingCluster::Unbind(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, chip::NodeId nodeId, chip::GroupId groupId, chip::EndpointId endpointId, chip::ClusterId clusterId) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -1292,8 +1660,11 @@ CHIP_ERROR BindingCluster::Unbind(Callback::Cancelable * onSuccessCallback, Call app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, Binding::Commands::Ids::Unbind, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -1309,16 +1680,14 @@ CHIP_ERROR BindingCluster::Unbind(Callback::Cancelable * onSuccessCallback, Call SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } @@ -1535,14 +1904,38 @@ CHIP_ERROR BridgedDeviceBasicCluster::ReadAttributeClusterRevision(Callback::Can } // ColorControl Cluster Commands +CHIP_ERROR ColorControlCluster::ColorLoopSet(OnColorLoopSetCommandResponseCallbackFunct onSuccess, + OnCommandErrorCallbackFunct onFailure, + const app::clusters::ColorControl::ColorLoopSetCommandParams::Type & params) +{ + using ResponseCallbackType = void; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, ColorControl::Commands::Ids::ColorLoopSet, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR ColorControlCluster::ColorLoopSet(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint8_t updateFlags, uint8_t action, uint8_t direction, uint16_t time, uint16_t startHue, uint8_t optionsMask, uint8_t optionsOverride) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -1553,8 +1946,11 @@ CHIP_ERROR ColorControlCluster::ColorLoopSet(Callback::Cancelable * onSuccessCal app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, ColorControl::Commands::Ids::ColorLoopSet, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -1576,26 +1972,48 @@ CHIP_ERROR ColorControlCluster::ColorLoopSet(Callback::Cancelable * onSuccessCal SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR ColorControlCluster::EnhancedMoveHue(OnEnhancedMoveHueCommandResponseCallbackFunct onSuccess, + OnCommandErrorCallbackFunct onFailure, + const app::clusters::ColorControl::EnhancedMoveHueCommandParams::Type & params) +{ + using ResponseCallbackType = void; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, ColorControl::Commands::Ids::EnhancedMoveHue, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR ColorControlCluster::EnhancedMoveHue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint8_t moveMode, uint16_t rate, uint8_t optionsMask, uint8_t optionsOverride) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -1606,8 +2024,11 @@ CHIP_ERROR ColorControlCluster::EnhancedMoveHue(Callback::Cancelable * onSuccess app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, ColorControl::Commands::Ids::EnhancedMoveHue, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -1623,27 +2044,49 @@ CHIP_ERROR ColorControlCluster::EnhancedMoveHue(Callback::Cancelable * onSuccess SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR ColorControlCluster::EnhancedMoveToHue(OnEnhancedMoveToHueCommandResponseCallbackFunct onSuccess, + OnCommandErrorCallbackFunct onFailure, + const app::clusters::ColorControl::EnhancedMoveToHueCommandParams::Type & params) +{ + using ResponseCallbackType = void; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, ColorControl::Commands::Ids::EnhancedMoveToHue, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR ColorControlCluster::EnhancedMoveToHue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t enhancedHue, uint8_t direction, uint16_t transitionTime, uint8_t optionsMask, uint8_t optionsOverride) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -1654,8 +2097,11 @@ CHIP_ERROR ColorControlCluster::EnhancedMoveToHue(Callback::Cancelable * onSucce app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, ColorControl::Commands::Ids::EnhancedMoveToHue, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -1673,28 +2119,51 @@ CHIP_ERROR ColorControlCluster::EnhancedMoveToHue(Callback::Cancelable * onSucce SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR ColorControlCluster::EnhancedMoveToHueAndSaturation( + OnEnhancedMoveToHueAndSaturationCommandResponseCallbackFunct onSuccess, OnCommandErrorCallbackFunct onFailure, + const app::clusters::ColorControl::EnhancedMoveToHueAndSaturationCommandParams::Type & params) +{ + using ResponseCallbackType = void; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, + ColorControl::Commands::Ids::EnhancedMoveToHueAndSaturation, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR ColorControlCluster::EnhancedMoveToHueAndSaturation(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t enhancedHue, uint8_t saturation, uint16_t transitionTime, uint8_t optionsMask, uint8_t optionsOverride) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -1706,8 +2175,11 @@ CHIP_ERROR ColorControlCluster::EnhancedMoveToHueAndSaturation(Callback::Cancela ColorControl::Commands::Ids::EnhancedMoveToHueAndSaturation, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -1725,27 +2197,49 @@ CHIP_ERROR ColorControlCluster::EnhancedMoveToHueAndSaturation(Callback::Cancela SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR ColorControlCluster::EnhancedStepHue(OnEnhancedStepHueCommandResponseCallbackFunct onSuccess, + OnCommandErrorCallbackFunct onFailure, + const app::clusters::ColorControl::EnhancedStepHueCommandParams::Type & params) +{ + using ResponseCallbackType = void; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, ColorControl::Commands::Ids::EnhancedStepHue, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR ColorControlCluster::EnhancedStepHue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint8_t stepMode, uint16_t stepSize, uint16_t transitionTime, uint8_t optionsMask, uint8_t optionsOverride) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -1756,8 +2250,11 @@ CHIP_ERROR ColorControlCluster::EnhancedStepHue(Callback::Cancelable * onSuccess app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, ColorControl::Commands::Ids::EnhancedStepHue, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -1775,26 +2272,47 @@ CHIP_ERROR ColorControlCluster::EnhancedStepHue(Callback::Cancelable * onSuccess SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR ColorControlCluster::MoveColor(OnMoveColorCommandResponseCallbackFunct onSuccess, OnCommandErrorCallbackFunct onFailure, + const app::clusters::ColorControl::MoveColorCommandParams::Type & params) +{ + using ResponseCallbackType = void; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, ColorControl::Commands::Ids::MoveColor, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR ColorControlCluster::MoveColor(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, int16_t rateX, int16_t rateY, uint8_t optionsMask, uint8_t optionsOverride) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -1805,8 +2323,11 @@ CHIP_ERROR ColorControlCluster::MoveColor(Callback::Cancelable * onSuccessCallba app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, ColorControl::Commands::Ids::MoveColor, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -1822,28 +2343,51 @@ CHIP_ERROR ColorControlCluster::MoveColor(Callback::Cancelable * onSuccessCallba SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR +ColorControlCluster::MoveColorTemperature(OnMoveColorTemperatureCommandResponseCallbackFunct onSuccess, + OnCommandErrorCallbackFunct onFailure, + const app::clusters::ColorControl::MoveColorTemperatureCommandParams::Type & params) +{ + using ResponseCallbackType = void; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, ColorControl::Commands::Ids::MoveColorTemperature, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR ColorControlCluster::MoveColorTemperature(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint8_t moveMode, uint16_t rate, uint16_t colorTemperatureMinimum, uint16_t colorTemperatureMaximum, uint8_t optionsMask, uint8_t optionsOverride) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -1854,8 +2398,11 @@ CHIP_ERROR ColorControlCluster::MoveColorTemperature(Callback::Cancelable * onSu app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, ColorControl::Commands::Ids::MoveColorTemperature, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -1875,26 +2422,47 @@ CHIP_ERROR ColorControlCluster::MoveColorTemperature(Callback::Cancelable * onSu SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR ColorControlCluster::MoveHue(OnMoveHueCommandResponseCallbackFunct onSuccess, OnCommandErrorCallbackFunct onFailure, + const app::clusters::ColorControl::MoveHueCommandParams::Type & params) +{ + using ResponseCallbackType = void; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, ColorControl::Commands::Ids::MoveHue, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR ColorControlCluster::MoveHue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint8_t moveMode, uint8_t rate, uint8_t optionsMask, uint8_t optionsOverride) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -1905,8 +2473,11 @@ CHIP_ERROR ColorControlCluster::MoveHue(Callback::Cancelable * onSuccessCallback app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, ColorControl::Commands::Ids::MoveHue, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -1922,29 +2493,51 @@ CHIP_ERROR ColorControlCluster::MoveHue(Callback::Cancelable * onSuccessCallback SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } -CHIP_ERROR ColorControlCluster::MoveSaturation(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, - uint8_t moveMode, uint8_t rate, uint8_t optionsMask, uint8_t optionsOverride) +CHIP_ERROR ColorControlCluster::MoveSaturation(OnMoveSaturationCommandResponseCallbackFunct onSuccess, + OnCommandErrorCallbackFunct onFailure, + const app::clusters::ColorControl::MoveSaturationCommandParams::Type & params) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + using ResponseCallbackType = void; - // Used when encoding non-empty command. Suppress error message when encoding empty commands. - (void) writer; + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, ColorControl::Commands::Ids::MoveSaturation, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + +CHIP_ERROR ColorControlCluster::MoveSaturation(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + uint8_t moveMode, uint8_t rate, uint8_t optionsMask, uint8_t optionsOverride) +{ + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; + + // Used when encoding non-empty command. Suppress error message when encoding empty commands. + (void) writer; (void) argSeqNumber; VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE); @@ -1952,8 +2545,11 @@ CHIP_ERROR ColorControlCluster::MoveSaturation(Callback::Cancelable * onSuccessC app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, ColorControl::Commands::Ids::MoveSaturation, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -1969,27 +2565,49 @@ CHIP_ERROR ColorControlCluster::MoveSaturation(Callback::Cancelable * onSuccessC SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR ColorControlCluster::MoveToColor(OnMoveToColorCommandResponseCallbackFunct onSuccess, + OnCommandErrorCallbackFunct onFailure, + const app::clusters::ColorControl::MoveToColorCommandParams::Type & params) +{ + using ResponseCallbackType = void; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, ColorControl::Commands::Ids::MoveToColor, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR ColorControlCluster::MoveToColor(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t colorX, uint16_t colorY, uint16_t transitionTime, uint8_t optionsMask, uint8_t optionsOverride) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -2000,8 +2618,11 @@ CHIP_ERROR ColorControlCluster::MoveToColor(Callback::Cancelable * onSuccessCall app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, ColorControl::Commands::Ids::MoveToColor, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -2019,27 +2640,51 @@ CHIP_ERROR ColorControlCluster::MoveToColor(Callback::Cancelable * onSuccessCall SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR +ColorControlCluster::MoveToColorTemperature(OnMoveToColorTemperatureCommandResponseCallbackFunct onSuccess, + OnCommandErrorCallbackFunct onFailure, + const app::clusters::ColorControl::MoveToColorTemperatureCommandParams::Type & params) +{ + using ResponseCallbackType = void; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, + ColorControl::Commands::Ids::MoveToColorTemperature, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR ColorControlCluster::MoveToColorTemperature(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t colorTemperature, uint16_t transitionTime, uint8_t optionsMask, uint8_t optionsOverride) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -2051,8 +2696,11 @@ CHIP_ERROR ColorControlCluster::MoveToColorTemperature(Callback::Cancelable * on ColorControl::Commands::Ids::MoveToColorTemperature, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -2068,27 +2716,48 @@ CHIP_ERROR ColorControlCluster::MoveToColorTemperature(Callback::Cancelable * on SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR ColorControlCluster::MoveToHue(OnMoveToHueCommandResponseCallbackFunct onSuccess, OnCommandErrorCallbackFunct onFailure, + const app::clusters::ColorControl::MoveToHueCommandParams::Type & params) +{ + using ResponseCallbackType = void; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, ColorControl::Commands::Ids::MoveToHue, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR ColorControlCluster::MoveToHue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint8_t hue, uint8_t direction, uint16_t transitionTime, uint8_t optionsMask, uint8_t optionsOverride) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -2099,8 +2768,11 @@ CHIP_ERROR ColorControlCluster::MoveToHue(Callback::Cancelable * onSuccessCallba app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, ColorControl::Commands::Ids::MoveToHue, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -2118,27 +2790,51 @@ CHIP_ERROR ColorControlCluster::MoveToHue(Callback::Cancelable * onSuccessCallba SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR +ColorControlCluster::MoveToHueAndSaturation(OnMoveToHueAndSaturationCommandResponseCallbackFunct onSuccess, + OnCommandErrorCallbackFunct onFailure, + const app::clusters::ColorControl::MoveToHueAndSaturationCommandParams::Type & params) +{ + using ResponseCallbackType = void; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, + ColorControl::Commands::Ids::MoveToHueAndSaturation, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR ColorControlCluster::MoveToHueAndSaturation(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint8_t hue, uint8_t saturation, uint16_t transitionTime, uint8_t optionsMask, uint8_t optionsOverride) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -2150,8 +2846,11 @@ CHIP_ERROR ColorControlCluster::MoveToHueAndSaturation(Callback::Cancelable * on ColorControl::Commands::Ids::MoveToHueAndSaturation, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -2169,27 +2868,49 @@ CHIP_ERROR ColorControlCluster::MoveToHueAndSaturation(Callback::Cancelable * on SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR ColorControlCluster::MoveToSaturation(OnMoveToSaturationCommandResponseCallbackFunct onSuccess, + OnCommandErrorCallbackFunct onFailure, + const app::clusters::ColorControl::MoveToSaturationCommandParams::Type & params) +{ + using ResponseCallbackType = void; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, ColorControl::Commands::Ids::MoveToSaturation, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR ColorControlCluster::MoveToSaturation(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint8_t saturation, uint16_t transitionTime, uint8_t optionsMask, uint8_t optionsOverride) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -2200,8 +2921,11 @@ CHIP_ERROR ColorControlCluster::MoveToSaturation(Callback::Cancelable * onSucces app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, ColorControl::Commands::Ids::MoveToSaturation, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -2217,27 +2941,48 @@ CHIP_ERROR ColorControlCluster::MoveToSaturation(Callback::Cancelable * onSucces SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR ColorControlCluster::StepColor(OnStepColorCommandResponseCallbackFunct onSuccess, OnCommandErrorCallbackFunct onFailure, + const app::clusters::ColorControl::StepColorCommandParams::Type & params) +{ + using ResponseCallbackType = void; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, ColorControl::Commands::Ids::StepColor, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR ColorControlCluster::StepColor(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, int16_t stepX, int16_t stepY, uint16_t transitionTime, uint8_t optionsMask, uint8_t optionsOverride) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -2248,8 +2993,11 @@ CHIP_ERROR ColorControlCluster::StepColor(Callback::Cancelable * onSuccessCallba app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, ColorControl::Commands::Ids::StepColor, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -2267,28 +3015,51 @@ CHIP_ERROR ColorControlCluster::StepColor(Callback::Cancelable * onSuccessCallba SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR +ColorControlCluster::StepColorTemperature(OnStepColorTemperatureCommandResponseCallbackFunct onSuccess, + OnCommandErrorCallbackFunct onFailure, + const app::clusters::ColorControl::StepColorTemperatureCommandParams::Type & params) +{ + using ResponseCallbackType = void; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, ColorControl::Commands::Ids::StepColorTemperature, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR ColorControlCluster::StepColorTemperature(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint8_t stepMode, uint16_t stepSize, uint16_t transitionTime, uint16_t colorTemperatureMinimum, uint16_t colorTemperatureMaximum, uint8_t optionsMask, uint8_t optionsOverride) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -2299,8 +3070,11 @@ CHIP_ERROR ColorControlCluster::StepColorTemperature(Callback::Cancelable * onSu app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, ColorControl::Commands::Ids::StepColorTemperature, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -2322,27 +3096,48 @@ CHIP_ERROR ColorControlCluster::StepColorTemperature(Callback::Cancelable * onSu SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR ColorControlCluster::StepHue(OnStepHueCommandResponseCallbackFunct onSuccess, OnCommandErrorCallbackFunct onFailure, + const app::clusters::ColorControl::StepHueCommandParams::Type & params) +{ + using ResponseCallbackType = void; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, ColorControl::Commands::Ids::StepHue, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR ColorControlCluster::StepHue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint8_t stepMode, uint8_t stepSize, uint16_t transitionTime, uint8_t optionsMask, uint8_t optionsOverride) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -2353,8 +3148,11 @@ CHIP_ERROR ColorControlCluster::StepHue(Callback::Cancelable * onSuccessCallback app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, ColorControl::Commands::Ids::StepHue, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -2372,27 +3170,49 @@ CHIP_ERROR ColorControlCluster::StepHue(Callback::Cancelable * onSuccessCallback SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR ColorControlCluster::StepSaturation(OnStepSaturationCommandResponseCallbackFunct onSuccess, + OnCommandErrorCallbackFunct onFailure, + const app::clusters::ColorControl::StepSaturationCommandParams::Type & params) +{ + using ResponseCallbackType = void; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, ColorControl::Commands::Ids::StepSaturation, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR ColorControlCluster::StepSaturation(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint8_t stepMode, uint8_t stepSize, uint16_t transitionTime, uint8_t optionsMask, uint8_t optionsOverride) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -2403,8 +3223,11 @@ CHIP_ERROR ColorControlCluster::StepSaturation(Callback::Cancelable * onSuccessC app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, ColorControl::Commands::Ids::StepSaturation, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -2422,26 +3245,48 @@ CHIP_ERROR ColorControlCluster::StepSaturation(Callback::Cancelable * onSuccessC SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR ColorControlCluster::StopMoveStep(OnStopMoveStepCommandResponseCallbackFunct onSuccess, + OnCommandErrorCallbackFunct onFailure, + const app::clusters::ColorControl::StopMoveStepCommandParams::Type & params) +{ + using ResponseCallbackType = void; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, ColorControl::Commands::Ids::StopMoveStep, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR ColorControlCluster::StopMoveStep(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint8_t optionsMask, uint8_t optionsOverride) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -2452,8 +3297,11 @@ CHIP_ERROR ColorControlCluster::StopMoveStep(Callback::Cancelable * onSuccessCal app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, ColorControl::Commands::Ids::StopMoveStep, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -2465,16 +3313,14 @@ CHIP_ERROR ColorControlCluster::StopMoveStep(Callback::Cancelable * onSuccessCal SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } @@ -3433,13 +4279,37 @@ CHIP_ERROR ColorControlCluster::ReadAttributeClusterRevision(Callback::Cancelabl } // ContentLauncher Cluster Commands +CHIP_ERROR ContentLauncherCluster::LaunchContent(OnLaunchContentCommandResponseCallbackFunct onSuccess, + OnCommandErrorCallbackFunct onFailure, + const app::clusters::ContentLauncher::LaunchContentCommandParams::Type & params) +{ + using ResponseCallbackType = clusters::ContentLauncher::LaunchContentResponseCommandParams::Type; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, ContentLauncher::Commands::Ids::LaunchContent, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR ContentLauncherCluster::LaunchContent(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, bool autoPlay, chip::ByteSpan data) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -3450,8 +4320,11 @@ CHIP_ERROR ContentLauncherCluster::LaunchContent(Callback::Cancelable * onSucces app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, ContentLauncher::Commands::Ids::LaunchContent, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -3463,26 +4336,48 @@ CHIP_ERROR ContentLauncherCluster::LaunchContent(Callback::Cancelable * onSucces SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR ContentLauncherCluster::LaunchURL(OnLaunchURLCommandResponseCallbackFunct onSuccess, + OnCommandErrorCallbackFunct onFailure, + const app::clusters::ContentLauncher::LaunchURLCommandParams::Type & params) +{ + using ResponseCallbackType = clusters::ContentLauncher::LaunchURLResponseCommandParams::Type; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, ContentLauncher::Commands::Ids::LaunchURL, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR ContentLauncherCluster::LaunchURL(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, chip::ByteSpan contentURL, chip::ByteSpan displayString) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -3493,8 +4388,11 @@ CHIP_ERROR ContentLauncherCluster::LaunchURL(Callback::Cancelable * onSuccessCal app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, ContentLauncher::Commands::Ids::LaunchURL, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -3506,16 +4404,14 @@ CHIP_ERROR ContentLauncherCluster::LaunchURL(Callback::Cancelable * onSuccessCal SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } @@ -3619,14 +4515,40 @@ CHIP_ERROR DescriptorCluster::ReadAttributeClusterRevision(Callback::Cancelable } // DiagnosticLogs Cluster Commands +CHIP_ERROR +DiagnosticLogsCluster::RetrieveLogsRequest(OnRetrieveLogsRequestCommandResponseCallbackFunct onSuccess, + OnCommandErrorCallbackFunct onFailure, + const app::clusters::DiagnosticLogs::RetrieveLogsRequestCommandParams::Type & params) +{ + using ResponseCallbackType = void; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, + DiagnosticLogs::Commands::Ids::RetrieveLogsRequest, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR DiagnosticLogsCluster::RetrieveLogsRequest(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint8_t intent, uint8_t requestedProtocol, chip::ByteSpan transferFileDesignator) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -3638,8 +4560,11 @@ CHIP_ERROR DiagnosticLogsCluster::RetrieveLogsRequest(Callback::Cancelable * onS DiagnosticLogs::Commands::Ids::RetrieveLogsRequest, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -3653,28 +4578,50 @@ CHIP_ERROR DiagnosticLogsCluster::RetrieveLogsRequest(Callback::Cancelable * onS SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } // DiagnosticLogs Cluster Attributes // DoorLock Cluster Commands +CHIP_ERROR DoorLockCluster::ClearAllPins(OnClearAllPinsCommandResponseCallbackFunct onSuccess, + OnCommandErrorCallbackFunct onFailure, + const app::clusters::DoorLock::ClearAllPinsCommandParams::Type & params) +{ + using ResponseCallbackType = clusters::DoorLock::ClearAllPinsResponseCommandParams::Type; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, DoorLock::Commands::Ids::ClearAllPins, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR DoorLockCluster::ClearAllPins(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -3685,8 +4632,11 @@ CHIP_ERROR DoorLockCluster::ClearAllPins(Callback::Cancelable * onSuccessCallbac app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, DoorLock::Commands::Ids::ClearAllPins, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); // Command takes no arguments. @@ -3694,25 +4644,47 @@ CHIP_ERROR DoorLockCluster::ClearAllPins(Callback::Cancelable * onSuccessCallbac SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR DoorLockCluster::ClearAllRfids(OnClearAllRfidsCommandResponseCallbackFunct onSuccess, + OnCommandErrorCallbackFunct onFailure, + const app::clusters::DoorLock::ClearAllRfidsCommandParams::Type & params) +{ + using ResponseCallbackType = clusters::DoorLock::ClearAllRfidsResponseCommandParams::Type; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, DoorLock::Commands::Ids::ClearAllRfids, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR DoorLockCluster::ClearAllRfids(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -3723,8 +4695,11 @@ CHIP_ERROR DoorLockCluster::ClearAllRfids(Callback::Cancelable * onSuccessCallba app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, DoorLock::Commands::Ids::ClearAllRfids, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); // Command takes no arguments. @@ -3732,26 +4707,48 @@ CHIP_ERROR DoorLockCluster::ClearAllRfids(Callback::Cancelable * onSuccessCallba SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR DoorLockCluster::ClearHolidaySchedule(OnClearHolidayScheduleCommandResponseCallbackFunct onSuccess, + OnCommandErrorCallbackFunct onFailure, + const app::clusters::DoorLock::ClearHolidayScheduleCommandParams::Type & params) +{ + using ResponseCallbackType = clusters::DoorLock::ClearHolidayScheduleResponseCommandParams::Type; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, DoorLock::Commands::Ids::ClearHolidaySchedule, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR DoorLockCluster::ClearHolidaySchedule(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint8_t scheduleId) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -3762,8 +4759,11 @@ CHIP_ERROR DoorLockCluster::ClearHolidaySchedule(Callback::Cancelable * onSucces app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, DoorLock::Commands::Ids::ClearHolidaySchedule, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -3773,26 +4773,47 @@ CHIP_ERROR DoorLockCluster::ClearHolidaySchedule(Callback::Cancelable * onSucces SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR DoorLockCluster::ClearPin(OnClearPinCommandResponseCallbackFunct onSuccess, OnCommandErrorCallbackFunct onFailure, + const app::clusters::DoorLock::ClearPinCommandParams::Type & params) +{ + using ResponseCallbackType = clusters::DoorLock::ClearPinResponseCommandParams::Type; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, DoorLock::Commands::Ids::ClearPin, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR DoorLockCluster::ClearPin(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t userId) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -3803,8 +4824,11 @@ CHIP_ERROR DoorLockCluster::ClearPin(Callback::Cancelable * onSuccessCallback, C app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, DoorLock::Commands::Ids::ClearPin, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -3814,26 +4838,47 @@ CHIP_ERROR DoorLockCluster::ClearPin(Callback::Cancelable * onSuccessCallback, C SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR DoorLockCluster::ClearRfid(OnClearRfidCommandResponseCallbackFunct onSuccess, OnCommandErrorCallbackFunct onFailure, + const app::clusters::DoorLock::ClearRfidCommandParams::Type & params) +{ + using ResponseCallbackType = clusters::DoorLock::ClearRfidResponseCommandParams::Type; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, DoorLock::Commands::Ids::ClearRfid, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR DoorLockCluster::ClearRfid(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t userId) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -3844,8 +4889,11 @@ CHIP_ERROR DoorLockCluster::ClearRfid(Callback::Cancelable * onSuccessCallback, app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, DoorLock::Commands::Ids::ClearRfid, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -3855,26 +4903,48 @@ CHIP_ERROR DoorLockCluster::ClearRfid(Callback::Cancelable * onSuccessCallback, SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR DoorLockCluster::ClearWeekdaySchedule(OnClearWeekdayScheduleCommandResponseCallbackFunct onSuccess, + OnCommandErrorCallbackFunct onFailure, + const app::clusters::DoorLock::ClearWeekdayScheduleCommandParams::Type & params) +{ + using ResponseCallbackType = clusters::DoorLock::ClearWeekdayScheduleResponseCommandParams::Type; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, DoorLock::Commands::Ids::ClearWeekdaySchedule, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR DoorLockCluster::ClearWeekdaySchedule(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint8_t scheduleId, uint16_t userId) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -3885,8 +4955,11 @@ CHIP_ERROR DoorLockCluster::ClearWeekdaySchedule(Callback::Cancelable * onSucces app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, DoorLock::Commands::Ids::ClearWeekdaySchedule, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -3898,26 +4971,48 @@ CHIP_ERROR DoorLockCluster::ClearWeekdaySchedule(Callback::Cancelable * onSucces SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR DoorLockCluster::ClearYeardaySchedule(OnClearYeardayScheduleCommandResponseCallbackFunct onSuccess, + OnCommandErrorCallbackFunct onFailure, + const app::clusters::DoorLock::ClearYeardayScheduleCommandParams::Type & params) +{ + using ResponseCallbackType = clusters::DoorLock::ClearYeardayScheduleResponseCommandParams::Type; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, DoorLock::Commands::Ids::ClearYeardaySchedule, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR DoorLockCluster::ClearYeardaySchedule(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint8_t scheduleId, uint16_t userId) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -3928,8 +5023,11 @@ CHIP_ERROR DoorLockCluster::ClearYeardaySchedule(Callback::Cancelable * onSucces app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, DoorLock::Commands::Ids::ClearYeardaySchedule, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -3941,26 +5039,48 @@ CHIP_ERROR DoorLockCluster::ClearYeardaySchedule(Callback::Cancelable * onSucces SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR DoorLockCluster::GetHolidaySchedule(OnGetHolidayScheduleCommandResponseCallbackFunct onSuccess, + OnCommandErrorCallbackFunct onFailure, + const app::clusters::DoorLock::GetHolidayScheduleCommandParams::Type & params) +{ + using ResponseCallbackType = clusters::DoorLock::GetHolidayScheduleResponseCommandParams::Type; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, DoorLock::Commands::Ids::GetHolidaySchedule, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR DoorLockCluster::GetHolidaySchedule(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint8_t scheduleId) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -3971,8 +5091,11 @@ CHIP_ERROR DoorLockCluster::GetHolidaySchedule(Callback::Cancelable * onSuccessC app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, DoorLock::Commands::Ids::GetHolidaySchedule, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -3982,28 +5105,50 @@ CHIP_ERROR DoorLockCluster::GetHolidaySchedule(Callback::Cancelable * onSuccessC SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } -CHIP_ERROR DoorLockCluster::GetLogRecord(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, - uint16_t logIndex) +CHIP_ERROR DoorLockCluster::GetLogRecord(OnGetLogRecordCommandResponseCallbackFunct onSuccess, + OnCommandErrorCallbackFunct onFailure, + const app::clusters::DoorLock::GetLogRecordCommandParams::Type & params) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + using ResponseCallbackType = clusters::DoorLock::GetLogRecordResponseCommandParams::Type; - // Used when encoding non-empty command. Suppress error message when encoding empty commands. + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, DoorLock::Commands::Ids::GetLogRecord, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + +CHIP_ERROR DoorLockCluster::GetLogRecord(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + uint16_t logIndex) +{ + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; + + // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; (void) argSeqNumber; @@ -4012,8 +5157,11 @@ CHIP_ERROR DoorLockCluster::GetLogRecord(Callback::Cancelable * onSuccessCallbac app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, DoorLock::Commands::Ids::GetLogRecord, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -4023,26 +5171,47 @@ CHIP_ERROR DoorLockCluster::GetLogRecord(Callback::Cancelable * onSuccessCallbac SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR DoorLockCluster::GetPin(OnGetPinCommandResponseCallbackFunct onSuccess, OnCommandErrorCallbackFunct onFailure, + const app::clusters::DoorLock::GetPinCommandParams::Type & params) +{ + using ResponseCallbackType = clusters::DoorLock::GetPinResponseCommandParams::Type; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, DoorLock::Commands::Ids::GetPin, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR DoorLockCluster::GetPin(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t userId) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -4053,8 +5222,11 @@ CHIP_ERROR DoorLockCluster::GetPin(Callback::Cancelable * onSuccessCallback, Cal app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, DoorLock::Commands::Ids::GetPin, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -4064,26 +5236,47 @@ CHIP_ERROR DoorLockCluster::GetPin(Callback::Cancelable * onSuccessCallback, Cal SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR DoorLockCluster::GetRfid(OnGetRfidCommandResponseCallbackFunct onSuccess, OnCommandErrorCallbackFunct onFailure, + const app::clusters::DoorLock::GetRfidCommandParams::Type & params) +{ + using ResponseCallbackType = clusters::DoorLock::GetRfidResponseCommandParams::Type; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, DoorLock::Commands::Ids::GetRfid, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR DoorLockCluster::GetRfid(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t userId) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -4094,8 +5287,11 @@ CHIP_ERROR DoorLockCluster::GetRfid(Callback::Cancelable * onSuccessCallback, Ca app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, DoorLock::Commands::Ids::GetRfid, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -4105,26 +5301,47 @@ CHIP_ERROR DoorLockCluster::GetRfid(Callback::Cancelable * onSuccessCallback, Ca SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR DoorLockCluster::GetUserType(OnGetUserTypeCommandResponseCallbackFunct onSuccess, OnCommandErrorCallbackFunct onFailure, + const app::clusters::DoorLock::GetUserTypeCommandParams::Type & params) +{ + using ResponseCallbackType = clusters::DoorLock::GetUserTypeResponseCommandParams::Type; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, DoorLock::Commands::Ids::GetUserType, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR DoorLockCluster::GetUserType(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t userId) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -4135,8 +5352,11 @@ CHIP_ERROR DoorLockCluster::GetUserType(Callback::Cancelable * onSuccessCallback app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, DoorLock::Commands::Ids::GetUserType, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -4146,26 +5366,48 @@ CHIP_ERROR DoorLockCluster::GetUserType(Callback::Cancelable * onSuccessCallback SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR DoorLockCluster::GetWeekdaySchedule(OnGetWeekdayScheduleCommandResponseCallbackFunct onSuccess, + OnCommandErrorCallbackFunct onFailure, + const app::clusters::DoorLock::GetWeekdayScheduleCommandParams::Type & params) +{ + using ResponseCallbackType = clusters::DoorLock::GetWeekdayScheduleResponseCommandParams::Type; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, DoorLock::Commands::Ids::GetWeekdaySchedule, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR DoorLockCluster::GetWeekdaySchedule(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint8_t scheduleId, uint16_t userId) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -4176,8 +5418,11 @@ CHIP_ERROR DoorLockCluster::GetWeekdaySchedule(Callback::Cancelable * onSuccessC app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, DoorLock::Commands::Ids::GetWeekdaySchedule, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -4189,26 +5434,48 @@ CHIP_ERROR DoorLockCluster::GetWeekdaySchedule(Callback::Cancelable * onSuccessC SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR DoorLockCluster::GetYeardaySchedule(OnGetYeardayScheduleCommandResponseCallbackFunct onSuccess, + OnCommandErrorCallbackFunct onFailure, + const app::clusters::DoorLock::GetYeardayScheduleCommandParams::Type & params) +{ + using ResponseCallbackType = clusters::DoorLock::GetYeardayScheduleResponseCommandParams::Type; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, DoorLock::Commands::Ids::GetYeardaySchedule, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR DoorLockCluster::GetYeardaySchedule(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint8_t scheduleId, uint16_t userId) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -4219,8 +5486,11 @@ CHIP_ERROR DoorLockCluster::GetYeardaySchedule(Callback::Cancelable * onSuccessC app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, DoorLock::Commands::Ids::GetYeardaySchedule, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -4232,26 +5502,47 @@ CHIP_ERROR DoorLockCluster::GetYeardaySchedule(Callback::Cancelable * onSuccessC SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR DoorLockCluster::LockDoor(OnLockDoorCommandResponseCallbackFunct onSuccess, OnCommandErrorCallbackFunct onFailure, + const app::clusters::DoorLock::LockDoorCommandParams::Type & params) +{ + using ResponseCallbackType = clusters::DoorLock::LockDoorResponseCommandParams::Type; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, DoorLock::Commands::Ids::LockDoor, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR DoorLockCluster::LockDoor(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, chip::ByteSpan pin) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -4262,8 +5553,11 @@ CHIP_ERROR DoorLockCluster::LockDoor(Callback::Cancelable * onSuccessCallback, C app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, DoorLock::Commands::Ids::LockDoor, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -4273,27 +5567,49 @@ CHIP_ERROR DoorLockCluster::LockDoor(Callback::Cancelable * onSuccessCallback, C SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR DoorLockCluster::SetHolidaySchedule(OnSetHolidayScheduleCommandResponseCallbackFunct onSuccess, + OnCommandErrorCallbackFunct onFailure, + const app::clusters::DoorLock::SetHolidayScheduleCommandParams::Type & params) +{ + using ResponseCallbackType = clusters::DoorLock::SetHolidayScheduleResponseCommandParams::Type; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, DoorLock::Commands::Ids::SetHolidaySchedule, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR DoorLockCluster::SetHolidaySchedule(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint8_t scheduleId, uint32_t localStartTime, uint32_t localEndTime, uint8_t operatingModeDuringHoliday) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -4304,8 +5620,11 @@ CHIP_ERROR DoorLockCluster::SetHolidaySchedule(Callback::Cancelable * onSuccessC app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, DoorLock::Commands::Ids::SetHolidaySchedule, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -4321,26 +5640,47 @@ CHIP_ERROR DoorLockCluster::SetHolidaySchedule(Callback::Cancelable * onSuccessC SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR DoorLockCluster::SetPin(OnSetPinCommandResponseCallbackFunct onSuccess, OnCommandErrorCallbackFunct onFailure, + const app::clusters::DoorLock::SetPinCommandParams::Type & params) +{ + using ResponseCallbackType = clusters::DoorLock::SetPinResponseCommandParams::Type; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, DoorLock::Commands::Ids::SetPin, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR DoorLockCluster::SetPin(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t userId, uint8_t userStatus, uint8_t userType, chip::ByteSpan pin) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -4351,8 +5691,11 @@ CHIP_ERROR DoorLockCluster::SetPin(Callback::Cancelable * onSuccessCallback, Cal app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, DoorLock::Commands::Ids::SetPin, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -4368,26 +5711,47 @@ CHIP_ERROR DoorLockCluster::SetPin(Callback::Cancelable * onSuccessCallback, Cal SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR DoorLockCluster::SetRfid(OnSetRfidCommandResponseCallbackFunct onSuccess, OnCommandErrorCallbackFunct onFailure, + const app::clusters::DoorLock::SetRfidCommandParams::Type & params) +{ + using ResponseCallbackType = clusters::DoorLock::SetRfidResponseCommandParams::Type; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, DoorLock::Commands::Ids::SetRfid, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR DoorLockCluster::SetRfid(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t userId, uint8_t userStatus, uint8_t userType, chip::ByteSpan id) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -4398,8 +5762,11 @@ CHIP_ERROR DoorLockCluster::SetRfid(Callback::Cancelable * onSuccessCallback, Ca app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, DoorLock::Commands::Ids::SetRfid, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -4415,26 +5782,47 @@ CHIP_ERROR DoorLockCluster::SetRfid(Callback::Cancelable * onSuccessCallback, Ca SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR DoorLockCluster::SetUserType(OnSetUserTypeCommandResponseCallbackFunct onSuccess, OnCommandErrorCallbackFunct onFailure, + const app::clusters::DoorLock::SetUserTypeCommandParams::Type & params) +{ + using ResponseCallbackType = clusters::DoorLock::SetUserTypeResponseCommandParams::Type; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, DoorLock::Commands::Ids::SetUserType, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR DoorLockCluster::SetUserType(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t userId, uint8_t userType) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -4445,8 +5833,11 @@ CHIP_ERROR DoorLockCluster::SetUserType(Callback::Cancelable * onSuccessCallback app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, DoorLock::Commands::Ids::SetUserType, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -4458,27 +5849,49 @@ CHIP_ERROR DoorLockCluster::SetUserType(Callback::Cancelable * onSuccessCallback SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR DoorLockCluster::SetWeekdaySchedule(OnSetWeekdayScheduleCommandResponseCallbackFunct onSuccess, + OnCommandErrorCallbackFunct onFailure, + const app::clusters::DoorLock::SetWeekdayScheduleCommandParams::Type & params) +{ + using ResponseCallbackType = clusters::DoorLock::SetWeekdayScheduleResponseCommandParams::Type; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, DoorLock::Commands::Ids::SetWeekdaySchedule, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR DoorLockCluster::SetWeekdaySchedule(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint8_t scheduleId, uint16_t userId, uint8_t daysMask, uint8_t startHour, uint8_t startMinute, uint8_t endHour, uint8_t endMinute) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -4489,8 +5902,11 @@ CHIP_ERROR DoorLockCluster::SetWeekdaySchedule(Callback::Cancelable * onSuccessC app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, DoorLock::Commands::Ids::SetWeekdaySchedule, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -4512,26 +5928,48 @@ CHIP_ERROR DoorLockCluster::SetWeekdaySchedule(Callback::Cancelable * onSuccessC SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR DoorLockCluster::SetYeardaySchedule(OnSetYeardayScheduleCommandResponseCallbackFunct onSuccess, + OnCommandErrorCallbackFunct onFailure, + const app::clusters::DoorLock::SetYeardayScheduleCommandParams::Type & params) +{ + using ResponseCallbackType = clusters::DoorLock::SetYeardayScheduleResponseCommandParams::Type; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, DoorLock::Commands::Ids::SetYeardaySchedule, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR DoorLockCluster::SetYeardaySchedule(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint8_t scheduleId, uint16_t userId, uint32_t localStartTime, uint32_t localEndTime) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -4542,8 +5980,11 @@ CHIP_ERROR DoorLockCluster::SetYeardaySchedule(Callback::Cancelable * onSuccessC app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, DoorLock::Commands::Ids::SetYeardaySchedule, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -4559,26 +6000,47 @@ CHIP_ERROR DoorLockCluster::SetYeardaySchedule(Callback::Cancelable * onSuccessC SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR DoorLockCluster::UnlockDoor(OnUnlockDoorCommandResponseCallbackFunct onSuccess, OnCommandErrorCallbackFunct onFailure, + const app::clusters::DoorLock::UnlockDoorCommandParams::Type & params) +{ + using ResponseCallbackType = clusters::DoorLock::UnlockDoorResponseCommandParams::Type; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, DoorLock::Commands::Ids::UnlockDoor, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR DoorLockCluster::UnlockDoor(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, chip::ByteSpan pin) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -4589,8 +6051,11 @@ CHIP_ERROR DoorLockCluster::UnlockDoor(Callback::Cancelable * onSuccessCallback, app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, DoorLock::Commands::Ids::UnlockDoor, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -4600,26 +6065,48 @@ CHIP_ERROR DoorLockCluster::UnlockDoor(Callback::Cancelable * onSuccessCallback, SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR DoorLockCluster::UnlockWithTimeout(OnUnlockWithTimeoutCommandResponseCallbackFunct onSuccess, + OnCommandErrorCallbackFunct onFailure, + const app::clusters::DoorLock::UnlockWithTimeoutCommandParams::Type & params) +{ + using ResponseCallbackType = clusters::DoorLock::UnlockWithTimeoutResponseCommandParams::Type; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, DoorLock::Commands::Ids::UnlockWithTimeout, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR DoorLockCluster::UnlockWithTimeout(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t timeoutInSeconds, chip::ByteSpan pin) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -4630,8 +6117,11 @@ CHIP_ERROR DoorLockCluster::UnlockWithTimeout(Callback::Cancelable * onSuccessCa app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, DoorLock::Commands::Ids::UnlockWithTimeout, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -4643,16 +6133,14 @@ CHIP_ERROR DoorLockCluster::UnlockWithTimeout(Callback::Cancelable * onSuccessCa SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } @@ -4871,13 +6359,38 @@ CHIP_ERROR ElectricalMeasurementCluster::ReadAttributeClusterRevision(Callback:: } // EthernetNetworkDiagnostics Cluster Commands +CHIP_ERROR EthernetNetworkDiagnosticsCluster::ResetCounts( + OnResetCountsCommandResponseCallbackFunct onSuccess, OnCommandErrorCallbackFunct onFailure, + const app::clusters::EthernetNetworkDiagnostics::ResetCountsCommandParams::Type & params) +{ + using ResponseCallbackType = void; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, + EthernetNetworkDiagnostics::Commands::Ids::ResetCounts, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR EthernetNetworkDiagnosticsCluster::ResetCounts(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -4889,8 +6402,11 @@ CHIP_ERROR EthernetNetworkDiagnosticsCluster::ResetCounts(Callback::Cancelable * EthernetNetworkDiagnostics::Commands::Ids::ResetCounts, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); // Command takes no arguments. @@ -4898,16 +6414,14 @@ CHIP_ERROR EthernetNetworkDiagnosticsCluster::ResetCounts(Callback::Cancelable * SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } @@ -5061,14 +6575,38 @@ CHIP_ERROR FlowMeasurementCluster::ReadAttributeClusterRevision(Callback::Cancel } // GeneralCommissioning Cluster Commands +CHIP_ERROR +GeneralCommissioningCluster::ArmFailSafe(OnArmFailSafeCommandResponseCallbackFunct onSuccess, OnCommandErrorCallbackFunct onFailure, + const app::clusters::GeneralCommissioning::ArmFailSafeCommandParams::Type & params) +{ + using ResponseCallbackType = clusters::GeneralCommissioning::ArmFailSafeResponseCommandParams::Type; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, GeneralCommissioning::Commands::Ids::ArmFailSafe, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR GeneralCommissioningCluster::ArmFailSafe(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t expiryLengthSeconds, uint64_t breadcrumb, uint32_t timeoutMs) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -5079,8 +6617,11 @@ CHIP_ERROR GeneralCommissioningCluster::ArmFailSafe(Callback::Cancelable * onSuc app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, GeneralCommissioning::Commands::Ids::ArmFailSafe, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -5094,26 +6635,49 @@ CHIP_ERROR GeneralCommissioningCluster::ArmFailSafe(Callback::Cancelable * onSuc SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR GeneralCommissioningCluster::CommissioningComplete( + OnCommissioningCompleteCommandResponseCallbackFunct onSuccess, OnCommandErrorCallbackFunct onFailure, + const app::clusters::GeneralCommissioning::CommissioningCompleteCommandParams::Type & params) +{ + using ResponseCallbackType = clusters::GeneralCommissioning::CommissioningCompleteResponseCommandParams::Type; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, + GeneralCommissioning::Commands::Ids::CommissioningComplete, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR GeneralCommissioningCluster::CommissioningComplete(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -5125,8 +6689,11 @@ CHIP_ERROR GeneralCommissioningCluster::CommissioningComplete(Callback::Cancelab GeneralCommissioning::Commands::Ids::CommissioningComplete, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); // Command takes no arguments. @@ -5134,27 +6701,50 @@ CHIP_ERROR GeneralCommissioningCluster::CommissioningComplete(Callback::Cancelab SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR GeneralCommissioningCluster::SetRegulatoryConfig( + OnSetRegulatoryConfigCommandResponseCallbackFunct onSuccess, OnCommandErrorCallbackFunct onFailure, + const app::clusters::GeneralCommissioning::SetRegulatoryConfigCommandParams::Type & params) +{ + using ResponseCallbackType = clusters::GeneralCommissioning::SetRegulatoryConfigResponseCommandParams::Type; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, + GeneralCommissioning::Commands::Ids::SetRegulatoryConfig, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR GeneralCommissioningCluster::SetRegulatoryConfig(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint8_t location, chip::ByteSpan countryCode, uint64_t breadcrumb, uint32_t timeoutMs) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -5166,8 +6756,11 @@ CHIP_ERROR GeneralCommissioningCluster::SetRegulatoryConfig(Callback::Cancelable GeneralCommissioning::Commands::Ids::SetRegulatoryConfig, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -5183,16 +6776,14 @@ CHIP_ERROR GeneralCommissioningCluster::SetRegulatoryConfig(Callback::Cancelable SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } @@ -5363,13 +6954,36 @@ CHIP_ERROR GroupKeyManagementCluster::ReadAttributeClusterRevision(Callback::Can } // Groups Cluster Commands +CHIP_ERROR GroupsCluster::AddGroup(OnAddGroupCommandResponseCallbackFunct onSuccess, OnCommandErrorCallbackFunct onFailure, + const app::clusters::Groups::AddGroupCommandParams::Type & params) +{ + using ResponseCallbackType = clusters::Groups::AddGroupResponseCommandParams::Type; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, Groups::Commands::Ids::AddGroup, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR GroupsCluster::AddGroup(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t groupId, chip::ByteSpan groupName) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -5380,8 +6994,11 @@ CHIP_ERROR GroupsCluster::AddGroup(Callback::Cancelable * onSuccessCallback, Cal app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, Groups::Commands::Ids::AddGroup, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -5393,26 +7010,48 @@ CHIP_ERROR GroupsCluster::AddGroup(Callback::Cancelable * onSuccessCallback, Cal SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR GroupsCluster::AddGroupIfIdentifying(OnAddGroupIfIdentifyingCommandResponseCallbackFunct onSuccess, + OnCommandErrorCallbackFunct onFailure, + const app::clusters::Groups::AddGroupIfIdentifyingCommandParams::Type & params) +{ + using ResponseCallbackType = void; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, Groups::Commands::Ids::AddGroupIfIdentifying, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR GroupsCluster::AddGroupIfIdentifying(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t groupId, chip::ByteSpan groupName) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -5423,8 +7062,11 @@ CHIP_ERROR GroupsCluster::AddGroupIfIdentifying(Callback::Cancelable * onSuccess app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, Groups::Commands::Ids::AddGroupIfIdentifying, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -5436,26 +7078,48 @@ CHIP_ERROR GroupsCluster::AddGroupIfIdentifying(Callback::Cancelable * onSuccess SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR GroupsCluster::GetGroupMembership(OnGetGroupMembershipCommandResponseCallbackFunct onSuccess, + OnCommandErrorCallbackFunct onFailure, + const app::clusters::Groups::GetGroupMembershipCommandParams::Type & params) +{ + using ResponseCallbackType = clusters::Groups::GetGroupMembershipResponseCommandParams::Type; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, Groups::Commands::Ids::GetGroupMembership, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR GroupsCluster::GetGroupMembership(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint8_t groupCount, uint16_t groupList) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -5466,8 +7130,11 @@ CHIP_ERROR GroupsCluster::GetGroupMembership(Callback::Cancelable * onSuccessCal app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, Groups::Commands::Ids::GetGroupMembership, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -5479,37 +7146,62 @@ CHIP_ERROR GroupsCluster::GetGroupMembership(Callback::Cancelable * onSuccessCal SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } -CHIP_ERROR GroupsCluster::RemoveAllGroups(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback) +CHIP_ERROR GroupsCluster::RemoveAllGroups(OnRemoveAllGroupsCommandResponseCallbackFunct onSuccess, + OnCommandErrorCallbackFunct onFailure, + const app::clusters::Groups::RemoveAllGroupsCommandParams::Type & params) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; - - // Used when encoding non-empty command. Suppress error message when encoding empty commands. - (void) writer; - (void) argSeqNumber; - - VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE); + using ResponseCallbackType = void; app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, Groups::Commands::Ids::RemoveAllGroups, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + +CHIP_ERROR GroupsCluster::RemoveAllGroups(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback) +{ + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; + + // Used when encoding non-empty command. Suppress error message when encoding empty commands. + (void) writer; + (void) argSeqNumber; + + VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE); + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, Groups::Commands::Ids::RemoveAllGroups, + (app::CommandPathFlags::kEndpointIdValid) }; + + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); // Command takes no arguments. @@ -5517,26 +7209,47 @@ CHIP_ERROR GroupsCluster::RemoveAllGroups(Callback::Cancelable * onSuccessCallba SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR GroupsCluster::RemoveGroup(OnRemoveGroupCommandResponseCallbackFunct onSuccess, OnCommandErrorCallbackFunct onFailure, + const app::clusters::Groups::RemoveGroupCommandParams::Type & params) +{ + using ResponseCallbackType = clusters::Groups::RemoveGroupResponseCommandParams::Type; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, Groups::Commands::Ids::RemoveGroup, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR GroupsCluster::RemoveGroup(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t groupId) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -5547,8 +7260,11 @@ CHIP_ERROR GroupsCluster::RemoveGroup(Callback::Cancelable * onSuccessCallback, app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, Groups::Commands::Ids::RemoveGroup, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -5558,26 +7274,47 @@ CHIP_ERROR GroupsCluster::RemoveGroup(Callback::Cancelable * onSuccessCallback, SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR GroupsCluster::ViewGroup(OnViewGroupCommandResponseCallbackFunct onSuccess, OnCommandErrorCallbackFunct onFailure, + const app::clusters::Groups::ViewGroupCommandParams::Type & params) +{ + using ResponseCallbackType = clusters::Groups::ViewGroupResponseCommandParams::Type; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, Groups::Commands::Ids::ViewGroup, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR GroupsCluster::ViewGroup(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t groupId) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -5588,8 +7325,11 @@ CHIP_ERROR GroupsCluster::ViewGroup(Callback::Cancelable * onSuccessCallback, Ca app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, Groups::Commands::Ids::ViewGroup, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -5599,16 +7339,14 @@ CHIP_ERROR GroupsCluster::ViewGroup(Callback::Cancelable * onSuccessCallback, Ca SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } @@ -5638,13 +7376,36 @@ CHIP_ERROR GroupsCluster::ReadAttributeClusterRevision(Callback::Cancelable * on } // Identify Cluster Commands +CHIP_ERROR IdentifyCluster::Identify(OnIdentifyCommandResponseCallbackFunct onSuccess, OnCommandErrorCallbackFunct onFailure, + const app::clusters::Identify::IdentifyCommandParams::Type & params) +{ + using ResponseCallbackType = void; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, Identify::Commands::Ids::Identify, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR IdentifyCluster::Identify(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t identifyTime) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -5655,8 +7416,11 @@ CHIP_ERROR IdentifyCluster::Identify(Callback::Cancelable * onSuccessCallback, C app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, Identify::Commands::Ids::Identify, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -5666,25 +7430,47 @@ CHIP_ERROR IdentifyCluster::Identify(Callback::Cancelable * onSuccessCallback, C SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR IdentifyCluster::IdentifyQuery(OnIdentifyQueryCommandResponseCallbackFunct onSuccess, + OnCommandErrorCallbackFunct onFailure, + const app::clusters::Identify::IdentifyQueryCommandParams::Type & params) +{ + using ResponseCallbackType = clusters::Identify::IdentifyQueryResponseCommandParams::Type; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, Identify::Commands::Ids::IdentifyQuery, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR IdentifyCluster::IdentifyQuery(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -5695,8 +7481,11 @@ CHIP_ERROR IdentifyCluster::IdentifyQuery(Callback::Cancelable * onSuccessCallba app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, Identify::Commands::Ids::IdentifyQuery, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); // Command takes no arguments. @@ -5704,16 +7493,14 @@ CHIP_ERROR IdentifyCluster::IdentifyQuery(Callback::Cancelable * onSuccessCallba SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } @@ -5760,13 +7547,36 @@ CHIP_ERROR IdentifyCluster::ReadAttributeClusterRevision(Callback::Cancelable * } // KeypadInput Cluster Commands +CHIP_ERROR KeypadInputCluster::SendKey(OnSendKeyCommandResponseCallbackFunct onSuccess, OnCommandErrorCallbackFunct onFailure, + const app::clusters::KeypadInput::SendKeyCommandParams::Type & params) +{ + using ResponseCallbackType = clusters::KeypadInput::SendKeyResponseCommandParams::Type; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, KeypadInput::Commands::Ids::SendKey, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR KeypadInputCluster::SendKey(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint8_t keyCode) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -5777,8 +7587,11 @@ CHIP_ERROR KeypadInputCluster::SendKey(Callback::Cancelable * onSuccessCallback, app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, KeypadInput::Commands::Ids::SendKey, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -5788,16 +7601,14 @@ CHIP_ERROR KeypadInputCluster::SendKey(Callback::Cancelable * onSuccessCallback, SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } @@ -5815,13 +7626,36 @@ CHIP_ERROR KeypadInputCluster::ReadAttributeClusterRevision(Callback::Cancelable } // LevelControl Cluster Commands +CHIP_ERROR LevelControlCluster::Move(OnMoveCommandResponseCallbackFunct onSuccess, OnCommandErrorCallbackFunct onFailure, + const app::clusters::LevelControl::MoveCommandParams::Type & params) +{ + using ResponseCallbackType = void; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, LevelControl::Commands::Ids::Move, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR LevelControlCluster::Move(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint8_t moveMode, uint8_t rate, uint8_t optionMask, uint8_t optionOverride) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -5832,8 +7666,11 @@ CHIP_ERROR LevelControlCluster::Move(Callback::Cancelable * onSuccessCallback, C app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, LevelControl::Commands::Ids::Move, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -5849,26 +7686,48 @@ CHIP_ERROR LevelControlCluster::Move(Callback::Cancelable * onSuccessCallback, C SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR LevelControlCluster::MoveToLevel(OnMoveToLevelCommandResponseCallbackFunct onSuccess, + OnCommandErrorCallbackFunct onFailure, + const app::clusters::LevelControl::MoveToLevelCommandParams::Type & params) +{ + using ResponseCallbackType = void; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, LevelControl::Commands::Ids::MoveToLevel, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR LevelControlCluster::MoveToLevel(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint8_t level, uint16_t transitionTime, uint8_t optionMask, uint8_t optionOverride) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -5879,8 +7738,11 @@ CHIP_ERROR LevelControlCluster::MoveToLevel(Callback::Cancelable * onSuccessCall app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, LevelControl::Commands::Ids::MoveToLevel, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -5896,27 +7758,50 @@ CHIP_ERROR LevelControlCluster::MoveToLevel(Callback::Cancelable * onSuccessCall SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR +LevelControlCluster::MoveToLevelWithOnOff(OnMoveToLevelWithOnOffCommandResponseCallbackFunct onSuccess, + OnCommandErrorCallbackFunct onFailure, + const app::clusters::LevelControl::MoveToLevelWithOnOffCommandParams::Type & params) +{ + using ResponseCallbackType = void; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, LevelControl::Commands::Ids::MoveToLevelWithOnOff, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR LevelControlCluster::MoveToLevelWithOnOff(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint8_t level, uint16_t transitionTime) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -5927,8 +7812,11 @@ CHIP_ERROR LevelControlCluster::MoveToLevelWithOnOff(Callback::Cancelable * onSu app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, LevelControl::Commands::Ids::MoveToLevelWithOnOff, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -5940,26 +7828,48 @@ CHIP_ERROR LevelControlCluster::MoveToLevelWithOnOff(Callback::Cancelable * onSu SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR LevelControlCluster::MoveWithOnOff(OnMoveWithOnOffCommandResponseCallbackFunct onSuccess, + OnCommandErrorCallbackFunct onFailure, + const app::clusters::LevelControl::MoveWithOnOffCommandParams::Type & params) +{ + using ResponseCallbackType = void; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, LevelControl::Commands::Ids::MoveWithOnOff, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR LevelControlCluster::MoveWithOnOff(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint8_t moveMode, uint8_t rate) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -5970,8 +7880,11 @@ CHIP_ERROR LevelControlCluster::MoveWithOnOff(Callback::Cancelable * onSuccessCa app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, LevelControl::Commands::Ids::MoveWithOnOff, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -5983,27 +7896,48 @@ CHIP_ERROR LevelControlCluster::MoveWithOnOff(Callback::Cancelable * onSuccessCa SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR LevelControlCluster::Step(OnStepCommandResponseCallbackFunct onSuccess, OnCommandErrorCallbackFunct onFailure, + const app::clusters::LevelControl::StepCommandParams::Type & params) +{ + using ResponseCallbackType = void; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, LevelControl::Commands::Ids::Step, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR LevelControlCluster::Step(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint8_t stepMode, uint8_t stepSize, uint16_t transitionTime, uint8_t optionMask, uint8_t optionOverride) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -6014,8 +7948,11 @@ CHIP_ERROR LevelControlCluster::Step(Callback::Cancelable * onSuccessCallback, C app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, LevelControl::Commands::Ids::Step, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -6033,26 +7970,48 @@ CHIP_ERROR LevelControlCluster::Step(Callback::Cancelable * onSuccessCallback, C SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR LevelControlCluster::StepWithOnOff(OnStepWithOnOffCommandResponseCallbackFunct onSuccess, + OnCommandErrorCallbackFunct onFailure, + const app::clusters::LevelControl::StepWithOnOffCommandParams::Type & params) +{ + using ResponseCallbackType = void; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, LevelControl::Commands::Ids::StepWithOnOff, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR LevelControlCluster::StepWithOnOff(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint8_t stepMode, uint8_t stepSize, uint16_t transitionTime) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -6063,8 +8022,11 @@ CHIP_ERROR LevelControlCluster::StepWithOnOff(Callback::Cancelable * onSuccessCa app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, LevelControl::Commands::Ids::StepWithOnOff, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -6078,26 +8040,47 @@ CHIP_ERROR LevelControlCluster::StepWithOnOff(Callback::Cancelable * onSuccessCa SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR LevelControlCluster::Stop(OnStopCommandResponseCallbackFunct onSuccess, OnCommandErrorCallbackFunct onFailure, + const app::clusters::LevelControl::StopCommandParams::Type & params) +{ + using ResponseCallbackType = void; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, LevelControl::Commands::Ids::Stop, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR LevelControlCluster::Stop(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint8_t optionMask, uint8_t optionOverride) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -6108,8 +8091,11 @@ CHIP_ERROR LevelControlCluster::Stop(Callback::Cancelable * onSuccessCallback, C app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, LevelControl::Commands::Ids::Stop, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -6121,25 +8107,47 @@ CHIP_ERROR LevelControlCluster::Stop(Callback::Cancelable * onSuccessCallback, C SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR LevelControlCluster::StopWithOnOff(OnStopWithOnOffCommandResponseCallbackFunct onSuccess, + OnCommandErrorCallbackFunct onFailure, + const app::clusters::LevelControl::StopWithOnOffCommandParams::Type & params) +{ + using ResponseCallbackType = void; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, LevelControl::Commands::Ids::StopWithOnOff, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR LevelControlCluster::StopWithOnOff(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -6150,8 +8158,11 @@ CHIP_ERROR LevelControlCluster::StopWithOnOff(Callback::Cancelable * onSuccessCa app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, LevelControl::Commands::Ids::StopWithOnOff, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); // Command takes no arguments. @@ -6159,16 +8170,14 @@ CHIP_ERROR LevelControlCluster::StopWithOnOff(Callback::Cancelable * onSuccessCa SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } @@ -6217,12 +8226,35 @@ CHIP_ERROR LevelControlCluster::ReadAttributeClusterRevision(Callback::Cancelabl } // LowPower Cluster Commands +CHIP_ERROR LowPowerCluster::Sleep(OnSleepCommandResponseCallbackFunct onSuccess, OnCommandErrorCallbackFunct onFailure, + const app::clusters::LowPower::SleepCommandParams::Type & params) +{ + using ResponseCallbackType = void; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, LowPower::Commands::Ids::Sleep, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR LowPowerCluster::Sleep(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -6233,8 +8265,11 @@ CHIP_ERROR LowPowerCluster::Sleep(Callback::Cancelable * onSuccessCallback, Call app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, LowPower::Commands::Ids::Sleep, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); // Command takes no arguments. @@ -6242,16 +8277,14 @@ CHIP_ERROR LowPowerCluster::Sleep(Callback::Cancelable * onSuccessCallback, Call SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } @@ -6269,12 +8302,36 @@ CHIP_ERROR LowPowerCluster::ReadAttributeClusterRevision(Callback::Cancelable * } // MediaInput Cluster Commands +CHIP_ERROR MediaInputCluster::HideInputStatus(OnHideInputStatusCommandResponseCallbackFunct onSuccess, + OnCommandErrorCallbackFunct onFailure, + const app::clusters::MediaInput::HideInputStatusCommandParams::Type & params) +{ + using ResponseCallbackType = void; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, MediaInput::Commands::Ids::HideInputStatus, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR MediaInputCluster::HideInputStatus(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -6285,8 +8342,11 @@ CHIP_ERROR MediaInputCluster::HideInputStatus(Callback::Cancelable * onSuccessCa app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, MediaInput::Commands::Ids::HideInputStatus, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); // Command takes no arguments. @@ -6294,26 +8354,48 @@ CHIP_ERROR MediaInputCluster::HideInputStatus(Callback::Cancelable * onSuccessCa SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR MediaInputCluster::RenameInput(OnRenameInputCommandResponseCallbackFunct onSuccess, + OnCommandErrorCallbackFunct onFailure, + const app::clusters::MediaInput::RenameInputCommandParams::Type & params) +{ + using ResponseCallbackType = void; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, MediaInput::Commands::Ids::RenameInput, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR MediaInputCluster::RenameInput(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint8_t index, chip::ByteSpan name) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -6324,8 +8406,11 @@ CHIP_ERROR MediaInputCluster::RenameInput(Callback::Cancelable * onSuccessCallba app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, MediaInput::Commands::Ids::RenameInput, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -6337,26 +8422,48 @@ CHIP_ERROR MediaInputCluster::RenameInput(Callback::Cancelable * onSuccessCallba SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR MediaInputCluster::SelectInput(OnSelectInputCommandResponseCallbackFunct onSuccess, + OnCommandErrorCallbackFunct onFailure, + const app::clusters::MediaInput::SelectInputCommandParams::Type & params) +{ + using ResponseCallbackType = void; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, MediaInput::Commands::Ids::SelectInput, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR MediaInputCluster::SelectInput(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint8_t index) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -6367,8 +8474,11 @@ CHIP_ERROR MediaInputCluster::SelectInput(Callback::Cancelable * onSuccessCallba app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, MediaInput::Commands::Ids::SelectInput, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -6378,25 +8488,47 @@ CHIP_ERROR MediaInputCluster::SelectInput(Callback::Cancelable * onSuccessCallba SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR MediaInputCluster::ShowInputStatus(OnShowInputStatusCommandResponseCallbackFunct onSuccess, + OnCommandErrorCallbackFunct onFailure, + const app::clusters::MediaInput::ShowInputStatusCommandParams::Type & params) +{ + using ResponseCallbackType = void; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, MediaInput::Commands::Ids::ShowInputStatus, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR MediaInputCluster::ShowInputStatus(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -6407,8 +8539,11 @@ CHIP_ERROR MediaInputCluster::ShowInputStatus(Callback::Cancelable * onSuccessCa app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, MediaInput::Commands::Ids::ShowInputStatus, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); // Command takes no arguments. @@ -6416,16 +8551,14 @@ CHIP_ERROR MediaInputCluster::ShowInputStatus(Callback::Cancelable * onSuccessCa SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } @@ -6467,13 +8600,37 @@ CHIP_ERROR MediaInputCluster::ReadAttributeClusterRevision(Callback::Cancelable } // MediaPlayback Cluster Commands +CHIP_ERROR MediaPlaybackCluster::MediaFastForward(OnMediaFastForwardCommandResponseCallbackFunct onSuccess, + OnCommandErrorCallbackFunct onFailure, + const app::clusters::MediaPlayback::MediaFastForwardCommandParams::Type & params) +{ + using ResponseCallbackType = clusters::MediaPlayback::MediaFastForwardResponseCommandParams::Type; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, MediaPlayback::Commands::Ids::MediaFastForward, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR MediaPlaybackCluster::MediaFastForward(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -6484,8 +8641,11 @@ CHIP_ERROR MediaPlaybackCluster::MediaFastForward(Callback::Cancelable * onSucce app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, MediaPlayback::Commands::Ids::MediaFastForward, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); // Command takes no arguments. @@ -6493,25 +8653,46 @@ CHIP_ERROR MediaPlaybackCluster::MediaFastForward(Callback::Cancelable * onSucce SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR MediaPlaybackCluster::MediaNext(OnMediaNextCommandResponseCallbackFunct onSuccess, OnCommandErrorCallbackFunct onFailure, + const app::clusters::MediaPlayback::MediaNextCommandParams::Type & params) +{ + using ResponseCallbackType = clusters::MediaPlayback::MediaNextResponseCommandParams::Type; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, MediaPlayback::Commands::Ids::MediaNext, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR MediaPlaybackCluster::MediaNext(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -6522,8 +8703,11 @@ CHIP_ERROR MediaPlaybackCluster::MediaNext(Callback::Cancelable * onSuccessCallb app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, MediaPlayback::Commands::Ids::MediaNext, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); // Command takes no arguments. @@ -6531,25 +8715,47 @@ CHIP_ERROR MediaPlaybackCluster::MediaNext(Callback::Cancelable * onSuccessCallb SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR MediaPlaybackCluster::MediaPause(OnMediaPauseCommandResponseCallbackFunct onSuccess, + OnCommandErrorCallbackFunct onFailure, + const app::clusters::MediaPlayback::MediaPauseCommandParams::Type & params) +{ + using ResponseCallbackType = clusters::MediaPlayback::MediaPauseResponseCommandParams::Type; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, MediaPlayback::Commands::Ids::MediaPause, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR MediaPlaybackCluster::MediaPause(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -6560,8 +8766,11 @@ CHIP_ERROR MediaPlaybackCluster::MediaPause(Callback::Cancelable * onSuccessCall app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, MediaPlayback::Commands::Ids::MediaPause, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); // Command takes no arguments. @@ -6569,25 +8778,46 @@ CHIP_ERROR MediaPlaybackCluster::MediaPause(Callback::Cancelable * onSuccessCall SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR MediaPlaybackCluster::MediaPlay(OnMediaPlayCommandResponseCallbackFunct onSuccess, OnCommandErrorCallbackFunct onFailure, + const app::clusters::MediaPlayback::MediaPlayCommandParams::Type & params) +{ + using ResponseCallbackType = clusters::MediaPlayback::MediaPlayResponseCommandParams::Type; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, MediaPlayback::Commands::Ids::MediaPlay, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR MediaPlaybackCluster::MediaPlay(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -6598,34 +8828,59 @@ CHIP_ERROR MediaPlaybackCluster::MediaPlay(Callback::Cancelable * onSuccessCallb app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, MediaPlayback::Commands::Ids::MediaPlay, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); // Command takes no arguments. - SuccessOrExit(err = sender->FinishCommand()); + SuccessOrExit(err = sender->FinishCommand()); + + // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); + + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); +exit: + return err; +} + +CHIP_ERROR MediaPlaybackCluster::MediaPrevious(OnMediaPreviousCommandResponseCallbackFunct onSuccess, + OnCommandErrorCallbackFunct onFailure, + const app::clusters::MediaPlayback::MediaPreviousCommandParams::Type & params) +{ + using ResponseCallbackType = clusters::MediaPlayback::MediaPreviousResponseCommandParams::Type; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, MediaPlayback::Commands::Ids::MediaPrevious, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); - // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + auto sender = Platform::MakeUnique(callback.get()); - err = mDevice->SendCommands(sender); + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); -exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } - return err; + sender.release(); + callback.release(); + return CHIP_NO_ERROR; } CHIP_ERROR MediaPlaybackCluster::MediaPrevious(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -6636,8 +8891,11 @@ CHIP_ERROR MediaPlaybackCluster::MediaPrevious(Callback::Cancelable * onSuccessC app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, MediaPlayback::Commands::Ids::MediaPrevious, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); // Command takes no arguments. @@ -6645,25 +8903,47 @@ CHIP_ERROR MediaPlaybackCluster::MediaPrevious(Callback::Cancelable * onSuccessC SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR MediaPlaybackCluster::MediaRewind(OnMediaRewindCommandResponseCallbackFunct onSuccess, + OnCommandErrorCallbackFunct onFailure, + const app::clusters::MediaPlayback::MediaRewindCommandParams::Type & params) +{ + using ResponseCallbackType = clusters::MediaPlayback::MediaRewindResponseCommandParams::Type; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, MediaPlayback::Commands::Ids::MediaRewind, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR MediaPlaybackCluster::MediaRewind(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -6674,8 +8954,11 @@ CHIP_ERROR MediaPlaybackCluster::MediaRewind(Callback::Cancelable * onSuccessCal app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, MediaPlayback::Commands::Ids::MediaRewind, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); // Command takes no arguments. @@ -6683,26 +8966,47 @@ CHIP_ERROR MediaPlaybackCluster::MediaRewind(Callback::Cancelable * onSuccessCal SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR MediaPlaybackCluster::MediaSeek(OnMediaSeekCommandResponseCallbackFunct onSuccess, OnCommandErrorCallbackFunct onFailure, + const app::clusters::MediaPlayback::MediaSeekCommandParams::Type & params) +{ + using ResponseCallbackType = clusters::MediaPlayback::MediaSeekResponseCommandParams::Type; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, MediaPlayback::Commands::Ids::MediaSeek, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR MediaPlaybackCluster::MediaSeek(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint64_t position) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -6713,8 +9017,11 @@ CHIP_ERROR MediaPlaybackCluster::MediaSeek(Callback::Cancelable * onSuccessCallb app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, MediaPlayback::Commands::Ids::MediaSeek, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -6724,26 +9031,49 @@ CHIP_ERROR MediaPlaybackCluster::MediaSeek(Callback::Cancelable * onSuccessCallb SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR +MediaPlaybackCluster::MediaSkipBackward(OnMediaSkipBackwardCommandResponseCallbackFunct onSuccess, + OnCommandErrorCallbackFunct onFailure, + const app::clusters::MediaPlayback::MediaSkipBackwardCommandParams::Type & params) +{ + using ResponseCallbackType = clusters::MediaPlayback::MediaSkipBackwardResponseCommandParams::Type; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, MediaPlayback::Commands::Ids::MediaSkipBackward, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR MediaPlaybackCluster::MediaSkipBackward(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint64_t deltaPositionMilliseconds) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -6754,8 +9084,11 @@ CHIP_ERROR MediaPlaybackCluster::MediaSkipBackward(Callback::Cancelable * onSucc app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, MediaPlayback::Commands::Ids::MediaSkipBackward, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -6765,26 +9098,48 @@ CHIP_ERROR MediaPlaybackCluster::MediaSkipBackward(Callback::Cancelable * onSucc SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR MediaPlaybackCluster::MediaSkipForward(OnMediaSkipForwardCommandResponseCallbackFunct onSuccess, + OnCommandErrorCallbackFunct onFailure, + const app::clusters::MediaPlayback::MediaSkipForwardCommandParams::Type & params) +{ + using ResponseCallbackType = clusters::MediaPlayback::MediaSkipForwardResponseCommandParams::Type; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, MediaPlayback::Commands::Ids::MediaSkipForward, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR MediaPlaybackCluster::MediaSkipForward(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint64_t deltaPositionMilliseconds) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -6795,8 +9150,11 @@ CHIP_ERROR MediaPlaybackCluster::MediaSkipForward(Callback::Cancelable * onSucce app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, MediaPlayback::Commands::Ids::MediaSkipForward, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -6806,25 +9164,47 @@ CHIP_ERROR MediaPlaybackCluster::MediaSkipForward(Callback::Cancelable * onSucce SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR MediaPlaybackCluster::MediaStartOver(OnMediaStartOverCommandResponseCallbackFunct onSuccess, + OnCommandErrorCallbackFunct onFailure, + const app::clusters::MediaPlayback::MediaStartOverCommandParams::Type & params) +{ + using ResponseCallbackType = clusters::MediaPlayback::MediaStartOverResponseCommandParams::Type; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, MediaPlayback::Commands::Ids::MediaStartOver, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR MediaPlaybackCluster::MediaStartOver(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -6835,8 +9215,11 @@ CHIP_ERROR MediaPlaybackCluster::MediaStartOver(Callback::Cancelable * onSuccess app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, MediaPlayback::Commands::Ids::MediaStartOver, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); // Command takes no arguments. @@ -6844,25 +9227,46 @@ CHIP_ERROR MediaPlaybackCluster::MediaStartOver(Callback::Cancelable * onSuccess SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR MediaPlaybackCluster::MediaStop(OnMediaStopCommandResponseCallbackFunct onSuccess, OnCommandErrorCallbackFunct onFailure, + const app::clusters::MediaPlayback::MediaStopCommandParams::Type & params) +{ + using ResponseCallbackType = clusters::MediaPlayback::MediaStopResponseCommandParams::Type; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, MediaPlayback::Commands::Ids::MediaStop, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR MediaPlaybackCluster::MediaStop(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -6873,8 +9277,11 @@ CHIP_ERROR MediaPlaybackCluster::MediaStop(Callback::Cancelable * onSuccessCallb app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, MediaPlayback::Commands::Ids::MediaStop, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); // Command takes no arguments. @@ -6882,16 +9289,14 @@ CHIP_ERROR MediaPlaybackCluster::MediaStop(Callback::Cancelable * onSuccessCallb SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } @@ -7005,14 +9410,39 @@ CHIP_ERROR MediaPlaybackCluster::ReadAttributeClusterRevision(Callback::Cancelab } // NetworkCommissioning Cluster Commands +CHIP_ERROR NetworkCommissioningCluster::AddThreadNetwork( + OnAddThreadNetworkCommandResponseCallbackFunct onSuccess, OnCommandErrorCallbackFunct onFailure, + const app::clusters::NetworkCommissioning::AddThreadNetworkCommandParams::Type & params) +{ + using ResponseCallbackType = clusters::NetworkCommissioning::AddThreadNetworkResponseCommandParams::Type; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, + NetworkCommissioning::Commands::Ids::AddThreadNetwork, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR NetworkCommissioningCluster::AddThreadNetwork(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, chip::ByteSpan operationalDataset, uint64_t breadcrumb, uint32_t timeoutMs) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -7024,8 +9454,11 @@ CHIP_ERROR NetworkCommissioningCluster::AddThreadNetwork(Callback::Cancelable * NetworkCommissioning::Commands::Ids::AddThreadNetwork, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -7039,27 +9472,51 @@ CHIP_ERROR NetworkCommissioningCluster::AddThreadNetwork(Callback::Cancelable * SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR +NetworkCommissioningCluster::AddWiFiNetwork(OnAddWiFiNetworkCommandResponseCallbackFunct onSuccess, + OnCommandErrorCallbackFunct onFailure, + const app::clusters::NetworkCommissioning::AddWiFiNetworkCommandParams::Type & params) +{ + using ResponseCallbackType = clusters::NetworkCommissioning::AddWiFiNetworkResponseCommandParams::Type; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, + NetworkCommissioning::Commands::Ids::AddWiFiNetwork, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR NetworkCommissioningCluster::AddWiFiNetwork(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, chip::ByteSpan ssid, chip::ByteSpan credentials, uint64_t breadcrumb, uint32_t timeoutMs) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -7071,8 +9528,11 @@ CHIP_ERROR NetworkCommissioningCluster::AddWiFiNetwork(Callback::Cancelable * on NetworkCommissioning::Commands::Ids::AddWiFiNetwork, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -7088,27 +9548,51 @@ CHIP_ERROR NetworkCommissioningCluster::AddWiFiNetwork(Callback::Cancelable * on SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR +NetworkCommissioningCluster::DisableNetwork(OnDisableNetworkCommandResponseCallbackFunct onSuccess, + OnCommandErrorCallbackFunct onFailure, + const app::clusters::NetworkCommissioning::DisableNetworkCommandParams::Type & params) +{ + using ResponseCallbackType = clusters::NetworkCommissioning::DisableNetworkResponseCommandParams::Type; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, + NetworkCommissioning::Commands::Ids::DisableNetwork, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR NetworkCommissioningCluster::DisableNetwork(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, chip::ByteSpan networkID, uint64_t breadcrumb, uint32_t timeoutMs) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -7120,8 +9604,11 @@ CHIP_ERROR NetworkCommissioningCluster::DisableNetwork(Callback::Cancelable * on NetworkCommissioning::Commands::Ids::DisableNetwork, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -7135,27 +9622,51 @@ CHIP_ERROR NetworkCommissioningCluster::DisableNetwork(Callback::Cancelable * on SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR +NetworkCommissioningCluster::EnableNetwork(OnEnableNetworkCommandResponseCallbackFunct onSuccess, + OnCommandErrorCallbackFunct onFailure, + const app::clusters::NetworkCommissioning::EnableNetworkCommandParams::Type & params) +{ + using ResponseCallbackType = clusters::NetworkCommissioning::EnableNetworkResponseCommandParams::Type; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, + NetworkCommissioning::Commands::Ids::EnableNetwork, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR NetworkCommissioningCluster::EnableNetwork(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, chip::ByteSpan networkID, uint64_t breadcrumb, uint32_t timeoutMs) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -7167,8 +9678,11 @@ CHIP_ERROR NetworkCommissioningCluster::EnableNetwork(Callback::Cancelable * onS NetworkCommissioning::Commands::Ids::EnableNetwork, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -7182,27 +9696,50 @@ CHIP_ERROR NetworkCommissioningCluster::EnableNetwork(Callback::Cancelable * onS SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR NetworkCommissioningCluster::GetLastNetworkCommissioningResult( + OnGetLastNetworkCommissioningResultCommandResponseCallbackFunct onSuccess, OnCommandErrorCallbackFunct onFailure, + const app::clusters::NetworkCommissioning::GetLastNetworkCommissioningResultCommandParams::Type & params) +{ + using ResponseCallbackType = void; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, + NetworkCommissioning::Commands::Ids::GetLastNetworkCommissioningResult, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR NetworkCommissioningCluster::GetLastNetworkCommissioningResult(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint32_t timeoutMs) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -7214,8 +9751,11 @@ CHIP_ERROR NetworkCommissioningCluster::GetLastNetworkCommissioningResult(Callba NetworkCommissioning::Commands::Ids::GetLastNetworkCommissioningResult, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -7225,27 +9765,51 @@ CHIP_ERROR NetworkCommissioningCluster::GetLastNetworkCommissioningResult(Callba SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR +NetworkCommissioningCluster::RemoveNetwork(OnRemoveNetworkCommandResponseCallbackFunct onSuccess, + OnCommandErrorCallbackFunct onFailure, + const app::clusters::NetworkCommissioning::RemoveNetworkCommandParams::Type & params) +{ + using ResponseCallbackType = clusters::NetworkCommissioning::RemoveNetworkResponseCommandParams::Type; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, + NetworkCommissioning::Commands::Ids::RemoveNetwork, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR NetworkCommissioningCluster::RemoveNetwork(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, chip::ByteSpan networkID, uint64_t breadcrumb, uint32_t timeoutMs) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -7257,8 +9821,11 @@ CHIP_ERROR NetworkCommissioningCluster::RemoveNetwork(Callback::Cancelable * onS NetworkCommissioning::Commands::Ids::RemoveNetwork, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -7272,27 +9839,50 @@ CHIP_ERROR NetworkCommissioningCluster::RemoveNetwork(Callback::Cancelable * onS SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR +NetworkCommissioningCluster::ScanNetworks(OnScanNetworksCommandResponseCallbackFunct onSuccess, + OnCommandErrorCallbackFunct onFailure, + const app::clusters::NetworkCommissioning::ScanNetworksCommandParams::Type & params) +{ + using ResponseCallbackType = clusters::NetworkCommissioning::ScanNetworksResponseCommandParams::Type; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, NetworkCommissioning::Commands::Ids::ScanNetworks, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR NetworkCommissioningCluster::ScanNetworks(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, chip::ByteSpan ssid, uint64_t breadcrumb, uint32_t timeoutMs) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -7303,8 +9893,11 @@ CHIP_ERROR NetworkCommissioningCluster::ScanNetworks(Callback::Cancelable * onSu app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, NetworkCommissioning::Commands::Ids::ScanNetworks, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -7318,28 +9911,51 @@ CHIP_ERROR NetworkCommissioningCluster::ScanNetworks(Callback::Cancelable * onSu SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR NetworkCommissioningCluster::UpdateThreadNetwork( + OnUpdateThreadNetworkCommandResponseCallbackFunct onSuccess, OnCommandErrorCallbackFunct onFailure, + const app::clusters::NetworkCommissioning::UpdateThreadNetworkCommandParams::Type & params) +{ + using ResponseCallbackType = clusters::NetworkCommissioning::UpdateThreadNetworkResponseCommandParams::Type; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, + NetworkCommissioning::Commands::Ids::UpdateThreadNetwork, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR NetworkCommissioningCluster::UpdateThreadNetwork(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, chip::ByteSpan operationalDataset, uint64_t breadcrumb, uint32_t timeoutMs) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -7351,8 +9967,11 @@ CHIP_ERROR NetworkCommissioningCluster::UpdateThreadNetwork(Callback::Cancelable NetworkCommissioning::Commands::Ids::UpdateThreadNetwork, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -7366,27 +9985,50 @@ CHIP_ERROR NetworkCommissioningCluster::UpdateThreadNetwork(Callback::Cancelable SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR NetworkCommissioningCluster::UpdateWiFiNetwork( + OnUpdateWiFiNetworkCommandResponseCallbackFunct onSuccess, OnCommandErrorCallbackFunct onFailure, + const app::clusters::NetworkCommissioning::UpdateWiFiNetworkCommandParams::Type & params) +{ + using ResponseCallbackType = clusters::NetworkCommissioning::UpdateWiFiNetworkResponseCommandParams::Type; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, + NetworkCommissioning::Commands::Ids::UpdateWiFiNetwork, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR NetworkCommissioningCluster::UpdateWiFiNetwork(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, chip::ByteSpan ssid, chip::ByteSpan credentials, uint64_t breadcrumb, uint32_t timeoutMs) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -7398,8 +10040,11 @@ CHIP_ERROR NetworkCommissioningCluster::UpdateWiFiNetwork(Callback::Cancelable * NetworkCommissioning::Commands::Ids::UpdateWiFiNetwork, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -7415,16 +10060,14 @@ CHIP_ERROR NetworkCommissioningCluster::UpdateWiFiNetwork(Callback::Cancelable * SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } @@ -7454,14 +10097,39 @@ CHIP_ERROR NetworkCommissioningCluster::ReadAttributeClusterRevision(Callback::C } // OtaSoftwareUpdateProvider Cluster Commands +CHIP_ERROR OtaSoftwareUpdateProviderCluster::ApplyUpdateRequest( + OnApplyUpdateRequestCommandResponseCallbackFunct onSuccess, OnCommandErrorCallbackFunct onFailure, + const app::clusters::OtaSoftwareUpdateProvider::ApplyUpdateRequestCommandParams::Type & params) +{ + using ResponseCallbackType = clusters::OtaSoftwareUpdateProvider::ApplyUpdateRequestResponseCommandParams::Type; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, + OtaSoftwareUpdateProvider::Commands::Ids::ApplyUpdateRequest, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR OtaSoftwareUpdateProviderCluster::ApplyUpdateRequest(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, chip::ByteSpan updateToken, uint32_t newVersion) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -7473,8 +10141,11 @@ CHIP_ERROR OtaSoftwareUpdateProviderCluster::ApplyUpdateRequest(Callback::Cancel OtaSoftwareUpdateProvider::Commands::Ids::ApplyUpdateRequest, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -7486,27 +10157,50 @@ CHIP_ERROR OtaSoftwareUpdateProviderCluster::ApplyUpdateRequest(Callback::Cancel SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR OtaSoftwareUpdateProviderCluster::NotifyUpdateApplied( + OnNotifyUpdateAppliedCommandResponseCallbackFunct onSuccess, OnCommandErrorCallbackFunct onFailure, + const app::clusters::OtaSoftwareUpdateProvider::NotifyUpdateAppliedCommandParams::Type & params) +{ + using ResponseCallbackType = void; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, + OtaSoftwareUpdateProvider::Commands::Ids::NotifyUpdateApplied, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR OtaSoftwareUpdateProviderCluster::NotifyUpdateApplied(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, chip::ByteSpan updateToken, uint32_t currentVersion) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -7518,8 +10212,11 @@ CHIP_ERROR OtaSoftwareUpdateProviderCluster::NotifyUpdateApplied(Callback::Cance OtaSoftwareUpdateProvider::Commands::Ids::NotifyUpdateApplied, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -7531,19 +10228,44 @@ CHIP_ERROR OtaSoftwareUpdateProviderCluster::NotifyUpdateApplied(Callback::Cance SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR +OtaSoftwareUpdateProviderCluster::QueryImage(OnQueryImageCommandResponseCallbackFunct onSuccess, + OnCommandErrorCallbackFunct onFailure, + const app::clusters::OtaSoftwareUpdateProvider::QueryImageCommandParams::Type & params) +{ + using ResponseCallbackType = clusters::OtaSoftwareUpdateProvider::QueryImageResponseCommandParams::Type; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, + OtaSoftwareUpdateProvider::Commands::Ids::QueryImage, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR OtaSoftwareUpdateProviderCluster::QueryImage(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t vendorId, uint16_t productId, uint16_t imageType, uint16_t hardwareVersion, @@ -7551,10 +10273,9 @@ CHIP_ERROR OtaSoftwareUpdateProviderCluster::QueryImage(Callback::Cancelable * o chip::ByteSpan location, bool requestorCanConsent, chip::ByteSpan metadataForProvider) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -7566,8 +10287,11 @@ CHIP_ERROR OtaSoftwareUpdateProviderCluster::QueryImage(Callback::Cancelable * o OtaSoftwareUpdateProvider::Commands::Ids::QueryImage, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -7593,16 +10317,14 @@ CHIP_ERROR OtaSoftwareUpdateProviderCluster::QueryImage(Callback::Cancelable * o SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } @@ -7620,15 +10342,40 @@ CHIP_ERROR OtaSoftwareUpdateProviderCluster::ReadAttributeClusterRevision(Callba } // OtaSoftwareUpdateRequestor Cluster Commands +CHIP_ERROR OtaSoftwareUpdateRequestorCluster::AnnounceOtaProvider( + OnAnnounceOtaProviderCommandResponseCallbackFunct onSuccess, OnCommandErrorCallbackFunct onFailure, + const app::clusters::OtaSoftwareUpdateRequestor::AnnounceOtaProviderCommandParams::Type & params) +{ + using ResponseCallbackType = void; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, + OtaSoftwareUpdateRequestor::Commands::Ids::AnnounceOtaProvider, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR OtaSoftwareUpdateRequestorCluster::AnnounceOtaProvider(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, chip::ByteSpan serverLocation, uint16_t vendorId, uint8_t announcementReason, chip::ByteSpan metadataForNode) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -7640,8 +10387,11 @@ CHIP_ERROR OtaSoftwareUpdateRequestorCluster::AnnounceOtaProvider(Callback::Canc OtaSoftwareUpdateRequestor::Commands::Ids::AnnounceOtaProvider, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -7657,16 +10407,14 @@ CHIP_ERROR OtaSoftwareUpdateRequestorCluster::AnnounceOtaProvider(Callback::Canc SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } @@ -7795,12 +10543,35 @@ CHIP_ERROR OccupancySensingCluster::ReadAttributeClusterRevision(Callback::Cance } // OnOff Cluster Commands +CHIP_ERROR OnOffCluster::Off(OnOffCommandResponseCallbackFunct onSuccess, OnCommandErrorCallbackFunct onFailure, + const app::clusters::OnOff::OffCommandParams::Type & params) +{ + using ResponseCallbackType = void; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, OnOff::Commands::Ids::Off, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR OnOffCluster::Off(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -7811,35 +10582,59 @@ CHIP_ERROR OnOffCluster::Off(Callback::Cancelable * onSuccessCallback, Callback: app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, OnOff::Commands::Ids::Off, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); // Command takes no arguments. - SuccessOrExit(err = sender->FinishCommand()); + SuccessOrExit(err = sender->FinishCommand()); + + // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); + + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); +exit: + return err; +} + +CHIP_ERROR OnOffCluster::OffWithEffect(OnOffWithEffectCommandResponseCallbackFunct onSuccess, OnCommandErrorCallbackFunct onFailure, + const app::clusters::OnOff::OffWithEffectCommandParams::Type & params) +{ + using ResponseCallbackType = void; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, OnOff::Commands::Ids::OffWithEffect, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); - // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + auto sender = Platform::MakeUnique(callback.get()); - err = mDevice->SendCommands(sender); + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); -exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } - return err; + sender.release(); + callback.release(); + return CHIP_NO_ERROR; } CHIP_ERROR OnOffCluster::OffWithEffect(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint8_t effectId, uint8_t effectVariant) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -7850,8 +10645,11 @@ CHIP_ERROR OnOffCluster::OffWithEffect(Callback::Cancelable * onSuccessCallback, app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, OnOff::Commands::Ids::OffWithEffect, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -7863,25 +10661,46 @@ CHIP_ERROR OnOffCluster::OffWithEffect(Callback::Cancelable * onSuccessCallback, SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR OnOffCluster::On(OnOnCommandResponseCallbackFunct onSuccess, OnCommandErrorCallbackFunct onFailure, + const app::clusters::OnOff::OnCommandParams::Type & params) +{ + using ResponseCallbackType = void; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, OnOff::Commands::Ids::On, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR OnOffCluster::On(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -7892,8 +10711,11 @@ CHIP_ERROR OnOffCluster::On(Callback::Cancelable * onSuccessCallback, Callback:: app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, OnOff::Commands::Ids::On, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); // Command takes no arguments. @@ -7901,25 +10723,47 @@ CHIP_ERROR OnOffCluster::On(Callback::Cancelable * onSuccessCallback, Callback:: SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR OnOffCluster::OnWithRecallGlobalScene(OnOnWithRecallGlobalSceneCommandResponseCallbackFunct onSuccess, + OnCommandErrorCallbackFunct onFailure, + const app::clusters::OnOff::OnWithRecallGlobalSceneCommandParams::Type & params) +{ + using ResponseCallbackType = void; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, OnOff::Commands::Ids::OnWithRecallGlobalScene, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR OnOffCluster::OnWithRecallGlobalScene(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -7930,8 +10774,11 @@ CHIP_ERROR OnOffCluster::OnWithRecallGlobalScene(Callback::Cancelable * onSucces app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, OnOff::Commands::Ids::OnWithRecallGlobalScene, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); // Command takes no arguments. @@ -7939,26 +10786,48 @@ CHIP_ERROR OnOffCluster::OnWithRecallGlobalScene(Callback::Cancelable * onSucces SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR OnOffCluster::OnWithTimedOff(OnOnWithTimedOffCommandResponseCallbackFunct onSuccess, + OnCommandErrorCallbackFunct onFailure, + const app::clusters::OnOff::OnWithTimedOffCommandParams::Type & params) +{ + using ResponseCallbackType = void; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, OnOff::Commands::Ids::OnWithTimedOff, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR OnOffCluster::OnWithTimedOff(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint8_t onOffControl, uint16_t onTime, uint16_t offWaitTime) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -7969,8 +10838,11 @@ CHIP_ERROR OnOffCluster::OnWithTimedOff(Callback::Cancelable * onSuccessCallback app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, OnOff::Commands::Ids::OnWithTimedOff, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -7984,25 +10856,46 @@ CHIP_ERROR OnOffCluster::OnWithTimedOff(Callback::Cancelable * onSuccessCallback SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR OnOffCluster::Toggle(OnToggleCommandResponseCallbackFunct onSuccess, OnCommandErrorCallbackFunct onFailure, + const app::clusters::OnOff::ToggleCommandParams::Type & params) +{ + using ResponseCallbackType = void; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, OnOff::Commands::Ids::Toggle, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR OnOffCluster::Toggle(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -8013,8 +10906,11 @@ CHIP_ERROR OnOffCluster::Toggle(Callback::Cancelable * onSuccessCallback, Callba app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, OnOff::Commands::Ids::Toggle, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); // Command takes no arguments. @@ -8022,16 +10918,14 @@ CHIP_ERROR OnOffCluster::Toggle(Callback::Cancelable * onSuccessCallback, Callba SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } @@ -8242,14 +11136,38 @@ CHIP_ERROR OnOffSwitchConfigurationCluster::ReadAttributeClusterRevision(Callbac } // OperationalCredentials Cluster Commands +CHIP_ERROR OperationalCredentialsCluster::AddNOC(OnAddNOCCommandResponseCallbackFunct onSuccess, + OnCommandErrorCallbackFunct onFailure, + const app::clusters::OperationalCredentials::AddNOCCommandParams::Type & params) +{ + using ResponseCallbackType = clusters::OperationalCredentials::NOCResponseCommandParams::Type; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, OperationalCredentials::Commands::Ids::AddNOC, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR OperationalCredentialsCluster::AddNOC(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, chip::ByteSpan nOCValue, chip::ByteSpan iCACValue, chip::ByteSpan iPKValue, chip::NodeId caseAdminNode, uint16_t adminVendorId) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -8260,8 +11178,11 @@ CHIP_ERROR OperationalCredentialsCluster::AddNOC(Callback::Cancelable * onSucces app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, OperationalCredentials::Commands::Ids::AddNOC, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -8279,27 +11200,50 @@ CHIP_ERROR OperationalCredentialsCluster::AddNOC(Callback::Cancelable * onSucces SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR OperationalCredentialsCluster::AddTrustedRootCertificate( + OnAddTrustedRootCertificateCommandResponseCallbackFunct onSuccess, OnCommandErrorCallbackFunct onFailure, + const app::clusters::OperationalCredentials::AddTrustedRootCertificateCommandParams::Type & params) +{ + using ResponseCallbackType = void; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, + OperationalCredentials::Commands::Ids::AddTrustedRootCertificate, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR OperationalCredentialsCluster::AddTrustedRootCertificate(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, chip::ByteSpan rootCertificate) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -8311,8 +11255,11 @@ CHIP_ERROR OperationalCredentialsCluster::AddTrustedRootCertificate(Callback::Ca OperationalCredentials::Commands::Ids::AddTrustedRootCertificate, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -8322,27 +11269,50 @@ CHIP_ERROR OperationalCredentialsCluster::AddTrustedRootCertificate(Callback::Ca SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR OperationalCredentialsCluster::AttestationRequest( + OnAttestationRequestCommandResponseCallbackFunct onSuccess, OnCommandErrorCallbackFunct onFailure, + const app::clusters::OperationalCredentials::AttestationRequestCommandParams::Type & params) +{ + using ResponseCallbackType = clusters::OperationalCredentials::AttestationResponseCommandParams::Type; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, + OperationalCredentials::Commands::Ids::AttestationRequest, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR OperationalCredentialsCluster::AttestationRequest(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, chip::ByteSpan attestationNonce) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -8354,8 +11324,11 @@ CHIP_ERROR OperationalCredentialsCluster::AttestationRequest(Callback::Cancelabl OperationalCredentials::Commands::Ids::AttestationRequest, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -8365,26 +11338,49 @@ CHIP_ERROR OperationalCredentialsCluster::AttestationRequest(Callback::Cancelabl SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR OperationalCredentialsCluster::CertificateChainRequest( + OnCertificateChainRequestCommandResponseCallbackFunct onSuccess, OnCommandErrorCallbackFunct onFailure, + const app::clusters::OperationalCredentials::CertificateChainRequestCommandParams::Type & params) +{ + using ResponseCallbackType = clusters::OperationalCredentials::CertificateChainResponseCommandParams::Type; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, + OperationalCredentials::Commands::Ids::CertificateChainRequest, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR OperationalCredentialsCluster::CertificateChainRequest(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint8_t certificateType) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -8396,8 +11392,11 @@ CHIP_ERROR OperationalCredentialsCluster::CertificateChainRequest(Callback::Canc OperationalCredentials::Commands::Ids::CertificateChainRequest, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -8407,26 +11406,50 @@ CHIP_ERROR OperationalCredentialsCluster::CertificateChainRequest(Callback::Canc SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR +OperationalCredentialsCluster::OpCSRRequest(OnOpCSRRequestCommandResponseCallbackFunct onSuccess, + OnCommandErrorCallbackFunct onFailure, + const app::clusters::OperationalCredentials::OpCSRRequestCommandParams::Type & params) +{ + using ResponseCallbackType = clusters::OperationalCredentials::OpCSRResponseCommandParams::Type; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, + OperationalCredentials::Commands::Ids::OpCSRRequest, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR OperationalCredentialsCluster::OpCSRRequest(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, chip::ByteSpan cSRNonce) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -8438,8 +11461,11 @@ CHIP_ERROR OperationalCredentialsCluster::OpCSRRequest(Callback::Cancelable * on OperationalCredentials::Commands::Ids::OpCSRRequest, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -8449,26 +11475,50 @@ CHIP_ERROR OperationalCredentialsCluster::OpCSRRequest(Callback::Cancelable * on SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR +OperationalCredentialsCluster::RemoveFabric(OnRemoveFabricCommandResponseCallbackFunct onSuccess, + OnCommandErrorCallbackFunct onFailure, + const app::clusters::OperationalCredentials::RemoveFabricCommandParams::Type & params) +{ + using ResponseCallbackType = clusters::OperationalCredentials::NOCResponseCommandParams::Type; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, + OperationalCredentials::Commands::Ids::RemoveFabric, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR OperationalCredentialsCluster::RemoveFabric(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint8_t fabricIndex) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -8480,8 +11530,11 @@ CHIP_ERROR OperationalCredentialsCluster::RemoveFabric(Callback::Cancelable * on OperationalCredentials::Commands::Ids::RemoveFabric, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -8491,27 +11544,50 @@ CHIP_ERROR OperationalCredentialsCluster::RemoveFabric(Callback::Cancelable * on SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR OperationalCredentialsCluster::RemoveTrustedRootCertificate( + OnRemoveTrustedRootCertificateCommandResponseCallbackFunct onSuccess, OnCommandErrorCallbackFunct onFailure, + const app::clusters::OperationalCredentials::RemoveTrustedRootCertificateCommandParams::Type & params) +{ + using ResponseCallbackType = void; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, + OperationalCredentials::Commands::Ids::RemoveTrustedRootCertificate, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR OperationalCredentialsCluster::RemoveTrustedRootCertificate(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, chip::ByteSpan trustedRootIdentifier) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -8523,8 +11599,11 @@ CHIP_ERROR OperationalCredentialsCluster::RemoveTrustedRootCertificate(Callback: OperationalCredentials::Commands::Ids::RemoveTrustedRootCertificate, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -8534,26 +11613,49 @@ CHIP_ERROR OperationalCredentialsCluster::RemoveTrustedRootCertificate(Callback: SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR OperationalCredentialsCluster::UpdateFabricLabel( + OnUpdateFabricLabelCommandResponseCallbackFunct onSuccess, OnCommandErrorCallbackFunct onFailure, + const app::clusters::OperationalCredentials::UpdateFabricLabelCommandParams::Type & params) +{ + using ResponseCallbackType = clusters::OperationalCredentials::NOCResponseCommandParams::Type; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, + OperationalCredentials::Commands::Ids::UpdateFabricLabel, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR OperationalCredentialsCluster::UpdateFabricLabel(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, chip::ByteSpan label) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -8565,8 +11667,11 @@ CHIP_ERROR OperationalCredentialsCluster::UpdateFabricLabel(Callback::Cancelable OperationalCredentials::Commands::Ids::UpdateFabricLabel, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -8576,27 +11681,49 @@ CHIP_ERROR OperationalCredentialsCluster::UpdateFabricLabel(Callback::Cancelable SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR +OperationalCredentialsCluster::UpdateNOC(OnUpdateNOCCommandResponseCallbackFunct onSuccess, OnCommandErrorCallbackFunct onFailure, + const app::clusters::OperationalCredentials::UpdateNOCCommandParams::Type & params) +{ + using ResponseCallbackType = clusters::OperationalCredentials::NOCResponseCommandParams::Type; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, OperationalCredentials::Commands::Ids::UpdateNOC, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR OperationalCredentialsCluster::UpdateNOC(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, chip::ByteSpan nOCValue, chip::ByteSpan iCACValue) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -8607,8 +11734,11 @@ CHIP_ERROR OperationalCredentialsCluster::UpdateNOC(Callback::Cancelable * onSuc app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, OperationalCredentials::Commands::Ids::UpdateNOC, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -8620,16 +11750,14 @@ CHIP_ERROR OperationalCredentialsCluster::UpdateNOC(Callback::Cancelable * onSuc SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } @@ -9091,14 +12219,37 @@ CHIP_ERROR RelativeHumidityMeasurementCluster::ReadAttributeClusterRevision(Call } // Scenes Cluster Commands +CHIP_ERROR ScenesCluster::AddScene(OnAddSceneCommandResponseCallbackFunct onSuccess, OnCommandErrorCallbackFunct onFailure, + const app::clusters::Scenes::AddSceneCommandParams::Type & params) +{ + using ResponseCallbackType = clusters::Scenes::AddSceneResponseCommandParams::Type; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, Scenes::Commands::Ids::AddScene, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR ScenesCluster::AddScene(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t groupId, uint8_t sceneId, uint16_t transitionTime, chip::ByteSpan sceneName, chip::ClusterId clusterId, uint8_t length, uint8_t value) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -9109,8 +12260,11 @@ CHIP_ERROR ScenesCluster::AddScene(Callback::Cancelable * onSuccessCallback, Cal app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, Scenes::Commands::Ids::AddScene, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -9132,26 +12286,48 @@ CHIP_ERROR ScenesCluster::AddScene(Callback::Cancelable * onSuccessCallback, Cal SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR ScenesCluster::GetSceneMembership(OnGetSceneMembershipCommandResponseCallbackFunct onSuccess, + OnCommandErrorCallbackFunct onFailure, + const app::clusters::Scenes::GetSceneMembershipCommandParams::Type & params) +{ + using ResponseCallbackType = clusters::Scenes::GetSceneMembershipResponseCommandParams::Type; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, Scenes::Commands::Ids::GetSceneMembership, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR ScenesCluster::GetSceneMembership(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t groupId) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -9162,8 +12338,11 @@ CHIP_ERROR ScenesCluster::GetSceneMembership(Callback::Cancelable * onSuccessCal app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, Scenes::Commands::Ids::GetSceneMembership, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -9173,26 +12352,47 @@ CHIP_ERROR ScenesCluster::GetSceneMembership(Callback::Cancelable * onSuccessCal SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR ScenesCluster::RecallScene(OnRecallSceneCommandResponseCallbackFunct onSuccess, OnCommandErrorCallbackFunct onFailure, + const app::clusters::Scenes::RecallSceneCommandParams::Type & params) +{ + using ResponseCallbackType = void; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, Scenes::Commands::Ids::RecallScene, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR ScenesCluster::RecallScene(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t groupId, uint8_t sceneId, uint16_t transitionTime) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -9203,8 +12403,11 @@ CHIP_ERROR ScenesCluster::RecallScene(Callback::Cancelable * onSuccessCallback, app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, Scenes::Commands::Ids::RecallScene, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -9218,26 +12421,48 @@ CHIP_ERROR ScenesCluster::RecallScene(Callback::Cancelable * onSuccessCallback, SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR ScenesCluster::RemoveAllScenes(OnRemoveAllScenesCommandResponseCallbackFunct onSuccess, + OnCommandErrorCallbackFunct onFailure, + const app::clusters::Scenes::RemoveAllScenesCommandParams::Type & params) +{ + using ResponseCallbackType = clusters::Scenes::RemoveAllScenesResponseCommandParams::Type; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, Scenes::Commands::Ids::RemoveAllScenes, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR ScenesCluster::RemoveAllScenes(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t groupId) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -9248,8 +12473,11 @@ CHIP_ERROR ScenesCluster::RemoveAllScenes(Callback::Cancelable * onSuccessCallba app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, Scenes::Commands::Ids::RemoveAllScenes, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -9259,26 +12487,47 @@ CHIP_ERROR ScenesCluster::RemoveAllScenes(Callback::Cancelable * onSuccessCallba SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR ScenesCluster::RemoveScene(OnRemoveSceneCommandResponseCallbackFunct onSuccess, OnCommandErrorCallbackFunct onFailure, + const app::clusters::Scenes::RemoveSceneCommandParams::Type & params) +{ + using ResponseCallbackType = clusters::Scenes::RemoveSceneResponseCommandParams::Type; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, Scenes::Commands::Ids::RemoveScene, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR ScenesCluster::RemoveScene(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t groupId, uint8_t sceneId) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -9289,8 +12538,11 @@ CHIP_ERROR ScenesCluster::RemoveScene(Callback::Cancelable * onSuccessCallback, app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, Scenes::Commands::Ids::RemoveScene, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -9302,26 +12554,47 @@ CHIP_ERROR ScenesCluster::RemoveScene(Callback::Cancelable * onSuccessCallback, SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR ScenesCluster::StoreScene(OnStoreSceneCommandResponseCallbackFunct onSuccess, OnCommandErrorCallbackFunct onFailure, + const app::clusters::Scenes::StoreSceneCommandParams::Type & params) +{ + using ResponseCallbackType = clusters::Scenes::StoreSceneResponseCommandParams::Type; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, Scenes::Commands::Ids::StoreScene, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR ScenesCluster::StoreScene(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t groupId, uint8_t sceneId) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -9332,8 +12605,11 @@ CHIP_ERROR ScenesCluster::StoreScene(Callback::Cancelable * onSuccessCallback, C app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, Scenes::Commands::Ids::StoreScene, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -9345,26 +12621,47 @@ CHIP_ERROR ScenesCluster::StoreScene(Callback::Cancelable * onSuccessCallback, C SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR ScenesCluster::ViewScene(OnViewSceneCommandResponseCallbackFunct onSuccess, OnCommandErrorCallbackFunct onFailure, + const app::clusters::Scenes::ViewSceneCommandParams::Type & params) +{ + using ResponseCallbackType = clusters::Scenes::ViewSceneResponseCommandParams::Type; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, Scenes::Commands::Ids::ViewScene, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR ScenesCluster::ViewScene(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t groupId, uint8_t sceneId) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -9375,8 +12672,11 @@ CHIP_ERROR ScenesCluster::ViewScene(Callback::Cancelable * onSuccessCallback, Ca app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, Scenes::Commands::Ids::ViewScene, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -9388,16 +12688,14 @@ CHIP_ERROR ScenesCluster::ViewScene(Callback::Cancelable * onSuccessCallback, Ca SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } @@ -9475,13 +12773,39 @@ CHIP_ERROR ScenesCluster::ReadAttributeClusterRevision(Callback::Cancelable * on } // SoftwareDiagnostics Cluster Commands +CHIP_ERROR +SoftwareDiagnosticsCluster::ResetWatermarks(OnResetWatermarksCommandResponseCallbackFunct onSuccess, + OnCommandErrorCallbackFunct onFailure, + const app::clusters::SoftwareDiagnostics::ResetWatermarksCommandParams::Type & params) +{ + using ResponseCallbackType = void; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, + SoftwareDiagnostics::Commands::Ids::ResetWatermarks, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR SoftwareDiagnosticsCluster::ResetWatermarks(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -9493,8 +12817,11 @@ CHIP_ERROR SoftwareDiagnosticsCluster::ResetWatermarks(Callback::Cancelable * on SoftwareDiagnostics::Commands::Ids::ResetWatermarks, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); // Command takes no arguments. @@ -9502,16 +12829,14 @@ CHIP_ERROR SoftwareDiagnosticsCluster::ResetWatermarks(Callback::Cancelable * on SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } @@ -9621,14 +12946,38 @@ CHIP_ERROR SwitchCluster::ReadAttributeClusterRevision(Callback::Cancelable * on BasicAttributeFilter); } -// TvChannel Cluster Commands +// TvChannel Cluster Commands +CHIP_ERROR TvChannelCluster::ChangeChannel(OnChangeChannelCommandResponseCallbackFunct onSuccess, + OnCommandErrorCallbackFunct onFailure, + const app::clusters::TvChannel::ChangeChannelCommandParams::Type & params) +{ + using ResponseCallbackType = clusters::TvChannel::ChangeChannelResponseCommandParams::Type; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, TvChannel::Commands::Ids::ChangeChannel, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR TvChannelCluster::ChangeChannel(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, chip::ByteSpan match) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -9639,8 +12988,11 @@ CHIP_ERROR TvChannelCluster::ChangeChannel(Callback::Cancelable * onSuccessCallb app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, TvChannel::Commands::Ids::ChangeChannel, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -9650,27 +13002,50 @@ CHIP_ERROR TvChannelCluster::ChangeChannel(Callback::Cancelable * onSuccessCallb SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR +TvChannelCluster::ChangeChannelByNumber(OnChangeChannelByNumberCommandResponseCallbackFunct onSuccess, + OnCommandErrorCallbackFunct onFailure, + const app::clusters::TvChannel::ChangeChannelByNumberCommandParams::Type & params) +{ + using ResponseCallbackType = void; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, TvChannel::Commands::Ids::ChangeChannelByNumber, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR TvChannelCluster::ChangeChannelByNumber(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t majorNumber, uint16_t minorNumber) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -9681,8 +13056,11 @@ CHIP_ERROR TvChannelCluster::ChangeChannelByNumber(Callback::Cancelable * onSucc app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, TvChannel::Commands::Ids::ChangeChannelByNumber, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -9694,26 +13072,47 @@ CHIP_ERROR TvChannelCluster::ChangeChannelByNumber(Callback::Cancelable * onSucc SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR TvChannelCluster::SkipChannel(OnSkipChannelCommandResponseCallbackFunct onSuccess, OnCommandErrorCallbackFunct onFailure, + const app::clusters::TvChannel::SkipChannelCommandParams::Type & params) +{ + using ResponseCallbackType = void; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, TvChannel::Commands::Ids::SkipChannel, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR TvChannelCluster::SkipChannel(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t count) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -9724,8 +13123,11 @@ CHIP_ERROR TvChannelCluster::SkipChannel(Callback::Cancelable * onSuccessCallbac app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, TvChannel::Commands::Ids::SkipChannel, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -9735,16 +13137,14 @@ CHIP_ERROR TvChannelCluster::SkipChannel(Callback::Cancelable * onSuccessCallbac SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } @@ -9798,13 +13198,37 @@ CHIP_ERROR TvChannelCluster::ReadAttributeClusterRevision(Callback::Cancelable * } // TargetNavigator Cluster Commands +CHIP_ERROR TargetNavigatorCluster::NavigateTarget(OnNavigateTargetCommandResponseCallbackFunct onSuccess, + OnCommandErrorCallbackFunct onFailure, + const app::clusters::TargetNavigator::NavigateTargetCommandParams::Type & params) +{ + using ResponseCallbackType = clusters::TargetNavigator::NavigateTargetResponseCommandParams::Type; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, TargetNavigator::Commands::Ids::NavigateTarget, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR TargetNavigatorCluster::NavigateTarget(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint8_t target, chip::ByteSpan data) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -9815,8 +13239,11 @@ CHIP_ERROR TargetNavigatorCluster::NavigateTarget(Callback::Cancelable * onSucce app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, TargetNavigator::Commands::Ids::NavigateTarget, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -9828,16 +13255,14 @@ CHIP_ERROR TargetNavigatorCluster::NavigateTarget(Callback::Cancelable * onSucce SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } @@ -9937,12 +13362,35 @@ CHIP_ERROR TemperatureMeasurementCluster::ReadAttributeClusterRevision(Callback: } // TestCluster Cluster Commands +CHIP_ERROR TestClusterCluster::Test(OnTestCommandResponseCallbackFunct onSuccess, OnCommandErrorCallbackFunct onFailure, + const app::clusters::TestCluster::TestCommandParams::Type & params) +{ + using ResponseCallbackType = void; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, TestCluster::Commands::Ids::Test, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR TestClusterCluster::Test(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -9953,8 +13401,11 @@ CHIP_ERROR TestClusterCluster::Test(Callback::Cancelable * onSuccessCallback, Ca app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, TestCluster::Commands::Ids::Test, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); // Command takes no arguments. @@ -9962,26 +13413,48 @@ CHIP_ERROR TestClusterCluster::Test(Callback::Cancelable * onSuccessCallback, Ca SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR TestClusterCluster::TestAddArguments(OnTestAddArgumentsCommandResponseCallbackFunct onSuccess, + OnCommandErrorCallbackFunct onFailure, + const app::clusters::TestCluster::TestAddArgumentsCommandParams::Type & params) +{ + using ResponseCallbackType = clusters::TestCluster::TestAddArgumentsResponseCommandParams::Type; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, TestCluster::Commands::Ids::TestAddArguments, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR TestClusterCluster::TestAddArguments(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint8_t arg1, uint8_t arg2) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -9992,8 +13465,11 @@ CHIP_ERROR TestClusterCluster::TestAddArguments(Callback::Cancelable * onSuccess app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, TestCluster::Commands::Ids::TestAddArguments, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -10005,25 +13481,47 @@ CHIP_ERROR TestClusterCluster::TestAddArguments(Callback::Cancelable * onSuccess SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR TestClusterCluster::TestNotHandled(OnTestNotHandledCommandResponseCallbackFunct onSuccess, + OnCommandErrorCallbackFunct onFailure, + const app::clusters::TestCluster::TestNotHandledCommandParams::Type & params) +{ + using ResponseCallbackType = void; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, TestCluster::Commands::Ids::TestNotHandled, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR TestClusterCluster::TestNotHandled(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -10034,8 +13532,11 @@ CHIP_ERROR TestClusterCluster::TestNotHandled(Callback::Cancelable * onSuccessCa app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, TestCluster::Commands::Ids::TestNotHandled, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); // Command takes no arguments. @@ -10043,25 +13544,47 @@ CHIP_ERROR TestClusterCluster::TestNotHandled(Callback::Cancelable * onSuccessCa SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR TestClusterCluster::TestSpecific(OnTestSpecificCommandResponseCallbackFunct onSuccess, + OnCommandErrorCallbackFunct onFailure, + const app::clusters::TestCluster::TestSpecificCommandParams::Type & params) +{ + using ResponseCallbackType = clusters::TestCluster::TestSpecificResponseCommandParams::Type; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, TestCluster::Commands::Ids::TestSpecific, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR TestClusterCluster::TestSpecific(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -10072,8 +13595,11 @@ CHIP_ERROR TestClusterCluster::TestSpecific(Callback::Cancelable * onSuccessCall app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, TestCluster::Commands::Ids::TestSpecific, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); // Command takes no arguments. @@ -10081,26 +13607,48 @@ CHIP_ERROR TestClusterCluster::TestSpecific(Callback::Cancelable * onSuccessCall SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR TestClusterCluster::TestUnknownCommand(OnTestUnknownCommandCommandResponseCallbackFunct onSuccess, + OnCommandErrorCallbackFunct onFailure, + const app::clusters::TestCluster::TestUnknownCommandCommandParams::Type & params) +{ + using ResponseCallbackType = void; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, TestCluster::Commands::Ids::TestUnknownCommand, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR TestClusterCluster::TestUnknownCommand(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -10111,8 +13659,11 @@ CHIP_ERROR TestClusterCluster::TestUnknownCommand(Callback::Cancelable * onSucce app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, TestCluster::Commands::Ids::TestUnknownCommand, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); // Command takes no arguments. @@ -10120,16 +13671,14 @@ CHIP_ERROR TestClusterCluster::TestUnknownCommand(Callback::Cancelable * onSucce SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } @@ -10821,13 +14370,37 @@ CHIP_ERROR TestClusterCluster::ReadAttributeClusterRevision(Callback::Cancelable } // Thermostat Cluster Commands +CHIP_ERROR ThermostatCluster::ClearWeeklySchedule(OnClearWeeklyScheduleCommandResponseCallbackFunct onSuccess, + OnCommandErrorCallbackFunct onFailure, + const app::clusters::Thermostat::ClearWeeklyScheduleCommandParams::Type & params) +{ + using ResponseCallbackType = void; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, Thermostat::Commands::Ids::ClearWeeklySchedule, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR ThermostatCluster::ClearWeeklySchedule(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -10838,8 +14411,11 @@ CHIP_ERROR ThermostatCluster::ClearWeeklySchedule(Callback::Cancelable * onSucce app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, Thermostat::Commands::Ids::ClearWeeklySchedule, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); // Command takes no arguments. @@ -10847,25 +14423,47 @@ CHIP_ERROR ThermostatCluster::ClearWeeklySchedule(Callback::Cancelable * onSucce SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR ThermostatCluster::GetRelayStatusLog(OnGetRelayStatusLogCommandResponseCallbackFunct onSuccess, + OnCommandErrorCallbackFunct onFailure, + const app::clusters::Thermostat::GetRelayStatusLogCommandParams::Type & params) +{ + using ResponseCallbackType = void; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, Thermostat::Commands::Ids::GetRelayStatusLog, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR ThermostatCluster::GetRelayStatusLog(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -10876,8 +14474,11 @@ CHIP_ERROR ThermostatCluster::GetRelayStatusLog(Callback::Cancelable * onSuccess app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, Thermostat::Commands::Ids::GetRelayStatusLog, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); // Command takes no arguments. @@ -10885,26 +14486,48 @@ CHIP_ERROR ThermostatCluster::GetRelayStatusLog(Callback::Cancelable * onSuccess SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR ThermostatCluster::GetWeeklySchedule(OnGetWeeklyScheduleCommandResponseCallbackFunct onSuccess, + OnCommandErrorCallbackFunct onFailure, + const app::clusters::Thermostat::GetWeeklyScheduleCommandParams::Type & params) +{ + using ResponseCallbackType = void; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, Thermostat::Commands::Ids::GetWeeklySchedule, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR ThermostatCluster::GetWeeklySchedule(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint8_t daysToReturn, uint8_t modeToReturn) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -10915,8 +14538,11 @@ CHIP_ERROR ThermostatCluster::GetWeeklySchedule(Callback::Cancelable * onSuccess app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, Thermostat::Commands::Ids::GetWeeklySchedule, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -10928,27 +14554,49 @@ CHIP_ERROR ThermostatCluster::GetWeeklySchedule(Callback::Cancelable * onSuccess SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR ThermostatCluster::SetWeeklySchedule(OnSetWeeklyScheduleCommandResponseCallbackFunct onSuccess, + OnCommandErrorCallbackFunct onFailure, + const app::clusters::Thermostat::SetWeeklyScheduleCommandParams::Type & params) +{ + using ResponseCallbackType = void; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, Thermostat::Commands::Ids::SetWeeklySchedule, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR ThermostatCluster::SetWeeklySchedule(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint8_t numberOfTransitionsForSequence, uint8_t dayOfWeekForSequence, uint8_t modeForSequence, uint8_t payload) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -10959,8 +14607,11 @@ CHIP_ERROR ThermostatCluster::SetWeeklySchedule(Callback::Cancelable * onSuccess app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, Thermostat::Commands::Ids::SetWeeklySchedule, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -10976,26 +14627,48 @@ CHIP_ERROR ThermostatCluster::SetWeeklySchedule(Callback::Cancelable * onSuccess SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR ThermostatCluster::SetpointRaiseLower(OnSetpointRaiseLowerCommandResponseCallbackFunct onSuccess, + OnCommandErrorCallbackFunct onFailure, + const app::clusters::Thermostat::SetpointRaiseLowerCommandParams::Type & params) +{ + using ResponseCallbackType = void; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, Thermostat::Commands::Ids::SetpointRaiseLower, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR ThermostatCluster::SetpointRaiseLower(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint8_t mode, int8_t amount) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -11006,8 +14679,11 @@ CHIP_ERROR ThermostatCluster::SetpointRaiseLower(Callback::Cancelable * onSucces app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, Thermostat::Commands::Ids::SetpointRaiseLower, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -11019,16 +14695,14 @@ CHIP_ERROR ThermostatCluster::SetpointRaiseLower(Callback::Cancelable * onSucces SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } @@ -11509,13 +15183,39 @@ CHIP_ERROR ThermostatUserInterfaceConfigurationCluster::ReadAttributeClusterRevi } // ThreadNetworkDiagnostics Cluster Commands +CHIP_ERROR +ThreadNetworkDiagnosticsCluster::ResetCounts(OnResetCountsCommandResponseCallbackFunct onSuccess, + OnCommandErrorCallbackFunct onFailure, + const app::clusters::ThreadNetworkDiagnostics::ResetCountsCommandParams::Type & params) +{ + using ResponseCallbackType = void; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, + ThreadNetworkDiagnostics::Commands::Ids::ResetCounts, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR ThreadNetworkDiagnosticsCluster::ResetCounts(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -11527,8 +15227,11 @@ CHIP_ERROR ThreadNetworkDiagnosticsCluster::ResetCounts(Callback::Cancelable * o ThreadNetworkDiagnostics::Commands::Ids::ResetCounts, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); // Command takes no arguments. @@ -11536,16 +15239,14 @@ CHIP_ERROR ThreadNetworkDiagnosticsCluster::ResetCounts(Callback::Cancelable * o SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } @@ -12345,13 +16046,39 @@ CHIP_ERROR WakeOnLanCluster::ReadAttributeClusterRevision(Callback::Cancelable * } // WiFiNetworkDiagnostics Cluster Commands +CHIP_ERROR +WiFiNetworkDiagnosticsCluster::ResetCounts(OnResetCountsCommandResponseCallbackFunct onSuccess, + OnCommandErrorCallbackFunct onFailure, + const app::clusters::WiFiNetworkDiagnostics::ResetCountsCommandParams::Type & params) +{ + using ResponseCallbackType = void; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, + WiFiNetworkDiagnostics::Commands::Ids::ResetCounts, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR WiFiNetworkDiagnosticsCluster::ResetCounts(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -12363,8 +16090,11 @@ CHIP_ERROR WiFiNetworkDiagnosticsCluster::ResetCounts(Callback::Cancelable * onS WiFiNetworkDiagnostics::Commands::Ids::ResetCounts, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); // Command takes no arguments. @@ -12372,16 +16102,14 @@ CHIP_ERROR WiFiNetworkDiagnosticsCluster::ResetCounts(Callback::Cancelable * onS SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } @@ -12459,12 +16187,36 @@ CHIP_ERROR WiFiNetworkDiagnosticsCluster::ReadAttributeClusterRevision(Callback: } // WindowCovering Cluster Commands +CHIP_ERROR WindowCoveringCluster::DownOrClose(OnDownOrCloseCommandResponseCallbackFunct onSuccess, + OnCommandErrorCallbackFunct onFailure, + const app::clusters::WindowCovering::DownOrCloseCommandParams::Type & params) +{ + using ResponseCallbackType = void; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, WindowCovering::Commands::Ids::DownOrClose, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR WindowCoveringCluster::DownOrClose(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -12475,8 +16227,11 @@ CHIP_ERROR WindowCoveringCluster::DownOrClose(Callback::Cancelable * onSuccessCa app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, WindowCovering::Commands::Ids::DownOrClose, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); // Command takes no arguments. @@ -12484,27 +16239,50 @@ CHIP_ERROR WindowCoveringCluster::DownOrClose(Callback::Cancelable * onSuccessCa SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR +WindowCoveringCluster::GoToLiftPercentage(OnGoToLiftPercentageCommandResponseCallbackFunct onSuccess, + OnCommandErrorCallbackFunct onFailure, + const app::clusters::WindowCovering::GoToLiftPercentageCommandParams::Type & params) +{ + using ResponseCallbackType = void; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, WindowCovering::Commands::Ids::GoToLiftPercentage, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR WindowCoveringCluster::GoToLiftPercentage(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint8_t liftPercentageValue, uint16_t liftPercent100thsValue) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -12515,8 +16293,11 @@ CHIP_ERROR WindowCoveringCluster::GoToLiftPercentage(Callback::Cancelable * onSu app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, WindowCovering::Commands::Ids::GoToLiftPercentage, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -12528,26 +16309,48 @@ CHIP_ERROR WindowCoveringCluster::GoToLiftPercentage(Callback::Cancelable * onSu SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR WindowCoveringCluster::GoToLiftValue(OnGoToLiftValueCommandResponseCallbackFunct onSuccess, + OnCommandErrorCallbackFunct onFailure, + const app::clusters::WindowCovering::GoToLiftValueCommandParams::Type & params) +{ + using ResponseCallbackType = void; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, WindowCovering::Commands::Ids::GoToLiftValue, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR WindowCoveringCluster::GoToLiftValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t liftValue) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -12558,8 +16361,11 @@ CHIP_ERROR WindowCoveringCluster::GoToLiftValue(Callback::Cancelable * onSuccess app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, WindowCovering::Commands::Ids::GoToLiftValue, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -12569,27 +16375,50 @@ CHIP_ERROR WindowCoveringCluster::GoToLiftValue(Callback::Cancelable * onSuccess SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR +WindowCoveringCluster::GoToTiltPercentage(OnGoToTiltPercentageCommandResponseCallbackFunct onSuccess, + OnCommandErrorCallbackFunct onFailure, + const app::clusters::WindowCovering::GoToTiltPercentageCommandParams::Type & params) +{ + using ResponseCallbackType = void; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, WindowCovering::Commands::Ids::GoToTiltPercentage, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR WindowCoveringCluster::GoToTiltPercentage(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint8_t tiltPercentageValue, uint16_t tiltPercent100thsValue) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -12600,8 +16429,11 @@ CHIP_ERROR WindowCoveringCluster::GoToTiltPercentage(Callback::Cancelable * onSu app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, WindowCovering::Commands::Ids::GoToTiltPercentage, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -12613,26 +16445,48 @@ CHIP_ERROR WindowCoveringCluster::GoToTiltPercentage(Callback::Cancelable * onSu SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR WindowCoveringCluster::GoToTiltValue(OnGoToTiltValueCommandResponseCallbackFunct onSuccess, + OnCommandErrorCallbackFunct onFailure, + const app::clusters::WindowCovering::GoToTiltValueCommandParams::Type & params) +{ + using ResponseCallbackType = void; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, WindowCovering::Commands::Ids::GoToTiltValue, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR WindowCoveringCluster::GoToTiltValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t tiltValue) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -12643,8 +16497,11 @@ CHIP_ERROR WindowCoveringCluster::GoToTiltValue(Callback::Cancelable * onSuccess app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, WindowCovering::Commands::Ids::GoToTiltValue, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -12654,25 +16511,47 @@ CHIP_ERROR WindowCoveringCluster::GoToTiltValue(Callback::Cancelable * onSuccess SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR WindowCoveringCluster::StopMotion(OnStopMotionCommandResponseCallbackFunct onSuccess, + OnCommandErrorCallbackFunct onFailure, + const app::clusters::WindowCovering::StopMotionCommandParams::Type & params) +{ + using ResponseCallbackType = void; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, WindowCovering::Commands::Ids::StopMotion, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR WindowCoveringCluster::StopMotion(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -12683,8 +16562,11 @@ CHIP_ERROR WindowCoveringCluster::StopMotion(Callback::Cancelable * onSuccessCal app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, WindowCovering::Commands::Ids::StopMotion, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); // Command takes no arguments. @@ -12692,25 +16574,46 @@ CHIP_ERROR WindowCoveringCluster::StopMotion(Callback::Cancelable * onSuccessCal SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR WindowCoveringCluster::UpOrOpen(OnUpOrOpenCommandResponseCallbackFunct onSuccess, OnCommandErrorCallbackFunct onFailure, + const app::clusters::WindowCovering::UpOrOpenCommandParams::Type & params) +{ + using ResponseCallbackType = void; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, WindowCovering::Commands::Ids::UpOrOpen, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR WindowCoveringCluster::UpOrOpen(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -12721,8 +16624,11 @@ CHIP_ERROR WindowCoveringCluster::UpOrOpen(Callback::Cancelable * onSuccessCallb app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, WindowCovering::Commands::Ids::UpOrOpen, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); // Command takes no arguments. @@ -12730,16 +16636,14 @@ CHIP_ERROR WindowCoveringCluster::UpOrOpen(Callback::Cancelable * onSuccessCallb SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } diff --git a/zzz_generated/controller-clusters/zap-generated/CHIPClusters.h b/zzz_generated/controller-clusters/zap-generated/CHIPClusters.h index 5c465de5f3c1e9..6cb34b56abce4e 100644 --- a/zzz_generated/controller-clusters/zap-generated/CHIPClusters.h +++ b/zzz_generated/controller-clusters/zap-generated/CHIPClusters.h @@ -23,10 +23,14 @@ #include #include +#include + #include #include #include +#include + namespace chip { namespace Controller { @@ -42,6 +46,16 @@ class DLL_EXPORT AccountLoginCluster : public ClusterBase CHIP_ERROR Login(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, chip::ByteSpan tempAccountIdentifier, chip::ByteSpan setupPIN); + // Cluster Commands (Cluster Object Implementation) + using OnCommandErrorCallbackFunct = std::function; + using OnGetSetupPINCommandResponseCallbackFunct = + std::function; + CHIP_ERROR GetSetupPIN(OnGetSetupPINCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::AccountLogin::GetSetupPINCommandParams::Type & params); + using OnLoginCommandResponseCallbackFunct = std::function; + CHIP_ERROR Login(OnLoginCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::AccountLogin::LoginCommandParams::Type & params); + // Cluster Attributes CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); @@ -62,6 +76,21 @@ class DLL_EXPORT AdministratorCommissioningCluster : public ClusterBase uint32_t iterations, chip::ByteSpan salt, uint16_t passcodeID); CHIP_ERROR RevokeCommissioning(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + // Cluster Commands (Cluster Object Implementation) + using OnCommandErrorCallbackFunct = std::function; + using OnOpenBasicCommissioningWindowCommandResponseCallbackFunct = std::function; + CHIP_ERROR OpenBasicCommissioningWindow( + OnOpenBasicCommissioningWindowCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::AdministratorCommissioning::OpenBasicCommissioningWindowCommandParams::Type & params); + using OnOpenCommissioningWindowCommandResponseCallbackFunct = std::function; + CHIP_ERROR + OpenCommissioningWindow(OnOpenCommissioningWindowCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::AdministratorCommissioning::OpenCommissioningWindowCommandParams::Type & params); + using OnRevokeCommissioningCommandResponseCallbackFunct = std::function; + CHIP_ERROR + RevokeCommissioning(OnRevokeCommissioningCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::AdministratorCommissioning::RevokeCommissioningCommandParams::Type & params); + // Cluster Attributes CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); @@ -77,6 +106,12 @@ class DLL_EXPORT ApplicationBasicCluster : public ClusterBase // Cluster Commands CHIP_ERROR ChangeStatus(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint8_t status); + // Cluster Commands (Cluster Object Implementation) + using OnCommandErrorCallbackFunct = std::function; + using OnChangeStatusCommandResponseCallbackFunct = std::function; + CHIP_ERROR ChangeStatus(OnChangeStatusCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::ApplicationBasic::ChangeStatusCommandParams::Type & params); + // Cluster Attributes CHIP_ERROR ReadAttributeVendorName(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR ReadAttributeVendorId(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); @@ -100,6 +135,13 @@ class DLL_EXPORT ApplicationLauncherCluster : public ClusterBase CHIP_ERROR LaunchApp(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, chip::ByteSpan data, uint16_t catalogVendorId, chip::ByteSpan applicationId); + // Cluster Commands (Cluster Object Implementation) + using OnCommandErrorCallbackFunct = std::function; + using OnLaunchAppCommandResponseCallbackFunct = + std::function; + CHIP_ERROR LaunchApp(OnLaunchAppCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::ApplicationLauncher::LaunchAppCommandParams::Type & params); + // Cluster Attributes CHIP_ERROR ReadAttributeApplicationLauncherList(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); @@ -121,6 +163,15 @@ class DLL_EXPORT AudioOutputCluster : public ClusterBase chip::ByteSpan name); CHIP_ERROR SelectOutput(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint8_t index); + // Cluster Commands (Cluster Object Implementation) + using OnCommandErrorCallbackFunct = std::function; + using OnRenameOutputCommandResponseCallbackFunct = std::function; + CHIP_ERROR RenameOutput(OnRenameOutputCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::AudioOutput::RenameOutputCommandParams::Type & params); + using OnSelectOutputCommandResponseCallbackFunct = std::function; + CHIP_ERROR SelectOutput(OnSelectOutputCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::AudioOutput::SelectOutputCommandParams::Type & params); + // Cluster Attributes CHIP_ERROR ReadAttributeAudioOutputList(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR ReadAttributeCurrentAudioOutput(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); @@ -140,6 +191,16 @@ class DLL_EXPORT BarrierControlCluster : public ClusterBase uint8_t percentOpen); CHIP_ERROR BarrierControlStop(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + // Cluster Commands (Cluster Object Implementation) + using OnCommandErrorCallbackFunct = std::function; + using OnBarrierControlGoToPercentCommandResponseCallbackFunct = std::function; + CHIP_ERROR + BarrierControlGoToPercent(OnBarrierControlGoToPercentCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::BarrierControl::BarrierControlGoToPercentCommandParams::Type & params); + using OnBarrierControlStopCommandResponseCallbackFunct = std::function; + CHIP_ERROR BarrierControlStop(OnBarrierControlStopCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::BarrierControl::BarrierControlStopCommandParams::Type & params); + // Cluster Attributes CHIP_ERROR ReadAttributeBarrierMovingState(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR ReadAttributeBarrierSafetyStatus(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); @@ -159,6 +220,12 @@ class DLL_EXPORT BasicCluster : public ClusterBase // Cluster Commands CHIP_ERROR MfgSpecificPing(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + // Cluster Commands (Cluster Object Implementation) + using OnCommandErrorCallbackFunct = std::function; + using OnMfgSpecificPingCommandResponseCallbackFunct = std::function; + CHIP_ERROR MfgSpecificPing(OnMfgSpecificPingCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::Basic::MfgSpecificPingCommandParams::Type & params); + // Cluster Attributes CHIP_ERROR ReadAttributeInteractionModelVersion(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); @@ -227,6 +294,15 @@ class DLL_EXPORT BindingCluster : public ClusterBase CHIP_ERROR Unbind(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, chip::NodeId nodeId, chip::GroupId groupId, chip::EndpointId endpointId, chip::ClusterId clusterId); + // Cluster Commands (Cluster Object Implementation) + using OnCommandErrorCallbackFunct = std::function; + using OnBindCommandResponseCallbackFunct = std::function; + CHIP_ERROR Bind(OnBindCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::Binding::BindCommandParams::Type & params); + using OnUnbindCommandResponseCallbackFunct = std::function; + CHIP_ERROR Unbind(OnUnbindCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::Binding::UnbindCommandParams::Type & params); + // Cluster Attributes CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); @@ -314,6 +390,67 @@ class DLL_EXPORT ColorControlCluster : public ClusterBase CHIP_ERROR StopMoveStep(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint8_t optionsMask, uint8_t optionsOverride); + // Cluster Commands (Cluster Object Implementation) + using OnCommandErrorCallbackFunct = std::function; + using OnColorLoopSetCommandResponseCallbackFunct = std::function; + CHIP_ERROR ColorLoopSet(OnColorLoopSetCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::ColorControl::ColorLoopSetCommandParams::Type & params); + using OnEnhancedMoveHueCommandResponseCallbackFunct = std::function; + CHIP_ERROR EnhancedMoveHue(OnEnhancedMoveHueCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::ColorControl::EnhancedMoveHueCommandParams::Type & params); + using OnEnhancedMoveToHueCommandResponseCallbackFunct = std::function; + CHIP_ERROR EnhancedMoveToHue(OnEnhancedMoveToHueCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::ColorControl::EnhancedMoveToHueCommandParams::Type & params); + using OnEnhancedMoveToHueAndSaturationCommandResponseCallbackFunct = std::function; + CHIP_ERROR + EnhancedMoveToHueAndSaturation(OnEnhancedMoveToHueAndSaturationCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::ColorControl::EnhancedMoveToHueAndSaturationCommandParams::Type & params); + using OnEnhancedStepHueCommandResponseCallbackFunct = std::function; + CHIP_ERROR EnhancedStepHue(OnEnhancedStepHueCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::ColorControl::EnhancedStepHueCommandParams::Type & params); + using OnMoveColorCommandResponseCallbackFunct = std::function; + CHIP_ERROR MoveColor(OnMoveColorCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::ColorControl::MoveColorCommandParams::Type & params); + using OnMoveColorTemperatureCommandResponseCallbackFunct = std::function; + CHIP_ERROR MoveColorTemperature(OnMoveColorTemperatureCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::ColorControl::MoveColorTemperatureCommandParams::Type & params); + using OnMoveHueCommandResponseCallbackFunct = std::function; + CHIP_ERROR MoveHue(OnMoveHueCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::ColorControl::MoveHueCommandParams::Type & params); + using OnMoveSaturationCommandResponseCallbackFunct = std::function; + CHIP_ERROR MoveSaturation(OnMoveSaturationCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::ColorControl::MoveSaturationCommandParams::Type & params); + using OnMoveToColorCommandResponseCallbackFunct = std::function; + CHIP_ERROR MoveToColor(OnMoveToColorCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::ColorControl::MoveToColorCommandParams::Type & params); + using OnMoveToColorTemperatureCommandResponseCallbackFunct = std::function; + CHIP_ERROR MoveToColorTemperature(OnMoveToColorTemperatureCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::ColorControl::MoveToColorTemperatureCommandParams::Type & params); + using OnMoveToHueCommandResponseCallbackFunct = std::function; + CHIP_ERROR MoveToHue(OnMoveToHueCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::ColorControl::MoveToHueCommandParams::Type & params); + using OnMoveToHueAndSaturationCommandResponseCallbackFunct = std::function; + CHIP_ERROR MoveToHueAndSaturation(OnMoveToHueAndSaturationCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::ColorControl::MoveToHueAndSaturationCommandParams::Type & params); + using OnMoveToSaturationCommandResponseCallbackFunct = std::function; + CHIP_ERROR MoveToSaturation(OnMoveToSaturationCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::ColorControl::MoveToSaturationCommandParams::Type & params); + using OnStepColorCommandResponseCallbackFunct = std::function; + CHIP_ERROR StepColor(OnStepColorCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::ColorControl::StepColorCommandParams::Type & params); + using OnStepColorTemperatureCommandResponseCallbackFunct = std::function; + CHIP_ERROR StepColorTemperature(OnStepColorTemperatureCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::ColorControl::StepColorTemperatureCommandParams::Type & params); + using OnStepHueCommandResponseCallbackFunct = std::function; + CHIP_ERROR StepHue(OnStepHueCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::ColorControl::StepHueCommandParams::Type & params); + using OnStepSaturationCommandResponseCallbackFunct = std::function; + CHIP_ERROR StepSaturation(OnStepSaturationCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::ColorControl::StepSaturationCommandParams::Type & params); + using OnStopMoveStepCommandResponseCallbackFunct = std::function; + CHIP_ERROR StopMoveStep(OnStopMoveStepCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::ColorControl::StopMoveStepCommandParams::Type & params); + // Cluster Attributes CHIP_ERROR ReadAttributeCurrentHue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR ReadAttributeCurrentSaturation(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); @@ -436,6 +573,17 @@ class DLL_EXPORT ContentLauncherCluster : public ClusterBase CHIP_ERROR LaunchURL(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, chip::ByteSpan contentURL, chip::ByteSpan displayString); + // Cluster Commands (Cluster Object Implementation) + using OnCommandErrorCallbackFunct = std::function; + using OnLaunchContentCommandResponseCallbackFunct = + std::function; + CHIP_ERROR LaunchContent(OnLaunchContentCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::ContentLauncher::LaunchContentCommandParams::Type & params); + using OnLaunchURLCommandResponseCallbackFunct = + std::function; + CHIP_ERROR LaunchURL(OnLaunchURLCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::ContentLauncher::LaunchURLCommandParams::Type & params); + // Cluster Attributes CHIP_ERROR ReadAttributeAcceptsHeaderList(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR ReadAttributeSupportedStreamingTypes(Callback::Cancelable * onSuccessCallback, @@ -469,6 +617,12 @@ class DLL_EXPORT DiagnosticLogsCluster : public ClusterBase CHIP_ERROR RetrieveLogsRequest(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint8_t intent, uint8_t requestedProtocol, chip::ByteSpan transferFileDesignator); + // Cluster Commands (Cluster Object Implementation) + using OnCommandErrorCallbackFunct = std::function; + using OnRetrieveLogsRequestCommandResponseCallbackFunct = std::function; + CHIP_ERROR RetrieveLogsRequest(OnRetrieveLogsRequestCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::DiagnosticLogs::RetrieveLogsRequestCommandParams::Type & params); + // Cluster Attributes private: @@ -520,6 +674,101 @@ class DLL_EXPORT DoorLockCluster : public ClusterBase CHIP_ERROR UnlockWithTimeout(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t timeoutInSeconds, chip::ByteSpan pin); + // Cluster Commands (Cluster Object Implementation) + using OnCommandErrorCallbackFunct = std::function; + using OnClearAllPinsCommandResponseCallbackFunct = + std::function; + CHIP_ERROR ClearAllPins(OnClearAllPinsCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::DoorLock::ClearAllPinsCommandParams::Type & params); + using OnClearAllRfidsCommandResponseCallbackFunct = + std::function; + CHIP_ERROR ClearAllRfids(OnClearAllRfidsCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::DoorLock::ClearAllRfidsCommandParams::Type & params); + using OnClearHolidayScheduleCommandResponseCallbackFunct = + std::function; + CHIP_ERROR ClearHolidaySchedule(OnClearHolidayScheduleCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::DoorLock::ClearHolidayScheduleCommandParams::Type & params); + using OnClearPinCommandResponseCallbackFunct = + std::function; + CHIP_ERROR ClearPin(OnClearPinCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::DoorLock::ClearPinCommandParams::Type & params); + using OnClearRfidCommandResponseCallbackFunct = + std::function; + CHIP_ERROR ClearRfid(OnClearRfidCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::DoorLock::ClearRfidCommandParams::Type & params); + using OnClearWeekdayScheduleCommandResponseCallbackFunct = + std::function; + CHIP_ERROR ClearWeekdaySchedule(OnClearWeekdayScheduleCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::DoorLock::ClearWeekdayScheduleCommandParams::Type & params); + using OnClearYeardayScheduleCommandResponseCallbackFunct = + std::function; + CHIP_ERROR ClearYeardaySchedule(OnClearYeardayScheduleCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::DoorLock::ClearYeardayScheduleCommandParams::Type & params); + using OnGetHolidayScheduleCommandResponseCallbackFunct = + std::function; + CHIP_ERROR GetHolidaySchedule(OnGetHolidayScheduleCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::DoorLock::GetHolidayScheduleCommandParams::Type & params); + using OnGetLogRecordCommandResponseCallbackFunct = + std::function; + CHIP_ERROR GetLogRecord(OnGetLogRecordCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::DoorLock::GetLogRecordCommandParams::Type & params); + using OnGetPinCommandResponseCallbackFunct = + std::function; + CHIP_ERROR GetPin(OnGetPinCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::DoorLock::GetPinCommandParams::Type & params); + using OnGetRfidCommandResponseCallbackFunct = + std::function; + CHIP_ERROR GetRfid(OnGetRfidCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::DoorLock::GetRfidCommandParams::Type & params); + using OnGetUserTypeCommandResponseCallbackFunct = + std::function; + CHIP_ERROR GetUserType(OnGetUserTypeCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::DoorLock::GetUserTypeCommandParams::Type & params); + using OnGetWeekdayScheduleCommandResponseCallbackFunct = + std::function; + CHIP_ERROR GetWeekdaySchedule(OnGetWeekdayScheduleCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::DoorLock::GetWeekdayScheduleCommandParams::Type & params); + using OnGetYeardayScheduleCommandResponseCallbackFunct = + std::function; + CHIP_ERROR GetYeardaySchedule(OnGetYeardayScheduleCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::DoorLock::GetYeardayScheduleCommandParams::Type & params); + using OnLockDoorCommandResponseCallbackFunct = + std::function; + CHIP_ERROR LockDoor(OnLockDoorCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::DoorLock::LockDoorCommandParams::Type & params); + using OnSetHolidayScheduleCommandResponseCallbackFunct = + std::function; + CHIP_ERROR SetHolidaySchedule(OnSetHolidayScheduleCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::DoorLock::SetHolidayScheduleCommandParams::Type & params); + using OnSetPinCommandResponseCallbackFunct = + std::function; + CHIP_ERROR SetPin(OnSetPinCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::DoorLock::SetPinCommandParams::Type & params); + using OnSetRfidCommandResponseCallbackFunct = + std::function; + CHIP_ERROR SetRfid(OnSetRfidCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::DoorLock::SetRfidCommandParams::Type & params); + using OnSetUserTypeCommandResponseCallbackFunct = + std::function; + CHIP_ERROR SetUserType(OnSetUserTypeCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::DoorLock::SetUserTypeCommandParams::Type & params); + using OnSetWeekdayScheduleCommandResponseCallbackFunct = + std::function; + CHIP_ERROR SetWeekdaySchedule(OnSetWeekdayScheduleCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::DoorLock::SetWeekdayScheduleCommandParams::Type & params); + using OnSetYeardayScheduleCommandResponseCallbackFunct = + std::function; + CHIP_ERROR SetYeardaySchedule(OnSetYeardayScheduleCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::DoorLock::SetYeardayScheduleCommandParams::Type & params); + using OnUnlockDoorCommandResponseCallbackFunct = + std::function; + CHIP_ERROR UnlockDoor(OnUnlockDoorCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::DoorLock::UnlockDoorCommandParams::Type & params); + using OnUnlockWithTimeoutCommandResponseCallbackFunct = + std::function; + CHIP_ERROR UnlockWithTimeout(OnUnlockWithTimeoutCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::DoorLock::UnlockWithTimeoutCommandParams::Type & params); + // Cluster Attributes CHIP_ERROR ReadAttributeLockState(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR ReadAttributeLockType(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); @@ -562,6 +811,12 @@ class DLL_EXPORT EthernetNetworkDiagnosticsCluster : public ClusterBase // Cluster Commands CHIP_ERROR ResetCounts(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + // Cluster Commands (Cluster Object Implementation) + using OnCommandErrorCallbackFunct = std::function; + using OnResetCountsCommandResponseCallbackFunct = std::function; + CHIP_ERROR ResetCounts(OnResetCountsCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::EthernetNetworkDiagnostics::ResetCountsCommandParams::Type & params); + // Cluster Attributes CHIP_ERROR ReadAttributePacketRxCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR ReadAttributePacketTxCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); @@ -610,6 +865,21 @@ class DLL_EXPORT GeneralCommissioningCluster : public ClusterBase CHIP_ERROR SetRegulatoryConfig(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint8_t location, chip::ByteSpan countryCode, uint64_t breadcrumb, uint32_t timeoutMs); + // Cluster Commands (Cluster Object Implementation) + using OnCommandErrorCallbackFunct = std::function; + using OnArmFailSafeCommandResponseCallbackFunct = + std::function; + CHIP_ERROR ArmFailSafe(OnArmFailSafeCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::GeneralCommissioning::ArmFailSafeCommandParams::Type & params); + using OnCommissioningCompleteCommandResponseCallbackFunct = + std::function; + CHIP_ERROR CommissioningComplete(OnCommissioningCompleteCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::GeneralCommissioning::CommissioningCompleteCommandParams::Type & params); + using OnSetRegulatoryConfigCommandResponseCallbackFunct = + std::function; + CHIP_ERROR SetRegulatoryConfig(OnSetRegulatoryConfigCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::GeneralCommissioning::SetRegulatoryConfigCommandParams::Type & params); + // Cluster Attributes CHIP_ERROR ReadAttributeBreadcrumb(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR ReadAttributeBasicCommissioningInfoList(Callback::Cancelable * onSuccessCallback, @@ -666,6 +936,31 @@ class DLL_EXPORT GroupsCluster : public ClusterBase CHIP_ERROR RemoveGroup(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t groupId); CHIP_ERROR ViewGroup(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t groupId); + // Cluster Commands (Cluster Object Implementation) + using OnCommandErrorCallbackFunct = std::function; + using OnAddGroupCommandResponseCallbackFunct = + std::function; + CHIP_ERROR AddGroup(OnAddGroupCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::Groups::AddGroupCommandParams::Type & params); + using OnAddGroupIfIdentifyingCommandResponseCallbackFunct = std::function; + CHIP_ERROR AddGroupIfIdentifying(OnAddGroupIfIdentifyingCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::Groups::AddGroupIfIdentifyingCommandParams::Type & params); + using OnGetGroupMembershipCommandResponseCallbackFunct = + std::function; + CHIP_ERROR GetGroupMembership(OnGetGroupMembershipCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::Groups::GetGroupMembershipCommandParams::Type & params); + using OnRemoveAllGroupsCommandResponseCallbackFunct = std::function; + CHIP_ERROR RemoveAllGroups(OnRemoveAllGroupsCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::Groups::RemoveAllGroupsCommandParams::Type & params); + using OnRemoveGroupCommandResponseCallbackFunct = + std::function; + CHIP_ERROR RemoveGroup(OnRemoveGroupCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::Groups::RemoveGroupCommandParams::Type & params); + using OnViewGroupCommandResponseCallbackFunct = + std::function; + CHIP_ERROR ViewGroup(OnViewGroupCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::Groups::ViewGroupCommandParams::Type & params); + // Cluster Attributes CHIP_ERROR ReadAttributeNameSupport(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); @@ -683,6 +978,16 @@ class DLL_EXPORT IdentifyCluster : public ClusterBase CHIP_ERROR Identify(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t identifyTime); CHIP_ERROR IdentifyQuery(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + // Cluster Commands (Cluster Object Implementation) + using OnCommandErrorCallbackFunct = std::function; + using OnIdentifyCommandResponseCallbackFunct = std::function; + CHIP_ERROR Identify(OnIdentifyCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::Identify::IdentifyCommandParams::Type & params); + using OnIdentifyQueryCommandResponseCallbackFunct = + std::function; + CHIP_ERROR IdentifyQuery(OnIdentifyQueryCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::Identify::IdentifyQueryCommandParams::Type & params); + // Cluster Attributes CHIP_ERROR ReadAttributeIdentifyTime(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); @@ -701,6 +1006,13 @@ class DLL_EXPORT KeypadInputCluster : public ClusterBase // Cluster Commands CHIP_ERROR SendKey(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint8_t keyCode); + // Cluster Commands (Cluster Object Implementation) + using OnCommandErrorCallbackFunct = std::function; + using OnSendKeyCommandResponseCallbackFunct = + std::function; + CHIP_ERROR SendKey(OnSendKeyCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::KeypadInput::SendKeyCommandParams::Type & params); + // Cluster Attributes CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); @@ -730,6 +1042,33 @@ class DLL_EXPORT LevelControlCluster : public ClusterBase uint8_t optionOverride); CHIP_ERROR StopWithOnOff(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + // Cluster Commands (Cluster Object Implementation) + using OnCommandErrorCallbackFunct = std::function; + using OnMoveCommandResponseCallbackFunct = std::function; + CHIP_ERROR Move(OnMoveCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::LevelControl::MoveCommandParams::Type & params); + using OnMoveToLevelCommandResponseCallbackFunct = std::function; + CHIP_ERROR MoveToLevel(OnMoveToLevelCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::LevelControl::MoveToLevelCommandParams::Type & params); + using OnMoveToLevelWithOnOffCommandResponseCallbackFunct = std::function; + CHIP_ERROR MoveToLevelWithOnOff(OnMoveToLevelWithOnOffCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::LevelControl::MoveToLevelWithOnOffCommandParams::Type & params); + using OnMoveWithOnOffCommandResponseCallbackFunct = std::function; + CHIP_ERROR MoveWithOnOff(OnMoveWithOnOffCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::LevelControl::MoveWithOnOffCommandParams::Type & params); + using OnStepCommandResponseCallbackFunct = std::function; + CHIP_ERROR Step(OnStepCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::LevelControl::StepCommandParams::Type & params); + using OnStepWithOnOffCommandResponseCallbackFunct = std::function; + CHIP_ERROR StepWithOnOff(OnStepWithOnOffCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::LevelControl::StepWithOnOffCommandParams::Type & params); + using OnStopCommandResponseCallbackFunct = std::function; + CHIP_ERROR Stop(OnStopCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::LevelControl::StopCommandParams::Type & params); + using OnStopWithOnOffCommandResponseCallbackFunct = std::function; + CHIP_ERROR StopWithOnOff(OnStopWithOnOffCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::LevelControl::StopWithOnOffCommandParams::Type & params); + // Cluster Attributes CHIP_ERROR ReadAttributeCurrentLevel(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); @@ -749,6 +1088,12 @@ class DLL_EXPORT LowPowerCluster : public ClusterBase // Cluster Commands CHIP_ERROR Sleep(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + // Cluster Commands (Cluster Object Implementation) + using OnCommandErrorCallbackFunct = std::function; + using OnSleepCommandResponseCallbackFunct = std::function; + CHIP_ERROR Sleep(OnSleepCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::LowPower::SleepCommandParams::Type & params); + // Cluster Attributes CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); @@ -768,6 +1113,21 @@ class DLL_EXPORT MediaInputCluster : public ClusterBase CHIP_ERROR SelectInput(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint8_t index); CHIP_ERROR ShowInputStatus(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + // Cluster Commands (Cluster Object Implementation) + using OnCommandErrorCallbackFunct = std::function; + using OnHideInputStatusCommandResponseCallbackFunct = std::function; + CHIP_ERROR HideInputStatus(OnHideInputStatusCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::MediaInput::HideInputStatusCommandParams::Type & params); + using OnRenameInputCommandResponseCallbackFunct = std::function; + CHIP_ERROR RenameInput(OnRenameInputCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::MediaInput::RenameInputCommandParams::Type & params); + using OnSelectInputCommandResponseCallbackFunct = std::function; + CHIP_ERROR SelectInput(OnSelectInputCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::MediaInput::SelectInputCommandParams::Type & params); + using OnShowInputStatusCommandResponseCallbackFunct = std::function; + CHIP_ERROR ShowInputStatus(OnShowInputStatusCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::MediaInput::ShowInputStatusCommandParams::Type & params); + // Cluster Attributes CHIP_ERROR ReadAttributeMediaInputList(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR ReadAttributeCurrentMediaInput(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); @@ -797,6 +1157,53 @@ class DLL_EXPORT MediaPlaybackCluster : public ClusterBase CHIP_ERROR MediaStartOver(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR MediaStop(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + // Cluster Commands (Cluster Object Implementation) + using OnCommandErrorCallbackFunct = std::function; + using OnMediaFastForwardCommandResponseCallbackFunct = + std::function; + CHIP_ERROR MediaFastForward(OnMediaFastForwardCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::MediaPlayback::MediaFastForwardCommandParams::Type & params); + using OnMediaNextCommandResponseCallbackFunct = + std::function; + CHIP_ERROR MediaNext(OnMediaNextCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::MediaPlayback::MediaNextCommandParams::Type & params); + using OnMediaPauseCommandResponseCallbackFunct = + std::function; + CHIP_ERROR MediaPause(OnMediaPauseCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::MediaPlayback::MediaPauseCommandParams::Type & params); + using OnMediaPlayCommandResponseCallbackFunct = + std::function; + CHIP_ERROR MediaPlay(OnMediaPlayCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::MediaPlayback::MediaPlayCommandParams::Type & params); + using OnMediaPreviousCommandResponseCallbackFunct = + std::function; + CHIP_ERROR MediaPrevious(OnMediaPreviousCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::MediaPlayback::MediaPreviousCommandParams::Type & params); + using OnMediaRewindCommandResponseCallbackFunct = + std::function; + CHIP_ERROR MediaRewind(OnMediaRewindCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::MediaPlayback::MediaRewindCommandParams::Type & params); + using OnMediaSeekCommandResponseCallbackFunct = + std::function; + CHIP_ERROR MediaSeek(OnMediaSeekCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::MediaPlayback::MediaSeekCommandParams::Type & params); + using OnMediaSkipBackwardCommandResponseCallbackFunct = + std::function; + CHIP_ERROR MediaSkipBackward(OnMediaSkipBackwardCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::MediaPlayback::MediaSkipBackwardCommandParams::Type & params); + using OnMediaSkipForwardCommandResponseCallbackFunct = + std::function; + CHIP_ERROR MediaSkipForward(OnMediaSkipForwardCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::MediaPlayback::MediaSkipForwardCommandParams::Type & params); + using OnMediaStartOverCommandResponseCallbackFunct = + std::function; + CHIP_ERROR MediaStartOver(OnMediaStartOverCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::MediaPlayback::MediaStartOverCommandParams::Type & params); + using OnMediaStopCommandResponseCallbackFunct = + std::function; + CHIP_ERROR MediaStop(OnMediaStopCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::MediaPlayback::MediaStopCommandParams::Type & params); + // Cluster Attributes CHIP_ERROR ReadAttributePlaybackState(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR ReadAttributeStartTime(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); @@ -837,6 +1244,45 @@ class DLL_EXPORT NetworkCommissioningCluster : public ClusterBase CHIP_ERROR UpdateWiFiNetwork(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, chip::ByteSpan ssid, chip::ByteSpan credentials, uint64_t breadcrumb, uint32_t timeoutMs); + // Cluster Commands (Cluster Object Implementation) + using OnCommandErrorCallbackFunct = std::function; + using OnAddThreadNetworkCommandResponseCallbackFunct = + std::function; + CHIP_ERROR AddThreadNetwork(OnAddThreadNetworkCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::NetworkCommissioning::AddThreadNetworkCommandParams::Type & params); + using OnAddWiFiNetworkCommandResponseCallbackFunct = + std::function; + CHIP_ERROR AddWiFiNetwork(OnAddWiFiNetworkCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::NetworkCommissioning::AddWiFiNetworkCommandParams::Type & params); + using OnDisableNetworkCommandResponseCallbackFunct = + std::function; + CHIP_ERROR DisableNetwork(OnDisableNetworkCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::NetworkCommissioning::DisableNetworkCommandParams::Type & params); + using OnEnableNetworkCommandResponseCallbackFunct = + std::function; + CHIP_ERROR EnableNetwork(OnEnableNetworkCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::NetworkCommissioning::EnableNetworkCommandParams::Type & params); + using OnGetLastNetworkCommissioningResultCommandResponseCallbackFunct = std::function; + CHIP_ERROR GetLastNetworkCommissioningResult( + OnGetLastNetworkCommissioningResultCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::NetworkCommissioning::GetLastNetworkCommissioningResultCommandParams::Type & params); + using OnRemoveNetworkCommandResponseCallbackFunct = + std::function; + CHIP_ERROR RemoveNetwork(OnRemoveNetworkCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::NetworkCommissioning::RemoveNetworkCommandParams::Type & params); + using OnScanNetworksCommandResponseCallbackFunct = + std::function; + CHIP_ERROR ScanNetworks(OnScanNetworksCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::NetworkCommissioning::ScanNetworksCommandParams::Type & params); + using OnUpdateThreadNetworkCommandResponseCallbackFunct = + std::function; + CHIP_ERROR UpdateThreadNetwork(OnUpdateThreadNetworkCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::NetworkCommissioning::UpdateThreadNetworkCommandParams::Type & params); + using OnUpdateWiFiNetworkCommandResponseCallbackFunct = + std::function; + CHIP_ERROR UpdateWiFiNetwork(OnUpdateWiFiNetworkCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::NetworkCommissioning::UpdateWiFiNetworkCommandParams::Type & params); + // Cluster Attributes CHIP_ERROR ReadAttributeFeatureMap(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); @@ -860,6 +1306,20 @@ class DLL_EXPORT OtaSoftwareUpdateProviderCluster : public ClusterBase uint8_t protocolsSupported, chip::ByteSpan location, bool requestorCanConsent, chip::ByteSpan metadataForProvider); + // Cluster Commands (Cluster Object Implementation) + using OnCommandErrorCallbackFunct = std::function; + using OnApplyUpdateRequestCommandResponseCallbackFunct = + std::function; + CHIP_ERROR ApplyUpdateRequest(OnApplyUpdateRequestCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::OtaSoftwareUpdateProvider::ApplyUpdateRequestCommandParams::Type & params); + using OnNotifyUpdateAppliedCommandResponseCallbackFunct = std::function; + CHIP_ERROR NotifyUpdateApplied(OnNotifyUpdateAppliedCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::OtaSoftwareUpdateProvider::NotifyUpdateAppliedCommandParams::Type & params); + using OnQueryImageCommandResponseCallbackFunct = + std::function; + CHIP_ERROR QueryImage(OnQueryImageCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::OtaSoftwareUpdateProvider::QueryImageCommandParams::Type & params); + // Cluster Attributes CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); @@ -877,6 +1337,13 @@ class DLL_EXPORT OtaSoftwareUpdateRequestorCluster : public ClusterBase chip::ByteSpan serverLocation, uint16_t vendorId, uint8_t announcementReason, chip::ByteSpan metadataForNode); + // Cluster Commands (Cluster Object Implementation) + using OnCommandErrorCallbackFunct = std::function; + using OnAnnounceOtaProviderCommandResponseCallbackFunct = std::function; + CHIP_ERROR + AnnounceOtaProvider(OnAnnounceOtaProviderCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::OtaSoftwareUpdateRequestor::AnnounceOtaProviderCommandParams::Type & params); + // Cluster Attributes CHIP_ERROR ReadAttributeDefaultOtaProvider(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR ReadAttributeUpdatePossible(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); @@ -920,6 +1387,27 @@ class DLL_EXPORT OnOffCluster : public ClusterBase uint8_t onOffControl, uint16_t onTime, uint16_t offWaitTime); CHIP_ERROR Toggle(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + // Cluster Commands (Cluster Object Implementation) + using OnCommandErrorCallbackFunct = std::function; + using OnOffCommandResponseCallbackFunct = std::function; + CHIP_ERROR Off(OnOffCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::OnOff::OffCommandParams::Type & params); + using OnOffWithEffectCommandResponseCallbackFunct = std::function; + CHIP_ERROR OffWithEffect(OnOffWithEffectCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::OnOff::OffWithEffectCommandParams::Type & params); + using OnOnCommandResponseCallbackFunct = std::function; + CHIP_ERROR On(OnOnCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::OnOff::OnCommandParams::Type & params); + using OnOnWithRecallGlobalSceneCommandResponseCallbackFunct = std::function; + CHIP_ERROR OnWithRecallGlobalScene(OnOnWithRecallGlobalSceneCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::OnOff::OnWithRecallGlobalSceneCommandParams::Type & params); + using OnOnWithTimedOffCommandResponseCallbackFunct = std::function; + CHIP_ERROR OnWithTimedOff(OnOnWithTimedOffCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::OnOff::OnWithTimedOffCommandParams::Type & params); + using OnToggleCommandResponseCallbackFunct = std::function; + CHIP_ERROR Toggle(OnToggleCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::OnOff::ToggleCommandParams::Type & params); + // Cluster Attributes CHIP_ERROR ReadAttributeOnOff(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR ReadAttributeGlobalSceneControl(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); @@ -981,6 +1469,46 @@ class DLL_EXPORT OperationalCredentialsCluster : public ClusterBase CHIP_ERROR UpdateNOC(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, chip::ByteSpan nOCValue, chip::ByteSpan iCACValue); + // Cluster Commands (Cluster Object Implementation) + using OnCommandErrorCallbackFunct = std::function; + using OnAddNOCCommandResponseCallbackFunct = + std::function; + CHIP_ERROR AddNOC(OnAddNOCCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::OperationalCredentials::AddNOCCommandParams::Type & params); + using OnAddTrustedRootCertificateCommandResponseCallbackFunct = std::function; + CHIP_ERROR + AddTrustedRootCertificate(OnAddTrustedRootCertificateCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::OperationalCredentials::AddTrustedRootCertificateCommandParams::Type & params); + using OnAttestationRequestCommandResponseCallbackFunct = + std::function; + CHIP_ERROR AttestationRequest(OnAttestationRequestCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::OperationalCredentials::AttestationRequestCommandParams::Type & params); + using OnCertificateChainRequestCommandResponseCallbackFunct = + std::function; + CHIP_ERROR + CertificateChainRequest(OnCertificateChainRequestCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::OperationalCredentials::CertificateChainRequestCommandParams::Type & params); + using OnOpCSRRequestCommandResponseCallbackFunct = + std::function; + CHIP_ERROR OpCSRRequest(OnOpCSRRequestCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::OperationalCredentials::OpCSRRequestCommandParams::Type & params); + using OnRemoveFabricCommandResponseCallbackFunct = + std::function; + CHIP_ERROR RemoveFabric(OnRemoveFabricCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::OperationalCredentials::RemoveFabricCommandParams::Type & params); + using OnRemoveTrustedRootCertificateCommandResponseCallbackFunct = std::function; + CHIP_ERROR RemoveTrustedRootCertificate( + OnRemoveTrustedRootCertificateCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::OperationalCredentials::RemoveTrustedRootCertificateCommandParams::Type & params); + using OnUpdateFabricLabelCommandResponseCallbackFunct = + std::function; + CHIP_ERROR UpdateFabricLabel(OnUpdateFabricLabelCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::OperationalCredentials::UpdateFabricLabelCommandParams::Type & params); + using OnUpdateNOCCommandResponseCallbackFunct = + std::function; + CHIP_ERROR UpdateNOC(OnUpdateNOCCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::OperationalCredentials::UpdateNOCCommandParams::Type & params); + // Cluster Attributes CHIP_ERROR ReadAttributeFabricsList(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR ReadAttributeSupportedFabrics(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); @@ -1091,6 +1619,36 @@ class DLL_EXPORT ScenesCluster : public ClusterBase CHIP_ERROR ViewScene(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t groupId, uint8_t sceneId); + // Cluster Commands (Cluster Object Implementation) + using OnCommandErrorCallbackFunct = std::function; + using OnAddSceneCommandResponseCallbackFunct = + std::function; + CHIP_ERROR AddScene(OnAddSceneCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::Scenes::AddSceneCommandParams::Type & params); + using OnGetSceneMembershipCommandResponseCallbackFunct = + std::function; + CHIP_ERROR GetSceneMembership(OnGetSceneMembershipCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::Scenes::GetSceneMembershipCommandParams::Type & params); + using OnRecallSceneCommandResponseCallbackFunct = std::function; + CHIP_ERROR RecallScene(OnRecallSceneCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::Scenes::RecallSceneCommandParams::Type & params); + using OnRemoveAllScenesCommandResponseCallbackFunct = + std::function; + CHIP_ERROR RemoveAllScenes(OnRemoveAllScenesCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::Scenes::RemoveAllScenesCommandParams::Type & params); + using OnRemoveSceneCommandResponseCallbackFunct = + std::function; + CHIP_ERROR RemoveScene(OnRemoveSceneCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::Scenes::RemoveSceneCommandParams::Type & params); + using OnStoreSceneCommandResponseCallbackFunct = + std::function; + CHIP_ERROR StoreScene(OnStoreSceneCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::Scenes::StoreSceneCommandParams::Type & params); + using OnViewSceneCommandResponseCallbackFunct = + std::function; + CHIP_ERROR ViewScene(OnViewSceneCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::Scenes::ViewSceneCommandParams::Type & params); + // Cluster Attributes CHIP_ERROR ReadAttributeSceneCount(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR ReadAttributeCurrentScene(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); @@ -1111,6 +1669,12 @@ class DLL_EXPORT SoftwareDiagnosticsCluster : public ClusterBase // Cluster Commands CHIP_ERROR ResetWatermarks(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + // Cluster Commands (Cluster Object Implementation) + using OnCommandErrorCallbackFunct = std::function; + using OnResetWatermarksCommandResponseCallbackFunct = std::function; + CHIP_ERROR ResetWatermarks(OnResetWatermarksCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::SoftwareDiagnostics::ResetWatermarksCommandParams::Type & params); + // Cluster Attributes CHIP_ERROR ReadAttributeCurrentHeapFree(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR ReadAttributeCurrentHeapUsed(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); @@ -1149,6 +1713,19 @@ class DLL_EXPORT TvChannelCluster : public ClusterBase uint16_t majorNumber, uint16_t minorNumber); CHIP_ERROR SkipChannel(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t count); + // Cluster Commands (Cluster Object Implementation) + using OnCommandErrorCallbackFunct = std::function; + using OnChangeChannelCommandResponseCallbackFunct = + std::function; + CHIP_ERROR ChangeChannel(OnChangeChannelCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::TvChannel::ChangeChannelCommandParams::Type & params); + using OnChangeChannelByNumberCommandResponseCallbackFunct = std::function; + CHIP_ERROR ChangeChannelByNumber(OnChangeChannelByNumberCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::TvChannel::ChangeChannelByNumberCommandParams::Type & params); + using OnSkipChannelCommandResponseCallbackFunct = std::function; + CHIP_ERROR SkipChannel(OnSkipChannelCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::TvChannel::SkipChannelCommandParams::Type & params); + // Cluster Attributes CHIP_ERROR ReadAttributeTvChannelList(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR ReadAttributeTvChannelLineup(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); @@ -1168,6 +1745,13 @@ class DLL_EXPORT TargetNavigatorCluster : public ClusterBase CHIP_ERROR NavigateTarget(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint8_t target, chip::ByteSpan data); + // Cluster Commands (Cluster Object Implementation) + using OnCommandErrorCallbackFunct = std::function; + using OnNavigateTargetCommandResponseCallbackFunct = + std::function; + CHIP_ERROR NavigateTarget(OnNavigateTargetCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::TargetNavigator::NavigateTargetCommandParams::Type & params); + // Cluster Attributes CHIP_ERROR ReadAttributeTargetNavigatorList(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); @@ -1205,6 +1789,26 @@ class DLL_EXPORT TestClusterCluster : public ClusterBase CHIP_ERROR TestSpecific(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR TestUnknownCommand(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + // Cluster Commands (Cluster Object Implementation) + using OnCommandErrorCallbackFunct = std::function; + using OnTestCommandResponseCallbackFunct = std::function; + CHIP_ERROR Test(OnTestCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::TestCluster::TestCommandParams::Type & params); + using OnTestAddArgumentsCommandResponseCallbackFunct = + std::function; + CHIP_ERROR TestAddArguments(OnTestAddArgumentsCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::TestCluster::TestAddArgumentsCommandParams::Type & params); + using OnTestNotHandledCommandResponseCallbackFunct = std::function; + CHIP_ERROR TestNotHandled(OnTestNotHandledCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::TestCluster::TestNotHandledCommandParams::Type & params); + using OnTestSpecificCommandResponseCallbackFunct = + std::function; + CHIP_ERROR TestSpecific(OnTestSpecificCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::TestCluster::TestSpecificCommandParams::Type & params); + using OnTestUnknownCommandCommandResponseCallbackFunct = std::function; + CHIP_ERROR TestUnknownCommand(OnTestUnknownCommandCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::TestCluster::TestUnknownCommandCommandParams::Type & params); + // Cluster Attributes CHIP_ERROR ReadAttributeBoolean(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR ReadAttributeBitmap8(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); @@ -1298,6 +1902,24 @@ class DLL_EXPORT ThermostatCluster : public ClusterBase CHIP_ERROR SetpointRaiseLower(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint8_t mode, int8_t amount); + // Cluster Commands (Cluster Object Implementation) + using OnCommandErrorCallbackFunct = std::function; + using OnClearWeeklyScheduleCommandResponseCallbackFunct = std::function; + CHIP_ERROR ClearWeeklySchedule(OnClearWeeklyScheduleCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::Thermostat::ClearWeeklyScheduleCommandParams::Type & params); + using OnGetRelayStatusLogCommandResponseCallbackFunct = std::function; + CHIP_ERROR GetRelayStatusLog(OnGetRelayStatusLogCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::Thermostat::GetRelayStatusLogCommandParams::Type & params); + using OnGetWeeklyScheduleCommandResponseCallbackFunct = std::function; + CHIP_ERROR GetWeeklySchedule(OnGetWeeklyScheduleCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::Thermostat::GetWeeklyScheduleCommandParams::Type & params); + using OnSetWeeklyScheduleCommandResponseCallbackFunct = std::function; + CHIP_ERROR SetWeeklySchedule(OnSetWeeklyScheduleCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::Thermostat::SetWeeklyScheduleCommandParams::Type & params); + using OnSetpointRaiseLowerCommandResponseCallbackFunct = std::function; + CHIP_ERROR SetpointRaiseLower(OnSetpointRaiseLowerCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::Thermostat::SetpointRaiseLowerCommandParams::Type & params); + // Cluster Attributes CHIP_ERROR ReadAttributeLocalTemperature(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR ReadAttributeAbsMinHeatSetpointLimit(Callback::Cancelable * onSuccessCallback, @@ -1384,6 +2006,12 @@ class DLL_EXPORT ThreadNetworkDiagnosticsCluster : public ClusterBase // Cluster Commands CHIP_ERROR ResetCounts(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + // Cluster Commands (Cluster Object Implementation) + using OnCommandErrorCallbackFunct = std::function; + using OnResetCountsCommandResponseCallbackFunct = std::function; + CHIP_ERROR ResetCounts(OnResetCountsCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::ThreadNetworkDiagnostics::ResetCountsCommandParams::Type & params); + // Cluster Attributes CHIP_ERROR ReadAttributeChannel(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR ReadAttributeRoutingRole(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); @@ -1487,6 +2115,12 @@ class DLL_EXPORT WiFiNetworkDiagnosticsCluster : public ClusterBase // Cluster Commands CHIP_ERROR ResetCounts(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + // Cluster Commands (Cluster Object Implementation) + using OnCommandErrorCallbackFunct = std::function; + using OnResetCountsCommandResponseCallbackFunct = std::function; + CHIP_ERROR ResetCounts(OnResetCountsCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::WiFiNetworkDiagnostics::ResetCountsCommandParams::Type & params); + // Cluster Attributes CHIP_ERROR ReadAttributeBssid(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR ReadAttributeSecurityType(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); @@ -1517,6 +2151,30 @@ class DLL_EXPORT WindowCoveringCluster : public ClusterBase CHIP_ERROR StopMotion(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR UpOrOpen(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + // Cluster Commands (Cluster Object Implementation) + using OnCommandErrorCallbackFunct = std::function; + using OnDownOrCloseCommandResponseCallbackFunct = std::function; + CHIP_ERROR DownOrClose(OnDownOrCloseCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::WindowCovering::DownOrCloseCommandParams::Type & params); + using OnGoToLiftPercentageCommandResponseCallbackFunct = std::function; + CHIP_ERROR GoToLiftPercentage(OnGoToLiftPercentageCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::WindowCovering::GoToLiftPercentageCommandParams::Type & params); + using OnGoToLiftValueCommandResponseCallbackFunct = std::function; + CHIP_ERROR GoToLiftValue(OnGoToLiftValueCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::WindowCovering::GoToLiftValueCommandParams::Type & params); + using OnGoToTiltPercentageCommandResponseCallbackFunct = std::function; + CHIP_ERROR GoToTiltPercentage(OnGoToTiltPercentageCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::WindowCovering::GoToTiltPercentageCommandParams::Type & params); + using OnGoToTiltValueCommandResponseCallbackFunct = std::function; + CHIP_ERROR GoToTiltValue(OnGoToTiltValueCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::WindowCovering::GoToTiltValueCommandParams::Type & params); + using OnStopMotionCommandResponseCallbackFunct = std::function; + CHIP_ERROR StopMotion(OnStopMotionCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::WindowCovering::StopMotionCommandParams::Type & params); + using OnUpOrOpenCommandResponseCallbackFunct = std::function; + CHIP_ERROR UpOrOpen(OnUpOrOpenCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::WindowCovering::UpOrOpenCommandParams::Type & params); + // Cluster Attributes CHIP_ERROR ReadAttributeType(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR ReadAttributeCurrentPositionLift(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); diff --git a/zzz_generated/controller-clusters/zap-generated/cluster_objects_commands.cpp b/zzz_generated/controller-clusters/zap-generated/cluster_objects_commands.cpp new file mode 100644 index 00000000000000..25bc84acc7ec9b --- /dev/null +++ b/zzz_generated/controller-clusters/zap-generated/cluster_objects_commands.cpp @@ -0,0 +1,2658 @@ +/* + * + * 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 "cluster_objects_commands.h" + +#include + +#pragma GCC diagnostic ignored "-Wstack-usage=" + +namespace chip { +namespace app { +namespace clusters { + +namespace AccountLogin { +namespace GetSetupPINCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kTempAccountIdentifierFieldId), tempAccountIdentifier)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace GetSetupPINCommandParams +namespace LoginCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kTempAccountIdentifierFieldId), tempAccountIdentifier)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kSetupPINFieldId), setupPIN)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace LoginCommandParams + +namespace GetSetupPINResponseCommandParams { +CHIP_ERROR Type::Decode(TLV::TLVReader & reader) +{ + return CHIP_ERROR_NOT_IMPLEMENTED; +} +} // namespace GetSetupPINResponseCommandParams + +} // namespace AccountLogin +namespace AdministratorCommissioning { +namespace OpenBasicCommissioningWindowCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kCommissioningTimeoutFieldId), commissioningTimeout)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace OpenBasicCommissioningWindowCommandParams +namespace OpenCommissioningWindowCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kCommissioningTimeoutFieldId), commissioningTimeout)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kPAKEVerifierFieldId), pAKEVerifier)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kDiscriminatorFieldId), discriminator)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kIterationsFieldId), iterations)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kSaltFieldId), salt)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kPasscodeIDFieldId), passcodeID)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace OpenCommissioningWindowCommandParams +namespace RevokeCommissioningCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace RevokeCommissioningCommandParams + +} // namespace AdministratorCommissioning +namespace ApplicationBasic { +namespace ChangeStatusCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kStatusFieldId), status)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace ChangeStatusCommandParams + +} // namespace ApplicationBasic +namespace ApplicationLauncher { +namespace LaunchAppCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kDataFieldId), data)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kCatalogVendorIdFieldId), catalogVendorId)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kApplicationIdFieldId), applicationId)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace LaunchAppCommandParams + +namespace LaunchAppResponseCommandParams { +CHIP_ERROR Type::Decode(TLV::TLVReader & reader) +{ + return CHIP_ERROR_NOT_IMPLEMENTED; +} +} // namespace LaunchAppResponseCommandParams + +} // namespace ApplicationLauncher +namespace AudioOutput { +namespace RenameOutputCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kIndexFieldId), index)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kNameFieldId), name)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace RenameOutputCommandParams +namespace SelectOutputCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kIndexFieldId), index)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace SelectOutputCommandParams + +} // namespace AudioOutput +namespace BarrierControl { +namespace BarrierControlGoToPercentCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kPercentOpenFieldId), percentOpen)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace BarrierControlGoToPercentCommandParams +namespace BarrierControlStopCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace BarrierControlStopCommandParams + +} // namespace BarrierControl +namespace Basic { +namespace MfgSpecificPingCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace MfgSpecificPingCommandParams + +} // namespace Basic +namespace BinaryInputBasic { + +} +namespace Binding { +namespace BindCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kNodeIdFieldId), nodeId)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kGroupIdFieldId), groupId)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kEndpointIdFieldId), endpointId)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kClusterIdFieldId), clusterId)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace BindCommandParams +namespace UnbindCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kNodeIdFieldId), nodeId)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kGroupIdFieldId), groupId)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kEndpointIdFieldId), endpointId)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kClusterIdFieldId), clusterId)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace UnbindCommandParams + +} // namespace Binding +namespace BridgedDeviceBasic { + +} +namespace ColorControl { +namespace ColorLoopSetCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kUpdateFlagsFieldId), updateFlags)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kActionFieldId), action)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kDirectionFieldId), direction)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kTimeFieldId), time)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kStartHueFieldId), startHue)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kOptionsMaskFieldId), optionsMask)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kOptionsOverrideFieldId), optionsOverride)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace ColorLoopSetCommandParams +namespace EnhancedMoveHueCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kMoveModeFieldId), moveMode)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kRateFieldId), rate)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kOptionsMaskFieldId), optionsMask)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kOptionsOverrideFieldId), optionsOverride)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace EnhancedMoveHueCommandParams +namespace EnhancedMoveToHueCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kEnhancedHueFieldId), enhancedHue)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kDirectionFieldId), direction)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kTransitionTimeFieldId), transitionTime)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kOptionsMaskFieldId), optionsMask)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kOptionsOverrideFieldId), optionsOverride)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace EnhancedMoveToHueCommandParams +namespace EnhancedMoveToHueAndSaturationCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kEnhancedHueFieldId), enhancedHue)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kSaturationFieldId), saturation)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kTransitionTimeFieldId), transitionTime)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kOptionsMaskFieldId), optionsMask)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kOptionsOverrideFieldId), optionsOverride)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace EnhancedMoveToHueAndSaturationCommandParams +namespace EnhancedStepHueCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kStepModeFieldId), stepMode)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kStepSizeFieldId), stepSize)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kTransitionTimeFieldId), transitionTime)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kOptionsMaskFieldId), optionsMask)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kOptionsOverrideFieldId), optionsOverride)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace EnhancedStepHueCommandParams +namespace MoveColorCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kRateXFieldId), rateX)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kRateYFieldId), rateY)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kOptionsMaskFieldId), optionsMask)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kOptionsOverrideFieldId), optionsOverride)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace MoveColorCommandParams +namespace MoveColorTemperatureCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kMoveModeFieldId), moveMode)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kRateFieldId), rate)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kColorTemperatureMinimumFieldId), colorTemperatureMinimum)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kColorTemperatureMaximumFieldId), colorTemperatureMaximum)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kOptionsMaskFieldId), optionsMask)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kOptionsOverrideFieldId), optionsOverride)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace MoveColorTemperatureCommandParams +namespace MoveHueCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kMoveModeFieldId), moveMode)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kRateFieldId), rate)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kOptionsMaskFieldId), optionsMask)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kOptionsOverrideFieldId), optionsOverride)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace MoveHueCommandParams +namespace MoveSaturationCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kMoveModeFieldId), moveMode)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kRateFieldId), rate)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kOptionsMaskFieldId), optionsMask)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kOptionsOverrideFieldId), optionsOverride)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace MoveSaturationCommandParams +namespace MoveToColorCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kColorXFieldId), colorX)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kColorYFieldId), colorY)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kTransitionTimeFieldId), transitionTime)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kOptionsMaskFieldId), optionsMask)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kOptionsOverrideFieldId), optionsOverride)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace MoveToColorCommandParams +namespace MoveToColorTemperatureCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kColorTemperatureFieldId), colorTemperature)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kTransitionTimeFieldId), transitionTime)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kOptionsMaskFieldId), optionsMask)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kOptionsOverrideFieldId), optionsOverride)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace MoveToColorTemperatureCommandParams +namespace MoveToHueCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kHueFieldId), hue)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kDirectionFieldId), direction)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kTransitionTimeFieldId), transitionTime)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kOptionsMaskFieldId), optionsMask)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kOptionsOverrideFieldId), optionsOverride)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace MoveToHueCommandParams +namespace MoveToHueAndSaturationCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kHueFieldId), hue)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kSaturationFieldId), saturation)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kTransitionTimeFieldId), transitionTime)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kOptionsMaskFieldId), optionsMask)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kOptionsOverrideFieldId), optionsOverride)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace MoveToHueAndSaturationCommandParams +namespace MoveToSaturationCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kSaturationFieldId), saturation)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kTransitionTimeFieldId), transitionTime)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kOptionsMaskFieldId), optionsMask)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kOptionsOverrideFieldId), optionsOverride)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace MoveToSaturationCommandParams +namespace StepColorCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kStepXFieldId), stepX)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kStepYFieldId), stepY)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kTransitionTimeFieldId), transitionTime)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kOptionsMaskFieldId), optionsMask)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kOptionsOverrideFieldId), optionsOverride)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace StepColorCommandParams +namespace StepColorTemperatureCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kStepModeFieldId), stepMode)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kStepSizeFieldId), stepSize)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kTransitionTimeFieldId), transitionTime)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kColorTemperatureMinimumFieldId), colorTemperatureMinimum)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kColorTemperatureMaximumFieldId), colorTemperatureMaximum)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kOptionsMaskFieldId), optionsMask)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kOptionsOverrideFieldId), optionsOverride)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace StepColorTemperatureCommandParams +namespace StepHueCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kStepModeFieldId), stepMode)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kStepSizeFieldId), stepSize)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kTransitionTimeFieldId), transitionTime)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kOptionsMaskFieldId), optionsMask)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kOptionsOverrideFieldId), optionsOverride)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace StepHueCommandParams +namespace StepSaturationCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kStepModeFieldId), stepMode)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kStepSizeFieldId), stepSize)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kTransitionTimeFieldId), transitionTime)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kOptionsMaskFieldId), optionsMask)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kOptionsOverrideFieldId), optionsOverride)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace StepSaturationCommandParams +namespace StopMoveStepCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kOptionsMaskFieldId), optionsMask)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kOptionsOverrideFieldId), optionsOverride)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace StopMoveStepCommandParams + +} // namespace ColorControl +namespace ContentLauncher { +namespace LaunchContentCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kAutoPlayFieldId), autoPlay)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kDataFieldId), data)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace LaunchContentCommandParams +namespace LaunchURLCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kContentURLFieldId), contentURL)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kDisplayStringFieldId), displayString)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace LaunchURLCommandParams + +namespace LaunchContentResponseCommandParams { +CHIP_ERROR Type::Decode(TLV::TLVReader & reader) +{ + return CHIP_ERROR_NOT_IMPLEMENTED; +} +} // namespace LaunchContentResponseCommandParams +namespace LaunchURLResponseCommandParams { +CHIP_ERROR Type::Decode(TLV::TLVReader & reader) +{ + return CHIP_ERROR_NOT_IMPLEMENTED; +} +} // namespace LaunchURLResponseCommandParams + +} // namespace ContentLauncher +namespace Descriptor { + +} +namespace DiagnosticLogs { +namespace RetrieveLogsRequestCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kIntentFieldId), intent)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kRequestedProtocolFieldId), requestedProtocol)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kTransferFileDesignatorFieldId), transferFileDesignator)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace RetrieveLogsRequestCommandParams + +} // namespace DiagnosticLogs +namespace DoorLock { +namespace ClearAllPinsCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace ClearAllPinsCommandParams +namespace ClearAllRfidsCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace ClearAllRfidsCommandParams +namespace ClearHolidayScheduleCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kScheduleIdFieldId), scheduleId)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace ClearHolidayScheduleCommandParams +namespace ClearPinCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kUserIdFieldId), userId)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace ClearPinCommandParams +namespace ClearRfidCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kUserIdFieldId), userId)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace ClearRfidCommandParams +namespace ClearWeekdayScheduleCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kScheduleIdFieldId), scheduleId)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kUserIdFieldId), userId)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace ClearWeekdayScheduleCommandParams +namespace ClearYeardayScheduleCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kScheduleIdFieldId), scheduleId)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kUserIdFieldId), userId)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace ClearYeardayScheduleCommandParams +namespace GetHolidayScheduleCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kScheduleIdFieldId), scheduleId)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace GetHolidayScheduleCommandParams +namespace GetLogRecordCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kLogIndexFieldId), logIndex)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace GetLogRecordCommandParams +namespace GetPinCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kUserIdFieldId), userId)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace GetPinCommandParams +namespace GetRfidCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kUserIdFieldId), userId)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace GetRfidCommandParams +namespace GetUserTypeCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kUserIdFieldId), userId)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace GetUserTypeCommandParams +namespace GetWeekdayScheduleCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kScheduleIdFieldId), scheduleId)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kUserIdFieldId), userId)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace GetWeekdayScheduleCommandParams +namespace GetYeardayScheduleCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kScheduleIdFieldId), scheduleId)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kUserIdFieldId), userId)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace GetYeardayScheduleCommandParams +namespace LockDoorCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kPinFieldId), pin)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace LockDoorCommandParams +namespace SetHolidayScheduleCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kScheduleIdFieldId), scheduleId)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kLocalStartTimeFieldId), localStartTime)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kLocalEndTimeFieldId), localEndTime)); + ReturnErrorOnFailure( + DataModel::Encode(writer, TLV::ContextTag(kOperatingModeDuringHolidayFieldId), operatingModeDuringHoliday)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace SetHolidayScheduleCommandParams +namespace SetPinCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kUserIdFieldId), userId)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kUserStatusFieldId), userStatus)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kUserTypeFieldId), userType)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kPinFieldId), pin)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace SetPinCommandParams +namespace SetRfidCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kUserIdFieldId), userId)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kUserStatusFieldId), userStatus)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kUserTypeFieldId), userType)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kIdFieldId), id)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace SetRfidCommandParams +namespace SetUserTypeCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kUserIdFieldId), userId)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kUserTypeFieldId), userType)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace SetUserTypeCommandParams +namespace SetWeekdayScheduleCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kScheduleIdFieldId), scheduleId)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kUserIdFieldId), userId)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kDaysMaskFieldId), daysMask)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kStartHourFieldId), startHour)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kStartMinuteFieldId), startMinute)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kEndHourFieldId), endHour)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kEndMinuteFieldId), endMinute)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace SetWeekdayScheduleCommandParams +namespace SetYeardayScheduleCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kScheduleIdFieldId), scheduleId)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kUserIdFieldId), userId)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kLocalStartTimeFieldId), localStartTime)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kLocalEndTimeFieldId), localEndTime)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace SetYeardayScheduleCommandParams +namespace UnlockDoorCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kPinFieldId), pin)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace UnlockDoorCommandParams +namespace UnlockWithTimeoutCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kTimeoutInSecondsFieldId), timeoutInSeconds)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kPinFieldId), pin)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace UnlockWithTimeoutCommandParams + +namespace ClearAllPinsResponseCommandParams { +CHIP_ERROR Type::Decode(TLV::TLVReader & reader) +{ + return CHIP_ERROR_NOT_IMPLEMENTED; +} +} // namespace ClearAllPinsResponseCommandParams +namespace ClearAllRfidsResponseCommandParams { +CHIP_ERROR Type::Decode(TLV::TLVReader & reader) +{ + return CHIP_ERROR_NOT_IMPLEMENTED; +} +} // namespace ClearAllRfidsResponseCommandParams +namespace ClearHolidayScheduleResponseCommandParams { +CHIP_ERROR Type::Decode(TLV::TLVReader & reader) +{ + return CHIP_ERROR_NOT_IMPLEMENTED; +} +} // namespace ClearHolidayScheduleResponseCommandParams +namespace ClearPinResponseCommandParams { +CHIP_ERROR Type::Decode(TLV::TLVReader & reader) +{ + return CHIP_ERROR_NOT_IMPLEMENTED; +} +} // namespace ClearPinResponseCommandParams +namespace ClearRfidResponseCommandParams { +CHIP_ERROR Type::Decode(TLV::TLVReader & reader) +{ + return CHIP_ERROR_NOT_IMPLEMENTED; +} +} // namespace ClearRfidResponseCommandParams +namespace ClearWeekdayScheduleResponseCommandParams { +CHIP_ERROR Type::Decode(TLV::TLVReader & reader) +{ + return CHIP_ERROR_NOT_IMPLEMENTED; +} +} // namespace ClearWeekdayScheduleResponseCommandParams +namespace ClearYeardayScheduleResponseCommandParams { +CHIP_ERROR Type::Decode(TLV::TLVReader & reader) +{ + return CHIP_ERROR_NOT_IMPLEMENTED; +} +} // namespace ClearYeardayScheduleResponseCommandParams +namespace GetHolidayScheduleResponseCommandParams { +CHIP_ERROR Type::Decode(TLV::TLVReader & reader) +{ + return CHIP_ERROR_NOT_IMPLEMENTED; +} +} // namespace GetHolidayScheduleResponseCommandParams +namespace GetLogRecordResponseCommandParams { +CHIP_ERROR Type::Decode(TLV::TLVReader & reader) +{ + return CHIP_ERROR_NOT_IMPLEMENTED; +} +} // namespace GetLogRecordResponseCommandParams +namespace GetPinResponseCommandParams { +CHIP_ERROR Type::Decode(TLV::TLVReader & reader) +{ + return CHIP_ERROR_NOT_IMPLEMENTED; +} +} // namespace GetPinResponseCommandParams +namespace GetRfidResponseCommandParams { +CHIP_ERROR Type::Decode(TLV::TLVReader & reader) +{ + return CHIP_ERROR_NOT_IMPLEMENTED; +} +} // namespace GetRfidResponseCommandParams +namespace GetUserTypeResponseCommandParams { +CHIP_ERROR Type::Decode(TLV::TLVReader & reader) +{ + return CHIP_ERROR_NOT_IMPLEMENTED; +} +} // namespace GetUserTypeResponseCommandParams +namespace GetWeekdayScheduleResponseCommandParams { +CHIP_ERROR Type::Decode(TLV::TLVReader & reader) +{ + return CHIP_ERROR_NOT_IMPLEMENTED; +} +} // namespace GetWeekdayScheduleResponseCommandParams +namespace GetYeardayScheduleResponseCommandParams { +CHIP_ERROR Type::Decode(TLV::TLVReader & reader) +{ + return CHIP_ERROR_NOT_IMPLEMENTED; +} +} // namespace GetYeardayScheduleResponseCommandParams +namespace LockDoorResponseCommandParams { +CHIP_ERROR Type::Decode(TLV::TLVReader & reader) +{ + return CHIP_ERROR_NOT_IMPLEMENTED; +} +} // namespace LockDoorResponseCommandParams +namespace SetHolidayScheduleResponseCommandParams { +CHIP_ERROR Type::Decode(TLV::TLVReader & reader) +{ + return CHIP_ERROR_NOT_IMPLEMENTED; +} +} // namespace SetHolidayScheduleResponseCommandParams +namespace SetPinResponseCommandParams { +CHIP_ERROR Type::Decode(TLV::TLVReader & reader) +{ + return CHIP_ERROR_NOT_IMPLEMENTED; +} +} // namespace SetPinResponseCommandParams +namespace SetRfidResponseCommandParams { +CHIP_ERROR Type::Decode(TLV::TLVReader & reader) +{ + return CHIP_ERROR_NOT_IMPLEMENTED; +} +} // namespace SetRfidResponseCommandParams +namespace SetUserTypeResponseCommandParams { +CHIP_ERROR Type::Decode(TLV::TLVReader & reader) +{ + return CHIP_ERROR_NOT_IMPLEMENTED; +} +} // namespace SetUserTypeResponseCommandParams +namespace SetWeekdayScheduleResponseCommandParams { +CHIP_ERROR Type::Decode(TLV::TLVReader & reader) +{ + return CHIP_ERROR_NOT_IMPLEMENTED; +} +} // namespace SetWeekdayScheduleResponseCommandParams +namespace SetYeardayScheduleResponseCommandParams { +CHIP_ERROR Type::Decode(TLV::TLVReader & reader) +{ + return CHIP_ERROR_NOT_IMPLEMENTED; +} +} // namespace SetYeardayScheduleResponseCommandParams +namespace UnlockDoorResponseCommandParams { +CHIP_ERROR Type::Decode(TLV::TLVReader & reader) +{ + return CHIP_ERROR_NOT_IMPLEMENTED; +} +} // namespace UnlockDoorResponseCommandParams +namespace UnlockWithTimeoutResponseCommandParams { +CHIP_ERROR Type::Decode(TLV::TLVReader & reader) +{ + return CHIP_ERROR_NOT_IMPLEMENTED; +} +} // namespace UnlockWithTimeoutResponseCommandParams + +} // namespace DoorLock +namespace ElectricalMeasurement { + +} +namespace EthernetNetworkDiagnostics { +namespace ResetCountsCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace ResetCountsCommandParams + +} // namespace EthernetNetworkDiagnostics +namespace FixedLabel { + +} +namespace FlowMeasurement { + +} +namespace GeneralCommissioning { +namespace ArmFailSafeCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kExpiryLengthSecondsFieldId), expiryLengthSeconds)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kBreadcrumbFieldId), breadcrumb)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kTimeoutMsFieldId), timeoutMs)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace ArmFailSafeCommandParams +namespace CommissioningCompleteCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace CommissioningCompleteCommandParams +namespace SetRegulatoryConfigCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kLocationFieldId), location)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kCountryCodeFieldId), countryCode)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kBreadcrumbFieldId), breadcrumb)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kTimeoutMsFieldId), timeoutMs)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace SetRegulatoryConfigCommandParams + +namespace ArmFailSafeResponseCommandParams { +CHIP_ERROR Type::Decode(TLV::TLVReader & reader) +{ + return CHIP_ERROR_NOT_IMPLEMENTED; +} +} // namespace ArmFailSafeResponseCommandParams +namespace CommissioningCompleteResponseCommandParams { +CHIP_ERROR Type::Decode(TLV::TLVReader & reader) +{ + return CHIP_ERROR_NOT_IMPLEMENTED; +} +} // namespace CommissioningCompleteResponseCommandParams +namespace SetRegulatoryConfigResponseCommandParams { +CHIP_ERROR Type::Decode(TLV::TLVReader & reader) +{ + return CHIP_ERROR_NOT_IMPLEMENTED; +} +} // namespace SetRegulatoryConfigResponseCommandParams + +} // namespace GeneralCommissioning +namespace GeneralDiagnostics { + +} +namespace GroupKeyManagement { + +} +namespace Groups { +namespace AddGroupCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kGroupIdFieldId), groupId)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kGroupNameFieldId), groupName)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace AddGroupCommandParams +namespace AddGroupIfIdentifyingCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kGroupIdFieldId), groupId)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kGroupNameFieldId), groupName)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace AddGroupIfIdentifyingCommandParams +namespace GetGroupMembershipCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kGroupCountFieldId), groupCount)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kGroupListFieldId), groupList)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace GetGroupMembershipCommandParams +namespace RemoveAllGroupsCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace RemoveAllGroupsCommandParams +namespace RemoveGroupCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kGroupIdFieldId), groupId)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace RemoveGroupCommandParams +namespace ViewGroupCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kGroupIdFieldId), groupId)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace ViewGroupCommandParams + +namespace AddGroupResponseCommandParams { +CHIP_ERROR Type::Decode(TLV::TLVReader & reader) +{ + return CHIP_ERROR_NOT_IMPLEMENTED; +} +} // namespace AddGroupResponseCommandParams +namespace GetGroupMembershipResponseCommandParams { +CHIP_ERROR Type::Decode(TLV::TLVReader & reader) +{ + return CHIP_ERROR_NOT_IMPLEMENTED; +} +} // namespace GetGroupMembershipResponseCommandParams +namespace RemoveGroupResponseCommandParams { +CHIP_ERROR Type::Decode(TLV::TLVReader & reader) +{ + return CHIP_ERROR_NOT_IMPLEMENTED; +} +} // namespace RemoveGroupResponseCommandParams +namespace ViewGroupResponseCommandParams { +CHIP_ERROR Type::Decode(TLV::TLVReader & reader) +{ + return CHIP_ERROR_NOT_IMPLEMENTED; +} +} // namespace ViewGroupResponseCommandParams + +} // namespace Groups +namespace Identify { +namespace IdentifyCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kIdentifyTimeFieldId), identifyTime)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace IdentifyCommandParams +namespace IdentifyQueryCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace IdentifyQueryCommandParams + +namespace IdentifyQueryResponseCommandParams { +CHIP_ERROR Type::Decode(TLV::TLVReader & reader) +{ + return CHIP_ERROR_NOT_IMPLEMENTED; +} +} // namespace IdentifyQueryResponseCommandParams + +} // namespace Identify +namespace KeypadInput { +namespace SendKeyCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kKeyCodeFieldId), keyCode)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace SendKeyCommandParams + +namespace SendKeyResponseCommandParams { +CHIP_ERROR Type::Decode(TLV::TLVReader & reader) +{ + return CHIP_ERROR_NOT_IMPLEMENTED; +} +} // namespace SendKeyResponseCommandParams + +} // namespace KeypadInput +namespace LevelControl { +namespace MoveCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kMoveModeFieldId), moveMode)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kRateFieldId), rate)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kOptionMaskFieldId), optionMask)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kOptionOverrideFieldId), optionOverride)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace MoveCommandParams +namespace MoveToLevelCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kLevelFieldId), level)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kTransitionTimeFieldId), transitionTime)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kOptionMaskFieldId), optionMask)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kOptionOverrideFieldId), optionOverride)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace MoveToLevelCommandParams +namespace MoveToLevelWithOnOffCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kLevelFieldId), level)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kTransitionTimeFieldId), transitionTime)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace MoveToLevelWithOnOffCommandParams +namespace MoveWithOnOffCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kMoveModeFieldId), moveMode)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kRateFieldId), rate)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace MoveWithOnOffCommandParams +namespace StepCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kStepModeFieldId), stepMode)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kStepSizeFieldId), stepSize)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kTransitionTimeFieldId), transitionTime)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kOptionMaskFieldId), optionMask)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kOptionOverrideFieldId), optionOverride)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace StepCommandParams +namespace StepWithOnOffCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kStepModeFieldId), stepMode)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kStepSizeFieldId), stepSize)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kTransitionTimeFieldId), transitionTime)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace StepWithOnOffCommandParams +namespace StopCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kOptionMaskFieldId), optionMask)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kOptionOverrideFieldId), optionOverride)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace StopCommandParams +namespace StopWithOnOffCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace StopWithOnOffCommandParams + +} // namespace LevelControl +namespace LowPower { +namespace SleepCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace SleepCommandParams + +} // namespace LowPower +namespace MediaInput { +namespace HideInputStatusCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace HideInputStatusCommandParams +namespace RenameInputCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kIndexFieldId), index)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kNameFieldId), name)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace RenameInputCommandParams +namespace SelectInputCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kIndexFieldId), index)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace SelectInputCommandParams +namespace ShowInputStatusCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace ShowInputStatusCommandParams + +} // namespace MediaInput +namespace MediaPlayback { +namespace MediaFastForwardCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace MediaFastForwardCommandParams +namespace MediaNextCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace MediaNextCommandParams +namespace MediaPauseCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace MediaPauseCommandParams +namespace MediaPlayCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace MediaPlayCommandParams +namespace MediaPreviousCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace MediaPreviousCommandParams +namespace MediaRewindCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace MediaRewindCommandParams +namespace MediaSeekCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kPositionFieldId), position)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace MediaSeekCommandParams +namespace MediaSkipBackwardCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kDeltaPositionMillisecondsFieldId), deltaPositionMilliseconds)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace MediaSkipBackwardCommandParams +namespace MediaSkipForwardCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kDeltaPositionMillisecondsFieldId), deltaPositionMilliseconds)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace MediaSkipForwardCommandParams +namespace MediaStartOverCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace MediaStartOverCommandParams +namespace MediaStopCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace MediaStopCommandParams + +namespace MediaFastForwardResponseCommandParams { +CHIP_ERROR Type::Decode(TLV::TLVReader & reader) +{ + return CHIP_ERROR_NOT_IMPLEMENTED; +} +} // namespace MediaFastForwardResponseCommandParams +namespace MediaNextResponseCommandParams { +CHIP_ERROR Type::Decode(TLV::TLVReader & reader) +{ + return CHIP_ERROR_NOT_IMPLEMENTED; +} +} // namespace MediaNextResponseCommandParams +namespace MediaPauseResponseCommandParams { +CHIP_ERROR Type::Decode(TLV::TLVReader & reader) +{ + return CHIP_ERROR_NOT_IMPLEMENTED; +} +} // namespace MediaPauseResponseCommandParams +namespace MediaPlayResponseCommandParams { +CHIP_ERROR Type::Decode(TLV::TLVReader & reader) +{ + return CHIP_ERROR_NOT_IMPLEMENTED; +} +} // namespace MediaPlayResponseCommandParams +namespace MediaPreviousResponseCommandParams { +CHIP_ERROR Type::Decode(TLV::TLVReader & reader) +{ + return CHIP_ERROR_NOT_IMPLEMENTED; +} +} // namespace MediaPreviousResponseCommandParams +namespace MediaRewindResponseCommandParams { +CHIP_ERROR Type::Decode(TLV::TLVReader & reader) +{ + return CHIP_ERROR_NOT_IMPLEMENTED; +} +} // namespace MediaRewindResponseCommandParams +namespace MediaSeekResponseCommandParams { +CHIP_ERROR Type::Decode(TLV::TLVReader & reader) +{ + return CHIP_ERROR_NOT_IMPLEMENTED; +} +} // namespace MediaSeekResponseCommandParams +namespace MediaSkipBackwardResponseCommandParams { +CHIP_ERROR Type::Decode(TLV::TLVReader & reader) +{ + return CHIP_ERROR_NOT_IMPLEMENTED; +} +} // namespace MediaSkipBackwardResponseCommandParams +namespace MediaSkipForwardResponseCommandParams { +CHIP_ERROR Type::Decode(TLV::TLVReader & reader) +{ + return CHIP_ERROR_NOT_IMPLEMENTED; +} +} // namespace MediaSkipForwardResponseCommandParams +namespace MediaStartOverResponseCommandParams { +CHIP_ERROR Type::Decode(TLV::TLVReader & reader) +{ + return CHIP_ERROR_NOT_IMPLEMENTED; +} +} // namespace MediaStartOverResponseCommandParams +namespace MediaStopResponseCommandParams { +CHIP_ERROR Type::Decode(TLV::TLVReader & reader) +{ + return CHIP_ERROR_NOT_IMPLEMENTED; +} +} // namespace MediaStopResponseCommandParams + +} // namespace MediaPlayback +namespace NetworkCommissioning { +namespace AddThreadNetworkCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kOperationalDatasetFieldId), operationalDataset)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kBreadcrumbFieldId), breadcrumb)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kTimeoutMsFieldId), timeoutMs)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace AddThreadNetworkCommandParams +namespace AddWiFiNetworkCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kSsidFieldId), ssid)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kCredentialsFieldId), credentials)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kBreadcrumbFieldId), breadcrumb)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kTimeoutMsFieldId), timeoutMs)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace AddWiFiNetworkCommandParams +namespace DisableNetworkCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kNetworkIDFieldId), networkID)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kBreadcrumbFieldId), breadcrumb)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kTimeoutMsFieldId), timeoutMs)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace DisableNetworkCommandParams +namespace EnableNetworkCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kNetworkIDFieldId), networkID)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kBreadcrumbFieldId), breadcrumb)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kTimeoutMsFieldId), timeoutMs)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace EnableNetworkCommandParams +namespace GetLastNetworkCommissioningResultCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kTimeoutMsFieldId), timeoutMs)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace GetLastNetworkCommissioningResultCommandParams +namespace RemoveNetworkCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kNetworkIDFieldId), networkID)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kBreadcrumbFieldId), breadcrumb)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kTimeoutMsFieldId), timeoutMs)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace RemoveNetworkCommandParams +namespace ScanNetworksCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kSsidFieldId), ssid)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kBreadcrumbFieldId), breadcrumb)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kTimeoutMsFieldId), timeoutMs)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace ScanNetworksCommandParams +namespace UpdateThreadNetworkCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kOperationalDatasetFieldId), operationalDataset)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kBreadcrumbFieldId), breadcrumb)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kTimeoutMsFieldId), timeoutMs)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace UpdateThreadNetworkCommandParams +namespace UpdateWiFiNetworkCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kSsidFieldId), ssid)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kCredentialsFieldId), credentials)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kBreadcrumbFieldId), breadcrumb)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kTimeoutMsFieldId), timeoutMs)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace UpdateWiFiNetworkCommandParams + +namespace AddThreadNetworkResponseCommandParams { +CHIP_ERROR Type::Decode(TLV::TLVReader & reader) +{ + return CHIP_ERROR_NOT_IMPLEMENTED; +} +} // namespace AddThreadNetworkResponseCommandParams +namespace AddWiFiNetworkResponseCommandParams { +CHIP_ERROR Type::Decode(TLV::TLVReader & reader) +{ + return CHIP_ERROR_NOT_IMPLEMENTED; +} +} // namespace AddWiFiNetworkResponseCommandParams +namespace DisableNetworkResponseCommandParams { +CHIP_ERROR Type::Decode(TLV::TLVReader & reader) +{ + return CHIP_ERROR_NOT_IMPLEMENTED; +} +} // namespace DisableNetworkResponseCommandParams +namespace EnableNetworkResponseCommandParams { +CHIP_ERROR Type::Decode(TLV::TLVReader & reader) +{ + return CHIP_ERROR_NOT_IMPLEMENTED; +} +} // namespace EnableNetworkResponseCommandParams +namespace RemoveNetworkResponseCommandParams { +CHIP_ERROR Type::Decode(TLV::TLVReader & reader) +{ + return CHIP_ERROR_NOT_IMPLEMENTED; +} +} // namespace RemoveNetworkResponseCommandParams +namespace ScanNetworksResponseCommandParams { +CHIP_ERROR Type::Decode(TLV::TLVReader & reader) +{ + return CHIP_ERROR_NOT_IMPLEMENTED; +} +} // namespace ScanNetworksResponseCommandParams +namespace UpdateThreadNetworkResponseCommandParams { +CHIP_ERROR Type::Decode(TLV::TLVReader & reader) +{ + return CHIP_ERROR_NOT_IMPLEMENTED; +} +} // namespace UpdateThreadNetworkResponseCommandParams +namespace UpdateWiFiNetworkResponseCommandParams { +CHIP_ERROR Type::Decode(TLV::TLVReader & reader) +{ + return CHIP_ERROR_NOT_IMPLEMENTED; +} +} // namespace UpdateWiFiNetworkResponseCommandParams + +} // namespace NetworkCommissioning +namespace OtaSoftwareUpdateProvider { +namespace ApplyUpdateRequestCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kUpdateTokenFieldId), updateToken)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kNewVersionFieldId), newVersion)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace ApplyUpdateRequestCommandParams +namespace NotifyUpdateAppliedCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kUpdateTokenFieldId), updateToken)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kCurrentVersionFieldId), currentVersion)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace NotifyUpdateAppliedCommandParams +namespace QueryImageCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kVendorIdFieldId), vendorId)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kProductIdFieldId), productId)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kImageTypeFieldId), imageType)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kHardwareVersionFieldId), hardwareVersion)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kCurrentVersionFieldId), currentVersion)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kProtocolsSupportedFieldId), protocolsSupported)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kLocationFieldId), location)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kRequestorCanConsentFieldId), requestorCanConsent)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kMetadataForProviderFieldId), metadataForProvider)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace QueryImageCommandParams + +namespace ApplyUpdateRequestResponseCommandParams { +CHIP_ERROR Type::Decode(TLV::TLVReader & reader) +{ + return CHIP_ERROR_NOT_IMPLEMENTED; +} +} // namespace ApplyUpdateRequestResponseCommandParams +namespace QueryImageResponseCommandParams { +CHIP_ERROR Type::Decode(TLV::TLVReader & reader) +{ + return CHIP_ERROR_NOT_IMPLEMENTED; +} +} // namespace QueryImageResponseCommandParams + +} // namespace OtaSoftwareUpdateProvider +namespace OtaSoftwareUpdateRequestor { +namespace AnnounceOtaProviderCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kServerLocationFieldId), serverLocation)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kVendorIdFieldId), vendorId)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kAnnouncementReasonFieldId), announcementReason)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kMetadataForNodeFieldId), metadataForNode)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace AnnounceOtaProviderCommandParams + +} // namespace OtaSoftwareUpdateRequestor +namespace OccupancySensing { + +} +namespace OnOff { +namespace OffCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace OffCommandParams +namespace OffWithEffectCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kEffectIdFieldId), effectId)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kEffectVariantFieldId), effectVariant)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace OffWithEffectCommandParams +namespace OnCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace OnCommandParams +namespace OnWithRecallGlobalSceneCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace OnWithRecallGlobalSceneCommandParams +namespace OnWithTimedOffCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kOnOffControlFieldId), onOffControl)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kOnTimeFieldId), onTime)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kOffWaitTimeFieldId), offWaitTime)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace OnWithTimedOffCommandParams +namespace ToggleCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace ToggleCommandParams + +} // namespace OnOff +namespace OnOffSwitchConfiguration { + +} +namespace OperationalCredentials { +namespace AddNOCCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kNOCValueFieldId), nOCValue)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kICACValueFieldId), iCACValue)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kIPKValueFieldId), iPKValue)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kCaseAdminNodeFieldId), caseAdminNode)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kAdminVendorIdFieldId), adminVendorId)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace AddNOCCommandParams +namespace AddTrustedRootCertificateCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kRootCertificateFieldId), rootCertificate)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace AddTrustedRootCertificateCommandParams +namespace AttestationRequestCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kAttestationNonceFieldId), attestationNonce)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace AttestationRequestCommandParams +namespace CertificateChainRequestCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kCertificateTypeFieldId), certificateType)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace CertificateChainRequestCommandParams +namespace OpCSRRequestCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kCSRNonceFieldId), cSRNonce)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace OpCSRRequestCommandParams +namespace RemoveFabricCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kFabricIndexFieldId), fabricIndex)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace RemoveFabricCommandParams +namespace RemoveTrustedRootCertificateCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kTrustedRootIdentifierFieldId), trustedRootIdentifier)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace RemoveTrustedRootCertificateCommandParams +namespace UpdateFabricLabelCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kLabelFieldId), label)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace UpdateFabricLabelCommandParams +namespace UpdateNOCCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kNOCValueFieldId), nOCValue)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kICACValueFieldId), iCACValue)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace UpdateNOCCommandParams + +namespace AttestationResponseCommandParams { +CHIP_ERROR Type::Decode(TLV::TLVReader & reader) +{ + return CHIP_ERROR_NOT_IMPLEMENTED; +} +} // namespace AttestationResponseCommandParams +namespace CertificateChainResponseCommandParams { +CHIP_ERROR Type::Decode(TLV::TLVReader & reader) +{ + return CHIP_ERROR_NOT_IMPLEMENTED; +} +} // namespace CertificateChainResponseCommandParams +namespace NOCResponseCommandParams { +CHIP_ERROR Type::Decode(TLV::TLVReader & reader) +{ + return CHIP_ERROR_NOT_IMPLEMENTED; +} +} // namespace NOCResponseCommandParams +namespace OpCSRResponseCommandParams { +CHIP_ERROR Type::Decode(TLV::TLVReader & reader) +{ + return CHIP_ERROR_NOT_IMPLEMENTED; +} +} // namespace OpCSRResponseCommandParams + +} // namespace OperationalCredentials +namespace PowerSource { + +} +namespace PressureMeasurement { + +} +namespace PumpConfigurationAndControl { + +} +namespace RelativeHumidityMeasurement { + +} +namespace Scenes { +namespace AddSceneCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kGroupIdFieldId), groupId)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kSceneIdFieldId), sceneId)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kTransitionTimeFieldId), transitionTime)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kSceneNameFieldId), sceneName)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kClusterIdFieldId), clusterId)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kLengthFieldId), length)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kValueFieldId), value)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace AddSceneCommandParams +namespace GetSceneMembershipCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kGroupIdFieldId), groupId)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace GetSceneMembershipCommandParams +namespace RecallSceneCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kGroupIdFieldId), groupId)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kSceneIdFieldId), sceneId)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kTransitionTimeFieldId), transitionTime)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace RecallSceneCommandParams +namespace RemoveAllScenesCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kGroupIdFieldId), groupId)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace RemoveAllScenesCommandParams +namespace RemoveSceneCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kGroupIdFieldId), groupId)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kSceneIdFieldId), sceneId)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace RemoveSceneCommandParams +namespace StoreSceneCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kGroupIdFieldId), groupId)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kSceneIdFieldId), sceneId)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace StoreSceneCommandParams +namespace ViewSceneCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kGroupIdFieldId), groupId)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kSceneIdFieldId), sceneId)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace ViewSceneCommandParams + +namespace AddSceneResponseCommandParams { +CHIP_ERROR Type::Decode(TLV::TLVReader & reader) +{ + return CHIP_ERROR_NOT_IMPLEMENTED; +} +} // namespace AddSceneResponseCommandParams +namespace GetSceneMembershipResponseCommandParams { +CHIP_ERROR Type::Decode(TLV::TLVReader & reader) +{ + return CHIP_ERROR_NOT_IMPLEMENTED; +} +} // namespace GetSceneMembershipResponseCommandParams +namespace RemoveAllScenesResponseCommandParams { +CHIP_ERROR Type::Decode(TLV::TLVReader & reader) +{ + return CHIP_ERROR_NOT_IMPLEMENTED; +} +} // namespace RemoveAllScenesResponseCommandParams +namespace RemoveSceneResponseCommandParams { +CHIP_ERROR Type::Decode(TLV::TLVReader & reader) +{ + return CHIP_ERROR_NOT_IMPLEMENTED; +} +} // namespace RemoveSceneResponseCommandParams +namespace StoreSceneResponseCommandParams { +CHIP_ERROR Type::Decode(TLV::TLVReader & reader) +{ + return CHIP_ERROR_NOT_IMPLEMENTED; +} +} // namespace StoreSceneResponseCommandParams +namespace ViewSceneResponseCommandParams { +CHIP_ERROR Type::Decode(TLV::TLVReader & reader) +{ + return CHIP_ERROR_NOT_IMPLEMENTED; +} +} // namespace ViewSceneResponseCommandParams + +} // namespace Scenes +namespace SoftwareDiagnostics { +namespace ResetWatermarksCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace ResetWatermarksCommandParams + +} // namespace SoftwareDiagnostics +namespace Switch { + +} +namespace TvChannel { +namespace ChangeChannelCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kMatchFieldId), match)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace ChangeChannelCommandParams +namespace ChangeChannelByNumberCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kMajorNumberFieldId), majorNumber)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kMinorNumberFieldId), minorNumber)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace ChangeChannelByNumberCommandParams +namespace SkipChannelCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kCountFieldId), count)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace SkipChannelCommandParams + +namespace ChangeChannelResponseCommandParams { +CHIP_ERROR Type::Decode(TLV::TLVReader & reader) +{ + return CHIP_ERROR_NOT_IMPLEMENTED; +} +} // namespace ChangeChannelResponseCommandParams + +} // namespace TvChannel +namespace TargetNavigator { +namespace NavigateTargetCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kTargetFieldId), target)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kDataFieldId), data)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace NavigateTargetCommandParams + +namespace NavigateTargetResponseCommandParams { +CHIP_ERROR Type::Decode(TLV::TLVReader & reader) +{ + return CHIP_ERROR_NOT_IMPLEMENTED; +} +} // namespace NavigateTargetResponseCommandParams + +} // namespace TargetNavigator +namespace TemperatureMeasurement { + +} +namespace TestCluster { +namespace TestCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace TestCommandParams +namespace TestAddArgumentsCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kArg1FieldId), arg1)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kArg2FieldId), arg2)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace TestAddArgumentsCommandParams +namespace TestNotHandledCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace TestNotHandledCommandParams +namespace TestSpecificCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace TestSpecificCommandParams +namespace TestUnknownCommandCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace TestUnknownCommandCommandParams + +namespace TestAddArgumentsResponseCommandParams { +CHIP_ERROR Type::Decode(TLV::TLVReader & reader) +{ + return CHIP_ERROR_NOT_IMPLEMENTED; +} +} // namespace TestAddArgumentsResponseCommandParams +namespace TestSpecificResponseCommandParams { +CHIP_ERROR Type::Decode(TLV::TLVReader & reader) +{ + return CHIP_ERROR_NOT_IMPLEMENTED; +} +} // namespace TestSpecificResponseCommandParams + +} // namespace TestCluster +namespace Thermostat { +namespace ClearWeeklyScheduleCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace ClearWeeklyScheduleCommandParams +namespace GetRelayStatusLogCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace GetRelayStatusLogCommandParams +namespace GetWeeklyScheduleCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kDaysToReturnFieldId), daysToReturn)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kModeToReturnFieldId), modeToReturn)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace GetWeeklyScheduleCommandParams +namespace SetWeeklyScheduleCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure( + DataModel::Encode(writer, TLV::ContextTag(kNumberOfTransitionsForSequenceFieldId), numberOfTransitionsForSequence)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kDayOfWeekForSequenceFieldId), dayOfWeekForSequence)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kModeForSequenceFieldId), modeForSequence)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kPayloadFieldId), payload)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace SetWeeklyScheduleCommandParams +namespace SetpointRaiseLowerCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kModeFieldId), mode)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kAmountFieldId), amount)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace SetpointRaiseLowerCommandParams + +} // namespace Thermostat +namespace ThermostatUserInterfaceConfiguration { + +} +namespace ThreadNetworkDiagnostics { +namespace ResetCountsCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace ResetCountsCommandParams + +} // namespace ThreadNetworkDiagnostics +namespace WakeOnLan { + +} +namespace WiFiNetworkDiagnostics { +namespace ResetCountsCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace ResetCountsCommandParams + +} // namespace WiFiNetworkDiagnostics +namespace WindowCovering { +namespace DownOrCloseCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace DownOrCloseCommandParams +namespace GoToLiftPercentageCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kLiftPercentageValueFieldId), liftPercentageValue)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kLiftPercent100thsValueFieldId), liftPercent100thsValue)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace GoToLiftPercentageCommandParams +namespace GoToLiftValueCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kLiftValueFieldId), liftValue)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace GoToLiftValueCommandParams +namespace GoToTiltPercentageCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kTiltPercentageValueFieldId), tiltPercentageValue)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kTiltPercent100thsValueFieldId), tiltPercent100thsValue)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace GoToTiltPercentageCommandParams +namespace GoToTiltValueCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kTiltValueFieldId), tiltValue)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace GoToTiltValueCommandParams +namespace StopMotionCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace StopMotionCommandParams +namespace UpOrOpenCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace UpOrOpenCommandParams + +} // namespace WindowCovering + +} // namespace clusters +} // namespace app +} // namespace chip diff --git a/zzz_generated/controller-clusters/zap-generated/cluster_objects_commands.h b/zzz_generated/controller-clusters/zap-generated/cluster_objects_commands.h new file mode 100644 index 00000000000000..e48b204191786d --- /dev/null +++ b/zzz_generated/controller-clusters/zap-generated/cluster_objects_commands.h @@ -0,0 +1,3881 @@ +/* + * + * 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 + +#pragma once + +#include +#include +#include +#include +#include +#include + +namespace chip { +namespace app { +namespace clusters { + +// AccountLogin Cluster Commands +namespace AccountLogin { + +namespace GetSetupPINCommandParams { +enum FieldId +{ + kTempAccountIdentifierFieldId = 0, +}; + +struct Type +{ +public: + Span tempAccountIdentifier; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace GetSetupPINCommandParams +namespace LoginCommandParams { +enum FieldId +{ + kTempAccountIdentifierFieldId = 0, + kSetupPINFieldId = 1, +}; + +struct Type +{ +public: + Span tempAccountIdentifier; + Span setupPIN; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace LoginCommandParams + +namespace GetSetupPINResponseCommandParams { +enum FieldId +{ + kSetupPINFieldId = 0, +}; + +struct Type +{ +public: + // TODO + + CHIP_ERROR Decode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace GetSetupPINResponseCommandParams + +} // namespace AccountLogin + +// AdministratorCommissioning Cluster Commands +namespace AdministratorCommissioning { + +namespace OpenBasicCommissioningWindowCommandParams { +enum FieldId +{ + kCommissioningTimeoutFieldId = 0, +}; + +struct Type +{ +public: + uint16_t commissioningTimeout; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace OpenBasicCommissioningWindowCommandParams +namespace OpenCommissioningWindowCommandParams { +enum FieldId +{ + kCommissioningTimeoutFieldId = 0, + kPAKEVerifierFieldId = 1, + kDiscriminatorFieldId = 2, + kIterationsFieldId = 3, + kSaltFieldId = 4, + kPasscodeIDFieldId = 5, +}; + +struct Type +{ +public: + uint16_t commissioningTimeout; + chip::ByteSpan pAKEVerifier; + uint16_t discriminator; + uint32_t iterations; + chip::ByteSpan salt; + uint16_t passcodeID; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace OpenCommissioningWindowCommandParams +namespace RevokeCommissioningCommandParams { +enum FieldId +{ +}; + +struct Type +{ +public: + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace RevokeCommissioningCommandParams + +} // namespace AdministratorCommissioning + +// ApplicationBasic Cluster Commands +namespace ApplicationBasic { + +namespace ChangeStatusCommandParams { +enum FieldId +{ + kStatusFieldId = 0, +}; + +struct Type +{ +public: + ApplicationBasicStatus status; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace ChangeStatusCommandParams + +} // namespace ApplicationBasic + +// ApplicationLauncher Cluster Commands +namespace ApplicationLauncher { + +namespace LaunchAppCommandParams { +enum FieldId +{ + kDataFieldId = 0, + kCatalogVendorIdFieldId = 1, + kApplicationIdFieldId = 2, +}; + +struct Type +{ +public: + Span data; + uint16_t catalogVendorId; + Span applicationId; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace LaunchAppCommandParams + +namespace LaunchAppResponseCommandParams { +enum FieldId +{ + kStatusFieldId = 0, + kDataFieldId = 1, +}; + +struct Type +{ +public: + // TODO + + CHIP_ERROR Decode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace LaunchAppResponseCommandParams + +} // namespace ApplicationLauncher + +// AudioOutput Cluster Commands +namespace AudioOutput { + +namespace RenameOutputCommandParams { +enum FieldId +{ + kIndexFieldId = 0, + kNameFieldId = 1, +}; + +struct Type +{ +public: + uint8_t index; + Span name; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace RenameOutputCommandParams +namespace SelectOutputCommandParams { +enum FieldId +{ + kIndexFieldId = 0, +}; + +struct Type +{ +public: + uint8_t index; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace SelectOutputCommandParams + +} // namespace AudioOutput + +// BarrierControl Cluster Commands +namespace BarrierControl { + +namespace BarrierControlGoToPercentCommandParams { +enum FieldId +{ + kPercentOpenFieldId = 0, +}; + +struct Type +{ +public: + uint8_t percentOpen; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace BarrierControlGoToPercentCommandParams +namespace BarrierControlStopCommandParams { +enum FieldId +{ +}; + +struct Type +{ +public: + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace BarrierControlStopCommandParams + +} // namespace BarrierControl + +// Basic Cluster Commands +namespace Basic { + +namespace MfgSpecificPingCommandParams { +enum FieldId +{ +}; + +struct Type +{ +public: + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace MfgSpecificPingCommandParams + +} // namespace Basic + +// BinaryInputBasic Cluster Commands +namespace BinaryInputBasic { + +} // namespace BinaryInputBasic + +// Binding Cluster Commands +namespace Binding { + +namespace BindCommandParams { +enum FieldId +{ + kNodeIdFieldId = 0, + kGroupIdFieldId = 1, + kEndpointIdFieldId = 2, + kClusterIdFieldId = 3, +}; + +struct Type +{ +public: + uint64_t nodeId; + uint16_t groupId; + uint16_t endpointId; + uint32_t clusterId; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace BindCommandParams +namespace UnbindCommandParams { +enum FieldId +{ + kNodeIdFieldId = 0, + kGroupIdFieldId = 1, + kEndpointIdFieldId = 2, + kClusterIdFieldId = 3, +}; + +struct Type +{ +public: + uint64_t nodeId; + uint16_t groupId; + uint16_t endpointId; + uint32_t clusterId; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace UnbindCommandParams + +} // namespace Binding + +// BridgedDeviceBasic Cluster Commands +namespace BridgedDeviceBasic { + +} // namespace BridgedDeviceBasic + +// ColorControl Cluster Commands +namespace ColorControl { + +namespace ColorLoopSetCommandParams { +enum FieldId +{ + kUpdateFlagsFieldId = 0, + kActionFieldId = 1, + kDirectionFieldId = 2, + kTimeFieldId = 3, + kStartHueFieldId = 4, + kOptionsMaskFieldId = 5, + kOptionsOverrideFieldId = 6, +}; + +struct Type +{ +public: + uint8_t updateFlags; + ColorLoopAction action; + ColorLoopDirection direction; + uint16_t time; + uint16_t startHue; + uint8_t optionsMask; + uint8_t optionsOverride; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace ColorLoopSetCommandParams +namespace EnhancedMoveHueCommandParams { +enum FieldId +{ + kMoveModeFieldId = 0, + kRateFieldId = 1, + kOptionsMaskFieldId = 2, + kOptionsOverrideFieldId = 3, +}; + +struct Type +{ +public: + HueMoveMode moveMode; + uint16_t rate; + uint8_t optionsMask; + uint8_t optionsOverride; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace EnhancedMoveHueCommandParams +namespace EnhancedMoveToHueCommandParams { +enum FieldId +{ + kEnhancedHueFieldId = 0, + kDirectionFieldId = 1, + kTransitionTimeFieldId = 2, + kOptionsMaskFieldId = 3, + kOptionsOverrideFieldId = 4, +}; + +struct Type +{ +public: + uint16_t enhancedHue; + HueDirection direction; + uint16_t transitionTime; + uint8_t optionsMask; + uint8_t optionsOverride; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace EnhancedMoveToHueCommandParams +namespace EnhancedMoveToHueAndSaturationCommandParams { +enum FieldId +{ + kEnhancedHueFieldId = 0, + kSaturationFieldId = 1, + kTransitionTimeFieldId = 2, + kOptionsMaskFieldId = 3, + kOptionsOverrideFieldId = 4, +}; + +struct Type +{ +public: + uint16_t enhancedHue; + uint8_t saturation; + uint16_t transitionTime; + uint8_t optionsMask; + uint8_t optionsOverride; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace EnhancedMoveToHueAndSaturationCommandParams +namespace EnhancedStepHueCommandParams { +enum FieldId +{ + kStepModeFieldId = 0, + kStepSizeFieldId = 1, + kTransitionTimeFieldId = 2, + kOptionsMaskFieldId = 3, + kOptionsOverrideFieldId = 4, +}; + +struct Type +{ +public: + HueStepMode stepMode; + uint16_t stepSize; + uint16_t transitionTime; + uint8_t optionsMask; + uint8_t optionsOverride; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace EnhancedStepHueCommandParams +namespace MoveColorCommandParams { +enum FieldId +{ + kRateXFieldId = 0, + kRateYFieldId = 1, + kOptionsMaskFieldId = 2, + kOptionsOverrideFieldId = 3, +}; + +struct Type +{ +public: + int16_t rateX; + int16_t rateY; + uint8_t optionsMask; + uint8_t optionsOverride; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace MoveColorCommandParams +namespace MoveColorTemperatureCommandParams { +enum FieldId +{ + kMoveModeFieldId = 0, + kRateFieldId = 1, + kColorTemperatureMinimumFieldId = 2, + kColorTemperatureMaximumFieldId = 3, + kOptionsMaskFieldId = 4, + kOptionsOverrideFieldId = 5, +}; + +struct Type +{ +public: + HueMoveMode moveMode; + uint16_t rate; + uint16_t colorTemperatureMinimum; + uint16_t colorTemperatureMaximum; + uint8_t optionsMask; + uint8_t optionsOverride; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace MoveColorTemperatureCommandParams +namespace MoveHueCommandParams { +enum FieldId +{ + kMoveModeFieldId = 0, + kRateFieldId = 1, + kOptionsMaskFieldId = 2, + kOptionsOverrideFieldId = 3, +}; + +struct Type +{ +public: + HueMoveMode moveMode; + uint8_t rate; + uint8_t optionsMask; + uint8_t optionsOverride; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace MoveHueCommandParams +namespace MoveSaturationCommandParams { +enum FieldId +{ + kMoveModeFieldId = 0, + kRateFieldId = 1, + kOptionsMaskFieldId = 2, + kOptionsOverrideFieldId = 3, +}; + +struct Type +{ +public: + SaturationMoveMode moveMode; + uint8_t rate; + uint8_t optionsMask; + uint8_t optionsOverride; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace MoveSaturationCommandParams +namespace MoveToColorCommandParams { +enum FieldId +{ + kColorXFieldId = 0, + kColorYFieldId = 1, + kTransitionTimeFieldId = 2, + kOptionsMaskFieldId = 3, + kOptionsOverrideFieldId = 4, +}; + +struct Type +{ +public: + uint16_t colorX; + uint16_t colorY; + uint16_t transitionTime; + uint8_t optionsMask; + uint8_t optionsOverride; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace MoveToColorCommandParams +namespace MoveToColorTemperatureCommandParams { +enum FieldId +{ + kColorTemperatureFieldId = 0, + kTransitionTimeFieldId = 1, + kOptionsMaskFieldId = 2, + kOptionsOverrideFieldId = 3, +}; + +struct Type +{ +public: + uint16_t colorTemperature; + uint16_t transitionTime; + uint8_t optionsMask; + uint8_t optionsOverride; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace MoveToColorTemperatureCommandParams +namespace MoveToHueCommandParams { +enum FieldId +{ + kHueFieldId = 0, + kDirectionFieldId = 1, + kTransitionTimeFieldId = 2, + kOptionsMaskFieldId = 3, + kOptionsOverrideFieldId = 4, +}; + +struct Type +{ +public: + uint8_t hue; + HueDirection direction; + uint16_t transitionTime; + uint8_t optionsMask; + uint8_t optionsOverride; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace MoveToHueCommandParams +namespace MoveToHueAndSaturationCommandParams { +enum FieldId +{ + kHueFieldId = 0, + kSaturationFieldId = 1, + kTransitionTimeFieldId = 2, + kOptionsMaskFieldId = 3, + kOptionsOverrideFieldId = 4, +}; + +struct Type +{ +public: + uint8_t hue; + uint8_t saturation; + uint16_t transitionTime; + uint8_t optionsMask; + uint8_t optionsOverride; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace MoveToHueAndSaturationCommandParams +namespace MoveToSaturationCommandParams { +enum FieldId +{ + kSaturationFieldId = 0, + kTransitionTimeFieldId = 1, + kOptionsMaskFieldId = 2, + kOptionsOverrideFieldId = 3, +}; + +struct Type +{ +public: + uint8_t saturation; + uint16_t transitionTime; + uint8_t optionsMask; + uint8_t optionsOverride; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace MoveToSaturationCommandParams +namespace StepColorCommandParams { +enum FieldId +{ + kStepXFieldId = 0, + kStepYFieldId = 1, + kTransitionTimeFieldId = 2, + kOptionsMaskFieldId = 3, + kOptionsOverrideFieldId = 4, +}; + +struct Type +{ +public: + int16_t stepX; + int16_t stepY; + uint16_t transitionTime; + uint8_t optionsMask; + uint8_t optionsOverride; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace StepColorCommandParams +namespace StepColorTemperatureCommandParams { +enum FieldId +{ + kStepModeFieldId = 0, + kStepSizeFieldId = 1, + kTransitionTimeFieldId = 2, + kColorTemperatureMinimumFieldId = 3, + kColorTemperatureMaximumFieldId = 4, + kOptionsMaskFieldId = 5, + kOptionsOverrideFieldId = 6, +}; + +struct Type +{ +public: + HueStepMode stepMode; + uint16_t stepSize; + uint16_t transitionTime; + uint16_t colorTemperatureMinimum; + uint16_t colorTemperatureMaximum; + uint8_t optionsMask; + uint8_t optionsOverride; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace StepColorTemperatureCommandParams +namespace StepHueCommandParams { +enum FieldId +{ + kStepModeFieldId = 0, + kStepSizeFieldId = 1, + kTransitionTimeFieldId = 2, + kOptionsMaskFieldId = 3, + kOptionsOverrideFieldId = 4, +}; + +struct Type +{ +public: + HueStepMode stepMode; + uint8_t stepSize; + uint16_t transitionTime; + uint8_t optionsMask; + uint8_t optionsOverride; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace StepHueCommandParams +namespace StepSaturationCommandParams { +enum FieldId +{ + kStepModeFieldId = 0, + kStepSizeFieldId = 1, + kTransitionTimeFieldId = 2, + kOptionsMaskFieldId = 3, + kOptionsOverrideFieldId = 4, +}; + +struct Type +{ +public: + SaturationStepMode stepMode; + uint8_t stepSize; + uint16_t transitionTime; + uint8_t optionsMask; + uint8_t optionsOverride; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace StepSaturationCommandParams +namespace StopMoveStepCommandParams { +enum FieldId +{ + kOptionsMaskFieldId = 0, + kOptionsOverrideFieldId = 1, +}; + +struct Type +{ +public: + uint8_t optionsMask; + uint8_t optionsOverride; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace StopMoveStepCommandParams + +} // namespace ColorControl + +// ContentLauncher Cluster Commands +namespace ContentLauncher { + +namespace LaunchContentCommandParams { +enum FieldId +{ + kAutoPlayFieldId = 0, + kDataFieldId = 1, +}; + +struct Type +{ +public: + bool autoPlay; + Span data; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace LaunchContentCommandParams +namespace LaunchURLCommandParams { +enum FieldId +{ + kContentURLFieldId = 0, + kDisplayStringFieldId = 1, +}; + +struct Type +{ +public: + Span contentURL; + Span displayString; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace LaunchURLCommandParams + +namespace LaunchContentResponseCommandParams { +enum FieldId +{ + kDataFieldId = 0, + kContentLaunchStatusFieldId = 1, +}; + +struct Type +{ +public: + // TODO + + CHIP_ERROR Decode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace LaunchContentResponseCommandParams +namespace LaunchURLResponseCommandParams { +enum FieldId +{ + kDataFieldId = 0, + kContentLaunchStatusFieldId = 1, +}; + +struct Type +{ +public: + // TODO + + CHIP_ERROR Decode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace LaunchURLResponseCommandParams + +} // namespace ContentLauncher + +// Descriptor Cluster Commands +namespace Descriptor { + +} // namespace Descriptor + +// DiagnosticLogs Cluster Commands +namespace DiagnosticLogs { + +namespace RetrieveLogsRequestCommandParams { +enum FieldId +{ + kIntentFieldId = 0, + kRequestedProtocolFieldId = 1, + kTransferFileDesignatorFieldId = 2, +}; + +struct Type +{ +public: + LogsIntent intent; + LogsTransferProtocol requestedProtocol; + chip::ByteSpan transferFileDesignator; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace RetrieveLogsRequestCommandParams + +} // namespace DiagnosticLogs + +// DoorLock Cluster Commands +namespace DoorLock { + +namespace ClearAllPinsCommandParams { +enum FieldId +{ +}; + +struct Type +{ +public: + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace ClearAllPinsCommandParams +namespace ClearAllRfidsCommandParams { +enum FieldId +{ +}; + +struct Type +{ +public: + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace ClearAllRfidsCommandParams +namespace ClearHolidayScheduleCommandParams { +enum FieldId +{ + kScheduleIdFieldId = 0, +}; + +struct Type +{ +public: + uint8_t scheduleId; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace ClearHolidayScheduleCommandParams +namespace ClearPinCommandParams { +enum FieldId +{ + kUserIdFieldId = 0, +}; + +struct Type +{ +public: + uint16_t userId; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace ClearPinCommandParams +namespace ClearRfidCommandParams { +enum FieldId +{ + kUserIdFieldId = 0, +}; + +struct Type +{ +public: + uint16_t userId; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace ClearRfidCommandParams +namespace ClearWeekdayScheduleCommandParams { +enum FieldId +{ + kScheduleIdFieldId = 0, + kUserIdFieldId = 1, +}; + +struct Type +{ +public: + uint8_t scheduleId; + uint16_t userId; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace ClearWeekdayScheduleCommandParams +namespace ClearYeardayScheduleCommandParams { +enum FieldId +{ + kScheduleIdFieldId = 0, + kUserIdFieldId = 1, +}; + +struct Type +{ +public: + uint8_t scheduleId; + uint16_t userId; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace ClearYeardayScheduleCommandParams +namespace GetHolidayScheduleCommandParams { +enum FieldId +{ + kScheduleIdFieldId = 0, +}; + +struct Type +{ +public: + uint8_t scheduleId; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace GetHolidayScheduleCommandParams +namespace GetLogRecordCommandParams { +enum FieldId +{ + kLogIndexFieldId = 0, +}; + +struct Type +{ +public: + uint16_t logIndex; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace GetLogRecordCommandParams +namespace GetPinCommandParams { +enum FieldId +{ + kUserIdFieldId = 0, +}; + +struct Type +{ +public: + uint16_t userId; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace GetPinCommandParams +namespace GetRfidCommandParams { +enum FieldId +{ + kUserIdFieldId = 0, +}; + +struct Type +{ +public: + uint16_t userId; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace GetRfidCommandParams +namespace GetUserTypeCommandParams { +enum FieldId +{ + kUserIdFieldId = 0, +}; + +struct Type +{ +public: + uint16_t userId; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace GetUserTypeCommandParams +namespace GetWeekdayScheduleCommandParams { +enum FieldId +{ + kScheduleIdFieldId = 0, + kUserIdFieldId = 1, +}; + +struct Type +{ +public: + uint8_t scheduleId; + uint16_t userId; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace GetWeekdayScheduleCommandParams +namespace GetYeardayScheduleCommandParams { +enum FieldId +{ + kScheduleIdFieldId = 0, + kUserIdFieldId = 1, +}; + +struct Type +{ +public: + uint8_t scheduleId; + uint16_t userId; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace GetYeardayScheduleCommandParams +namespace LockDoorCommandParams { +enum FieldId +{ + kPinFieldId = 0, +}; + +struct Type +{ +public: + Span pin; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace LockDoorCommandParams +namespace SetHolidayScheduleCommandParams { +enum FieldId +{ + kScheduleIdFieldId = 0, + kLocalStartTimeFieldId = 1, + kLocalEndTimeFieldId = 2, + kOperatingModeDuringHolidayFieldId = 3, +}; + +struct Type +{ +public: + uint8_t scheduleId; + uint32_t localStartTime; + uint32_t localEndTime; + uint8_t operatingModeDuringHoliday; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace SetHolidayScheduleCommandParams +namespace SetPinCommandParams { +enum FieldId +{ + kUserIdFieldId = 0, + kUserStatusFieldId = 1, + kUserTypeFieldId = 2, + kPinFieldId = 3, +}; + +struct Type +{ +public: + uint16_t userId; + DoorLockUserStatus userStatus; + DoorLockUserType userType; + Span pin; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace SetPinCommandParams +namespace SetRfidCommandParams { +enum FieldId +{ + kUserIdFieldId = 0, + kUserStatusFieldId = 1, + kUserTypeFieldId = 2, + kIdFieldId = 3, +}; + +struct Type +{ +public: + uint16_t userId; + DoorLockUserStatus userStatus; + DoorLockUserType userType; + Span id; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace SetRfidCommandParams +namespace SetUserTypeCommandParams { +enum FieldId +{ + kUserIdFieldId = 0, + kUserTypeFieldId = 1, +}; + +struct Type +{ +public: + uint16_t userId; + DoorLockUserType userType; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace SetUserTypeCommandParams +namespace SetWeekdayScheduleCommandParams { +enum FieldId +{ + kScheduleIdFieldId = 0, + kUserIdFieldId = 1, + kDaysMaskFieldId = 2, + kStartHourFieldId = 3, + kStartMinuteFieldId = 4, + kEndHourFieldId = 5, + kEndMinuteFieldId = 6, +}; + +struct Type +{ +public: + uint8_t scheduleId; + uint16_t userId; + uint8_t daysMask; + uint8_t startHour; + uint8_t startMinute; + uint8_t endHour; + uint8_t endMinute; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace SetWeekdayScheduleCommandParams +namespace SetYeardayScheduleCommandParams { +enum FieldId +{ + kScheduleIdFieldId = 0, + kUserIdFieldId = 1, + kLocalStartTimeFieldId = 2, + kLocalEndTimeFieldId = 3, +}; + +struct Type +{ +public: + uint8_t scheduleId; + uint16_t userId; + uint32_t localStartTime; + uint32_t localEndTime; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace SetYeardayScheduleCommandParams +namespace UnlockDoorCommandParams { +enum FieldId +{ + kPinFieldId = 0, +}; + +struct Type +{ +public: + Span pin; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace UnlockDoorCommandParams +namespace UnlockWithTimeoutCommandParams { +enum FieldId +{ + kTimeoutInSecondsFieldId = 0, + kPinFieldId = 1, +}; + +struct Type +{ +public: + uint16_t timeoutInSeconds; + Span pin; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace UnlockWithTimeoutCommandParams + +namespace ClearAllPinsResponseCommandParams { +enum FieldId +{ + kStatusFieldId = 0, +}; + +struct Type +{ +public: + // TODO + + CHIP_ERROR Decode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace ClearAllPinsResponseCommandParams +namespace ClearAllRfidsResponseCommandParams { +enum FieldId +{ + kStatusFieldId = 0, +}; + +struct Type +{ +public: + // TODO + + CHIP_ERROR Decode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace ClearAllRfidsResponseCommandParams +namespace ClearHolidayScheduleResponseCommandParams { +enum FieldId +{ + kStatusFieldId = 0, +}; + +struct Type +{ +public: + // TODO + + CHIP_ERROR Decode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace ClearHolidayScheduleResponseCommandParams +namespace ClearPinResponseCommandParams { +enum FieldId +{ + kStatusFieldId = 0, +}; + +struct Type +{ +public: + // TODO + + CHIP_ERROR Decode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace ClearPinResponseCommandParams +namespace ClearRfidResponseCommandParams { +enum FieldId +{ + kStatusFieldId = 0, +}; + +struct Type +{ +public: + // TODO + + CHIP_ERROR Decode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace ClearRfidResponseCommandParams +namespace ClearWeekdayScheduleResponseCommandParams { +enum FieldId +{ + kStatusFieldId = 0, +}; + +struct Type +{ +public: + // TODO + + CHIP_ERROR Decode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace ClearWeekdayScheduleResponseCommandParams +namespace ClearYeardayScheduleResponseCommandParams { +enum FieldId +{ + kStatusFieldId = 0, +}; + +struct Type +{ +public: + // TODO + + CHIP_ERROR Decode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace ClearYeardayScheduleResponseCommandParams +namespace GetHolidayScheduleResponseCommandParams { +enum FieldId +{ + kScheduleIdFieldId = 0, + kStatusFieldId = 1, + kLocalStartTimeFieldId = 2, + kLocalEndTimeFieldId = 3, + kOperatingModeDuringHolidayFieldId = 4, +}; + +struct Type +{ +public: + // TODO + + CHIP_ERROR Decode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace GetHolidayScheduleResponseCommandParams +namespace GetLogRecordResponseCommandParams { +enum FieldId +{ + kLogEntryIdFieldId = 0, + kTimestampFieldId = 1, + kEventTypeFieldId = 2, + kSourceFieldId = 3, + kEventIdOrAlarmCodeFieldId = 4, + kUserIdFieldId = 5, + kPinFieldId = 6, +}; + +struct Type +{ +public: + // TODO + + CHIP_ERROR Decode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace GetLogRecordResponseCommandParams +namespace GetPinResponseCommandParams { +enum FieldId +{ + kUserIdFieldId = 0, + kUserStatusFieldId = 1, + kUserTypeFieldId = 2, + kPinFieldId = 3, +}; + +struct Type +{ +public: + // TODO + + CHIP_ERROR Decode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace GetPinResponseCommandParams +namespace GetRfidResponseCommandParams { +enum FieldId +{ + kUserIdFieldId = 0, + kUserStatusFieldId = 1, + kUserTypeFieldId = 2, + kRfidFieldId = 3, +}; + +struct Type +{ +public: + // TODO + + CHIP_ERROR Decode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace GetRfidResponseCommandParams +namespace GetUserTypeResponseCommandParams { +enum FieldId +{ + kUserIdFieldId = 0, + kUserTypeFieldId = 1, +}; + +struct Type +{ +public: + // TODO + + CHIP_ERROR Decode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace GetUserTypeResponseCommandParams +namespace GetWeekdayScheduleResponseCommandParams { +enum FieldId +{ + kScheduleIdFieldId = 0, + kUserIdFieldId = 1, + kStatusFieldId = 2, + kDaysMaskFieldId = 3, + kStartHourFieldId = 4, + kStartMinuteFieldId = 5, + kEndHourFieldId = 6, + kEndMinuteFieldId = 7, +}; + +struct Type +{ +public: + // TODO + + CHIP_ERROR Decode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace GetWeekdayScheduleResponseCommandParams +namespace GetYeardayScheduleResponseCommandParams { +enum FieldId +{ + kScheduleIdFieldId = 0, + kUserIdFieldId = 1, + kStatusFieldId = 2, + kLocalStartTimeFieldId = 3, + kLocalEndTimeFieldId = 4, +}; + +struct Type +{ +public: + // TODO + + CHIP_ERROR Decode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace GetYeardayScheduleResponseCommandParams +namespace LockDoorResponseCommandParams { +enum FieldId +{ + kStatusFieldId = 0, +}; + +struct Type +{ +public: + // TODO + + CHIP_ERROR Decode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace LockDoorResponseCommandParams +namespace SetHolidayScheduleResponseCommandParams { +enum FieldId +{ + kStatusFieldId = 0, +}; + +struct Type +{ +public: + // TODO + + CHIP_ERROR Decode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace SetHolidayScheduleResponseCommandParams +namespace SetPinResponseCommandParams { +enum FieldId +{ + kStatusFieldId = 0, +}; + +struct Type +{ +public: + // TODO + + CHIP_ERROR Decode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace SetPinResponseCommandParams +namespace SetRfidResponseCommandParams { +enum FieldId +{ + kStatusFieldId = 0, +}; + +struct Type +{ +public: + // TODO + + CHIP_ERROR Decode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace SetRfidResponseCommandParams +namespace SetUserTypeResponseCommandParams { +enum FieldId +{ + kStatusFieldId = 0, +}; + +struct Type +{ +public: + // TODO + + CHIP_ERROR Decode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace SetUserTypeResponseCommandParams +namespace SetWeekdayScheduleResponseCommandParams { +enum FieldId +{ + kStatusFieldId = 0, +}; + +struct Type +{ +public: + // TODO + + CHIP_ERROR Decode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace SetWeekdayScheduleResponseCommandParams +namespace SetYeardayScheduleResponseCommandParams { +enum FieldId +{ + kStatusFieldId = 0, +}; + +struct Type +{ +public: + // TODO + + CHIP_ERROR Decode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace SetYeardayScheduleResponseCommandParams +namespace UnlockDoorResponseCommandParams { +enum FieldId +{ + kStatusFieldId = 0, +}; + +struct Type +{ +public: + // TODO + + CHIP_ERROR Decode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace UnlockDoorResponseCommandParams +namespace UnlockWithTimeoutResponseCommandParams { +enum FieldId +{ + kStatusFieldId = 0, +}; + +struct Type +{ +public: + // TODO + + CHIP_ERROR Decode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace UnlockWithTimeoutResponseCommandParams + +} // namespace DoorLock + +// ElectricalMeasurement Cluster Commands +namespace ElectricalMeasurement { + +} // namespace ElectricalMeasurement + +// EthernetNetworkDiagnostics Cluster Commands +namespace EthernetNetworkDiagnostics { + +namespace ResetCountsCommandParams { +enum FieldId +{ +}; + +struct Type +{ +public: + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace ResetCountsCommandParams + +} // namespace EthernetNetworkDiagnostics + +// FixedLabel Cluster Commands +namespace FixedLabel { + +} // namespace FixedLabel + +// FlowMeasurement Cluster Commands +namespace FlowMeasurement { + +} // namespace FlowMeasurement + +// GeneralCommissioning Cluster Commands +namespace GeneralCommissioning { + +namespace ArmFailSafeCommandParams { +enum FieldId +{ + kExpiryLengthSecondsFieldId = 0, + kBreadcrumbFieldId = 1, + kTimeoutMsFieldId = 2, +}; + +struct Type +{ +public: + uint16_t expiryLengthSeconds; + uint64_t breadcrumb; + uint32_t timeoutMs; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace ArmFailSafeCommandParams +namespace CommissioningCompleteCommandParams { +enum FieldId +{ +}; + +struct Type +{ +public: + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace CommissioningCompleteCommandParams +namespace SetRegulatoryConfigCommandParams { +enum FieldId +{ + kLocationFieldId = 0, + kCountryCodeFieldId = 1, + kBreadcrumbFieldId = 2, + kTimeoutMsFieldId = 3, +}; + +struct Type +{ +public: + RegulatoryLocationType location; + Span countryCode; + uint64_t breadcrumb; + uint32_t timeoutMs; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace SetRegulatoryConfigCommandParams + +namespace ArmFailSafeResponseCommandParams { +enum FieldId +{ + kErrorCodeFieldId = 0, + kDebugTextFieldId = 1, +}; + +struct Type +{ +public: + // TODO + + CHIP_ERROR Decode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace ArmFailSafeResponseCommandParams +namespace CommissioningCompleteResponseCommandParams { +enum FieldId +{ + kErrorCodeFieldId = 0, + kDebugTextFieldId = 1, +}; + +struct Type +{ +public: + // TODO + + CHIP_ERROR Decode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace CommissioningCompleteResponseCommandParams +namespace SetRegulatoryConfigResponseCommandParams { +enum FieldId +{ + kErrorCodeFieldId = 0, + kDebugTextFieldId = 1, +}; + +struct Type +{ +public: + // TODO + + CHIP_ERROR Decode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace SetRegulatoryConfigResponseCommandParams + +} // namespace GeneralCommissioning + +// GeneralDiagnostics Cluster Commands +namespace GeneralDiagnostics { + +} // namespace GeneralDiagnostics + +// GroupKeyManagement Cluster Commands +namespace GroupKeyManagement { + +} // namespace GroupKeyManagement + +// Groups Cluster Commands +namespace Groups { + +namespace AddGroupCommandParams { +enum FieldId +{ + kGroupIdFieldId = 0, + kGroupNameFieldId = 1, +}; + +struct Type +{ +public: + uint16_t groupId; + Span groupName; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace AddGroupCommandParams +namespace AddGroupIfIdentifyingCommandParams { +enum FieldId +{ + kGroupIdFieldId = 0, + kGroupNameFieldId = 1, +}; + +struct Type +{ +public: + uint16_t groupId; + Span groupName; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace AddGroupIfIdentifyingCommandParams +namespace GetGroupMembershipCommandParams { +enum FieldId +{ + kGroupCountFieldId = 0, + kGroupListFieldId = 1, +}; + +struct Type +{ +public: + uint8_t groupCount; + DataModel::List groupList; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace GetGroupMembershipCommandParams +namespace RemoveAllGroupsCommandParams { +enum FieldId +{ +}; + +struct Type +{ +public: + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace RemoveAllGroupsCommandParams +namespace RemoveGroupCommandParams { +enum FieldId +{ + kGroupIdFieldId = 0, +}; + +struct Type +{ +public: + uint16_t groupId; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace RemoveGroupCommandParams +namespace ViewGroupCommandParams { +enum FieldId +{ + kGroupIdFieldId = 0, +}; + +struct Type +{ +public: + uint16_t groupId; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace ViewGroupCommandParams + +namespace AddGroupResponseCommandParams { +enum FieldId +{ + kStatusFieldId = 0, + kGroupIdFieldId = 1, +}; + +struct Type +{ +public: + // TODO + + CHIP_ERROR Decode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace AddGroupResponseCommandParams +namespace GetGroupMembershipResponseCommandParams { +enum FieldId +{ + kCapacityFieldId = 0, + kGroupCountFieldId = 1, + kGroupListFieldId = 2, +}; + +struct Type +{ +public: + // TODO + + CHIP_ERROR Decode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace GetGroupMembershipResponseCommandParams +namespace RemoveGroupResponseCommandParams { +enum FieldId +{ + kStatusFieldId = 0, + kGroupIdFieldId = 1, +}; + +struct Type +{ +public: + // TODO + + CHIP_ERROR Decode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace RemoveGroupResponseCommandParams +namespace ViewGroupResponseCommandParams { +enum FieldId +{ + kStatusFieldId = 0, + kGroupIdFieldId = 1, + kGroupNameFieldId = 2, +}; + +struct Type +{ +public: + // TODO + + CHIP_ERROR Decode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace ViewGroupResponseCommandParams + +} // namespace Groups + +// Identify Cluster Commands +namespace Identify { + +namespace IdentifyCommandParams { +enum FieldId +{ + kIdentifyTimeFieldId = 0, +}; + +struct Type +{ +public: + uint16_t identifyTime; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace IdentifyCommandParams +namespace IdentifyQueryCommandParams { +enum FieldId +{ +}; + +struct Type +{ +public: + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace IdentifyQueryCommandParams + +namespace IdentifyQueryResponseCommandParams { +enum FieldId +{ + kTimeoutFieldId = 0, +}; + +struct Type +{ +public: + // TODO + + CHIP_ERROR Decode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace IdentifyQueryResponseCommandParams + +} // namespace Identify + +// KeypadInput Cluster Commands +namespace KeypadInput { + +namespace SendKeyCommandParams { +enum FieldId +{ + kKeyCodeFieldId = 0, +}; + +struct Type +{ +public: + KeypadInputCecKeyCode keyCode; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace SendKeyCommandParams + +namespace SendKeyResponseCommandParams { +enum FieldId +{ + kStatusFieldId = 0, +}; + +struct Type +{ +public: + // TODO + + CHIP_ERROR Decode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace SendKeyResponseCommandParams + +} // namespace KeypadInput + +// LevelControl Cluster Commands +namespace LevelControl { + +namespace MoveCommandParams { +enum FieldId +{ + kMoveModeFieldId = 0, + kRateFieldId = 1, + kOptionMaskFieldId = 2, + kOptionOverrideFieldId = 3, +}; + +struct Type +{ +public: + MoveMode moveMode; + uint8_t rate; + uint8_t optionMask; + uint8_t optionOverride; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace MoveCommandParams +namespace MoveToLevelCommandParams { +enum FieldId +{ + kLevelFieldId = 0, + kTransitionTimeFieldId = 1, + kOptionMaskFieldId = 2, + kOptionOverrideFieldId = 3, +}; + +struct Type +{ +public: + uint8_t level; + uint16_t transitionTime; + uint8_t optionMask; + uint8_t optionOverride; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace MoveToLevelCommandParams +namespace MoveToLevelWithOnOffCommandParams { +enum FieldId +{ + kLevelFieldId = 0, + kTransitionTimeFieldId = 1, +}; + +struct Type +{ +public: + uint8_t level; + uint16_t transitionTime; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace MoveToLevelWithOnOffCommandParams +namespace MoveWithOnOffCommandParams { +enum FieldId +{ + kMoveModeFieldId = 0, + kRateFieldId = 1, +}; + +struct Type +{ +public: + MoveMode moveMode; + uint8_t rate; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace MoveWithOnOffCommandParams +namespace StepCommandParams { +enum FieldId +{ + kStepModeFieldId = 0, + kStepSizeFieldId = 1, + kTransitionTimeFieldId = 2, + kOptionMaskFieldId = 3, + kOptionOverrideFieldId = 4, +}; + +struct Type +{ +public: + StepMode stepMode; + uint8_t stepSize; + uint16_t transitionTime; + uint8_t optionMask; + uint8_t optionOverride; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace StepCommandParams +namespace StepWithOnOffCommandParams { +enum FieldId +{ + kStepModeFieldId = 0, + kStepSizeFieldId = 1, + kTransitionTimeFieldId = 2, +}; + +struct Type +{ +public: + StepMode stepMode; + uint8_t stepSize; + uint16_t transitionTime; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace StepWithOnOffCommandParams +namespace StopCommandParams { +enum FieldId +{ + kOptionMaskFieldId = 0, + kOptionOverrideFieldId = 1, +}; + +struct Type +{ +public: + uint8_t optionMask; + uint8_t optionOverride; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace StopCommandParams +namespace StopWithOnOffCommandParams { +enum FieldId +{ +}; + +struct Type +{ +public: + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace StopWithOnOffCommandParams + +} // namespace LevelControl + +// LowPower Cluster Commands +namespace LowPower { + +namespace SleepCommandParams { +enum FieldId +{ +}; + +struct Type +{ +public: + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace SleepCommandParams + +} // namespace LowPower + +// MediaInput Cluster Commands +namespace MediaInput { + +namespace HideInputStatusCommandParams { +enum FieldId +{ +}; + +struct Type +{ +public: + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace HideInputStatusCommandParams +namespace RenameInputCommandParams { +enum FieldId +{ + kIndexFieldId = 0, + kNameFieldId = 1, +}; + +struct Type +{ +public: + uint8_t index; + Span name; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace RenameInputCommandParams +namespace SelectInputCommandParams { +enum FieldId +{ + kIndexFieldId = 0, +}; + +struct Type +{ +public: + uint8_t index; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace SelectInputCommandParams +namespace ShowInputStatusCommandParams { +enum FieldId +{ +}; + +struct Type +{ +public: + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace ShowInputStatusCommandParams + +} // namespace MediaInput + +// MediaPlayback Cluster Commands +namespace MediaPlayback { + +namespace MediaFastForwardCommandParams { +enum FieldId +{ +}; + +struct Type +{ +public: + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace MediaFastForwardCommandParams +namespace MediaNextCommandParams { +enum FieldId +{ +}; + +struct Type +{ +public: + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace MediaNextCommandParams +namespace MediaPauseCommandParams { +enum FieldId +{ +}; + +struct Type +{ +public: + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace MediaPauseCommandParams +namespace MediaPlayCommandParams { +enum FieldId +{ +}; + +struct Type +{ +public: + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace MediaPlayCommandParams +namespace MediaPreviousCommandParams { +enum FieldId +{ +}; + +struct Type +{ +public: + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace MediaPreviousCommandParams +namespace MediaRewindCommandParams { +enum FieldId +{ +}; + +struct Type +{ +public: + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace MediaRewindCommandParams +namespace MediaSeekCommandParams { +enum FieldId +{ + kPositionFieldId = 0, +}; + +struct Type +{ +public: + uint64_t position; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace MediaSeekCommandParams +namespace MediaSkipBackwardCommandParams { +enum FieldId +{ + kDeltaPositionMillisecondsFieldId = 0, +}; + +struct Type +{ +public: + uint64_t deltaPositionMilliseconds; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace MediaSkipBackwardCommandParams +namespace MediaSkipForwardCommandParams { +enum FieldId +{ + kDeltaPositionMillisecondsFieldId = 0, +}; + +struct Type +{ +public: + uint64_t deltaPositionMilliseconds; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace MediaSkipForwardCommandParams +namespace MediaStartOverCommandParams { +enum FieldId +{ +}; + +struct Type +{ +public: + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace MediaStartOverCommandParams +namespace MediaStopCommandParams { +enum FieldId +{ +}; + +struct Type +{ +public: + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace MediaStopCommandParams + +namespace MediaFastForwardResponseCommandParams { +enum FieldId +{ + kMediaPlaybackStatusFieldId = 0, +}; + +struct Type +{ +public: + // TODO + + CHIP_ERROR Decode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace MediaFastForwardResponseCommandParams +namespace MediaNextResponseCommandParams { +enum FieldId +{ + kMediaPlaybackStatusFieldId = 0, +}; + +struct Type +{ +public: + // TODO + + CHIP_ERROR Decode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace MediaNextResponseCommandParams +namespace MediaPauseResponseCommandParams { +enum FieldId +{ + kMediaPlaybackStatusFieldId = 0, +}; + +struct Type +{ +public: + // TODO + + CHIP_ERROR Decode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace MediaPauseResponseCommandParams +namespace MediaPlayResponseCommandParams { +enum FieldId +{ + kMediaPlaybackStatusFieldId = 0, +}; + +struct Type +{ +public: + // TODO + + CHIP_ERROR Decode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace MediaPlayResponseCommandParams +namespace MediaPreviousResponseCommandParams { +enum FieldId +{ + kMediaPlaybackStatusFieldId = 0, +}; + +struct Type +{ +public: + // TODO + + CHIP_ERROR Decode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace MediaPreviousResponseCommandParams +namespace MediaRewindResponseCommandParams { +enum FieldId +{ + kMediaPlaybackStatusFieldId = 0, +}; + +struct Type +{ +public: + // TODO + + CHIP_ERROR Decode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace MediaRewindResponseCommandParams +namespace MediaSeekResponseCommandParams { +enum FieldId +{ + kMediaPlaybackStatusFieldId = 0, +}; + +struct Type +{ +public: + // TODO + + CHIP_ERROR Decode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace MediaSeekResponseCommandParams +namespace MediaSkipBackwardResponseCommandParams { +enum FieldId +{ + kMediaPlaybackStatusFieldId = 0, +}; + +struct Type +{ +public: + // TODO + + CHIP_ERROR Decode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace MediaSkipBackwardResponseCommandParams +namespace MediaSkipForwardResponseCommandParams { +enum FieldId +{ + kMediaPlaybackStatusFieldId = 0, +}; + +struct Type +{ +public: + // TODO + + CHIP_ERROR Decode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace MediaSkipForwardResponseCommandParams +namespace MediaStartOverResponseCommandParams { +enum FieldId +{ + kMediaPlaybackStatusFieldId = 0, +}; + +struct Type +{ +public: + // TODO + + CHIP_ERROR Decode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace MediaStartOverResponseCommandParams +namespace MediaStopResponseCommandParams { +enum FieldId +{ + kMediaPlaybackStatusFieldId = 0, +}; + +struct Type +{ +public: + // TODO + + CHIP_ERROR Decode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace MediaStopResponseCommandParams + +} // namespace MediaPlayback + +// NetworkCommissioning Cluster Commands +namespace NetworkCommissioning { + +namespace AddThreadNetworkCommandParams { +enum FieldId +{ + kOperationalDatasetFieldId = 0, + kBreadcrumbFieldId = 1, + kTimeoutMsFieldId = 2, +}; + +struct Type +{ +public: + chip::ByteSpan operationalDataset; + uint64_t breadcrumb; + uint32_t timeoutMs; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace AddThreadNetworkCommandParams +namespace AddWiFiNetworkCommandParams { +enum FieldId +{ + kSsidFieldId = 0, + kCredentialsFieldId = 1, + kBreadcrumbFieldId = 2, + kTimeoutMsFieldId = 3, +}; + +struct Type +{ +public: + chip::ByteSpan ssid; + chip::ByteSpan credentials; + uint64_t breadcrumb; + uint32_t timeoutMs; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace AddWiFiNetworkCommandParams +namespace DisableNetworkCommandParams { +enum FieldId +{ + kNetworkIDFieldId = 0, + kBreadcrumbFieldId = 1, + kTimeoutMsFieldId = 2, +}; + +struct Type +{ +public: + chip::ByteSpan networkID; + uint64_t breadcrumb; + uint32_t timeoutMs; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace DisableNetworkCommandParams +namespace EnableNetworkCommandParams { +enum FieldId +{ + kNetworkIDFieldId = 0, + kBreadcrumbFieldId = 1, + kTimeoutMsFieldId = 2, +}; + +struct Type +{ +public: + chip::ByteSpan networkID; + uint64_t breadcrumb; + uint32_t timeoutMs; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace EnableNetworkCommandParams +namespace GetLastNetworkCommissioningResultCommandParams { +enum FieldId +{ + kTimeoutMsFieldId = 0, +}; + +struct Type +{ +public: + uint32_t timeoutMs; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace GetLastNetworkCommissioningResultCommandParams +namespace RemoveNetworkCommandParams { +enum FieldId +{ + kNetworkIDFieldId = 0, + kBreadcrumbFieldId = 1, + kTimeoutMsFieldId = 2, +}; + +struct Type +{ +public: + chip::ByteSpan networkID; + uint64_t breadcrumb; + uint32_t timeoutMs; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace RemoveNetworkCommandParams +namespace ScanNetworksCommandParams { +enum FieldId +{ + kSsidFieldId = 0, + kBreadcrumbFieldId = 1, + kTimeoutMsFieldId = 2, +}; + +struct Type +{ +public: + chip::ByteSpan ssid; + uint64_t breadcrumb; + uint32_t timeoutMs; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace ScanNetworksCommandParams +namespace UpdateThreadNetworkCommandParams { +enum FieldId +{ + kOperationalDatasetFieldId = 0, + kBreadcrumbFieldId = 1, + kTimeoutMsFieldId = 2, +}; + +struct Type +{ +public: + chip::ByteSpan operationalDataset; + uint64_t breadcrumb; + uint32_t timeoutMs; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace UpdateThreadNetworkCommandParams +namespace UpdateWiFiNetworkCommandParams { +enum FieldId +{ + kSsidFieldId = 0, + kCredentialsFieldId = 1, + kBreadcrumbFieldId = 2, + kTimeoutMsFieldId = 3, +}; + +struct Type +{ +public: + chip::ByteSpan ssid; + chip::ByteSpan credentials; + uint64_t breadcrumb; + uint32_t timeoutMs; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace UpdateWiFiNetworkCommandParams + +namespace AddThreadNetworkResponseCommandParams { +enum FieldId +{ + kErrorCodeFieldId = 0, + kDebugTextFieldId = 1, +}; + +struct Type +{ +public: + // TODO + + CHIP_ERROR Decode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace AddThreadNetworkResponseCommandParams +namespace AddWiFiNetworkResponseCommandParams { +enum FieldId +{ + kErrorCodeFieldId = 0, + kDebugTextFieldId = 1, +}; + +struct Type +{ +public: + // TODO + + CHIP_ERROR Decode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace AddWiFiNetworkResponseCommandParams +namespace DisableNetworkResponseCommandParams { +enum FieldId +{ + kErrorCodeFieldId = 0, + kDebugTextFieldId = 1, +}; + +struct Type +{ +public: + // TODO + + CHIP_ERROR Decode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace DisableNetworkResponseCommandParams +namespace EnableNetworkResponseCommandParams { +enum FieldId +{ + kErrorCodeFieldId = 0, + kDebugTextFieldId = 1, +}; + +struct Type +{ +public: + // TODO + + CHIP_ERROR Decode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace EnableNetworkResponseCommandParams +namespace RemoveNetworkResponseCommandParams { +enum FieldId +{ + kErrorCodeFieldId = 0, + kDebugTextFieldId = 1, +}; + +struct Type +{ +public: + // TODO + + CHIP_ERROR Decode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace RemoveNetworkResponseCommandParams +namespace ScanNetworksResponseCommandParams { +enum FieldId +{ + kErrorCodeFieldId = 0, + kDebugTextFieldId = 1, + kWifiScanResultsFieldId = 2, + kThreadScanResultsFieldId = 3, +}; + +struct Type +{ +public: + // TODO + + CHIP_ERROR Decode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace ScanNetworksResponseCommandParams +namespace UpdateThreadNetworkResponseCommandParams { +enum FieldId +{ + kErrorCodeFieldId = 0, + kDebugTextFieldId = 1, +}; + +struct Type +{ +public: + // TODO + + CHIP_ERROR Decode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace UpdateThreadNetworkResponseCommandParams +namespace UpdateWiFiNetworkResponseCommandParams { +enum FieldId +{ + kErrorCodeFieldId = 0, + kDebugTextFieldId = 1, +}; + +struct Type +{ +public: + // TODO + + CHIP_ERROR Decode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace UpdateWiFiNetworkResponseCommandParams + +} // namespace NetworkCommissioning + +// OtaSoftwareUpdateProvider Cluster Commands +namespace OtaSoftwareUpdateProvider { + +namespace ApplyUpdateRequestCommandParams { +enum FieldId +{ + kUpdateTokenFieldId = 0, + kNewVersionFieldId = 1, +}; + +struct Type +{ +public: + chip::ByteSpan updateToken; + uint32_t newVersion; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace ApplyUpdateRequestCommandParams +namespace NotifyUpdateAppliedCommandParams { +enum FieldId +{ + kUpdateTokenFieldId = 0, + kCurrentVersionFieldId = 1, +}; + +struct Type +{ +public: + chip::ByteSpan updateToken; + uint32_t currentVersion; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace NotifyUpdateAppliedCommandParams +namespace QueryImageCommandParams { +enum FieldId +{ + kVendorIdFieldId = 0, + kProductIdFieldId = 1, + kImageTypeFieldId = 2, + kHardwareVersionFieldId = 3, + kCurrentVersionFieldId = 4, + kProtocolsSupportedFieldId = 5, + kLocationFieldId = 6, + kRequestorCanConsentFieldId = 7, + kMetadataForProviderFieldId = 8, +}; + +struct Type +{ +public: + uint16_t vendorId; + uint16_t productId; + uint16_t imageType; + uint16_t hardwareVersion; + uint32_t currentVersion; + OTADownloadProtocol protocolsSupported; + Span location; + bool requestorCanConsent; + chip::ByteSpan metadataForProvider; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace QueryImageCommandParams + +namespace ApplyUpdateRequestResponseCommandParams { +enum FieldId +{ + kActionFieldId = 0, + kDelayedActionTimeFieldId = 1, +}; + +struct Type +{ +public: + // TODO + + CHIP_ERROR Decode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace ApplyUpdateRequestResponseCommandParams +namespace QueryImageResponseCommandParams { +enum FieldId +{ + kStatusFieldId = 0, + kDelayedActionTimeFieldId = 1, + kImageURIFieldId = 2, + kSoftwareVersionFieldId = 3, + kUpdateTokenFieldId = 4, + kUserConsentNeededFieldId = 5, + kMetadataForRequestorFieldId = 6, +}; + +struct Type +{ +public: + // TODO + + CHIP_ERROR Decode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace QueryImageResponseCommandParams + +} // namespace OtaSoftwareUpdateProvider + +// OtaSoftwareUpdateRequestor Cluster Commands +namespace OtaSoftwareUpdateRequestor { + +namespace AnnounceOtaProviderCommandParams { +enum FieldId +{ + kServerLocationFieldId = 0, + kVendorIdFieldId = 1, + kAnnouncementReasonFieldId = 2, + kMetadataForNodeFieldId = 3, +}; + +struct Type +{ +public: + chip::ByteSpan serverLocation; + uint16_t vendorId; + OTAAnnouncementReason announcementReason; + chip::ByteSpan metadataForNode; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace AnnounceOtaProviderCommandParams + +} // namespace OtaSoftwareUpdateRequestor + +// OccupancySensing Cluster Commands +namespace OccupancySensing { + +} // namespace OccupancySensing + +// OnOff Cluster Commands +namespace OnOff { + +namespace OffCommandParams { +enum FieldId +{ +}; + +struct Type +{ +public: + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace OffCommandParams +namespace OffWithEffectCommandParams { +enum FieldId +{ + kEffectIdFieldId = 0, + kEffectVariantFieldId = 1, +}; + +struct Type +{ +public: + OnOffEffectIdentifier effectId; + enum8 effectVariant; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace OffWithEffectCommandParams +namespace OnCommandParams { +enum FieldId +{ +}; + +struct Type +{ +public: + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace OnCommandParams +namespace OnWithRecallGlobalSceneCommandParams { +enum FieldId +{ +}; + +struct Type +{ +public: + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace OnWithRecallGlobalSceneCommandParams +namespace OnWithTimedOffCommandParams { +enum FieldId +{ + kOnOffControlFieldId = 0, + kOnTimeFieldId = 1, + kOffWaitTimeFieldId = 2, +}; + +struct Type +{ +public: + uint8_t onOffControl; + uint16_t onTime; + uint16_t offWaitTime; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace OnWithTimedOffCommandParams +namespace ToggleCommandParams { +enum FieldId +{ +}; + +struct Type +{ +public: + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace ToggleCommandParams + +} // namespace OnOff + +// OnOffSwitchConfiguration Cluster Commands +namespace OnOffSwitchConfiguration { + +} // namespace OnOffSwitchConfiguration + +// OperationalCredentials Cluster Commands +namespace OperationalCredentials { + +namespace AddNOCCommandParams { +enum FieldId +{ + kNOCValueFieldId = 0, + kICACValueFieldId = 1, + kIPKValueFieldId = 2, + kCaseAdminNodeFieldId = 3, + kAdminVendorIdFieldId = 4, +}; + +struct Type +{ +public: + chip::ByteSpan nOCValue; + chip::ByteSpan iCACValue; + chip::ByteSpan iPKValue; + uint64_t caseAdminNode; + uint16_t adminVendorId; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace AddNOCCommandParams +namespace AddTrustedRootCertificateCommandParams { +enum FieldId +{ + kRootCertificateFieldId = 0, +}; + +struct Type +{ +public: + chip::ByteSpan rootCertificate; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace AddTrustedRootCertificateCommandParams +namespace AttestationRequestCommandParams { +enum FieldId +{ + kAttestationNonceFieldId = 0, +}; + +struct Type +{ +public: + chip::ByteSpan attestationNonce; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace AttestationRequestCommandParams +namespace CertificateChainRequestCommandParams { +enum FieldId +{ + kCertificateTypeFieldId = 0, +}; + +struct Type +{ +public: + uint8_t certificateType; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace CertificateChainRequestCommandParams +namespace OpCSRRequestCommandParams { +enum FieldId +{ + kCSRNonceFieldId = 0, +}; + +struct Type +{ +public: + chip::ByteSpan cSRNonce; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace OpCSRRequestCommandParams +namespace RemoveFabricCommandParams { +enum FieldId +{ + kFabricIndexFieldId = 0, +}; + +struct Type +{ +public: + uint8_t fabricIndex; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace RemoveFabricCommandParams +namespace RemoveTrustedRootCertificateCommandParams { +enum FieldId +{ + kTrustedRootIdentifierFieldId = 0, +}; + +struct Type +{ +public: + chip::ByteSpan trustedRootIdentifier; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace RemoveTrustedRootCertificateCommandParams +namespace UpdateFabricLabelCommandParams { +enum FieldId +{ + kLabelFieldId = 0, +}; + +struct Type +{ +public: + Span label; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace UpdateFabricLabelCommandParams +namespace UpdateNOCCommandParams { +enum FieldId +{ + kNOCValueFieldId = 0, + kICACValueFieldId = 1, +}; + +struct Type +{ +public: + chip::ByteSpan nOCValue; + chip::ByteSpan iCACValue; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace UpdateNOCCommandParams + +namespace AttestationResponseCommandParams { +enum FieldId +{ + kAttestationElementsFieldId = 0, + kSignatureFieldId = 1, +}; + +struct Type +{ +public: + // TODO + + CHIP_ERROR Decode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace AttestationResponseCommandParams +namespace CertificateChainResponseCommandParams { +enum FieldId +{ + kCertificateFieldId = 0, +}; + +struct Type +{ +public: + // TODO + + CHIP_ERROR Decode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace CertificateChainResponseCommandParams +namespace NOCResponseCommandParams { +enum FieldId +{ + kStatusCodeFieldId = 0, + kFabricIndexFieldId = 1, + kDebugTextFieldId = 2, +}; + +struct Type +{ +public: + // TODO + + CHIP_ERROR Decode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace NOCResponseCommandParams +namespace OpCSRResponseCommandParams { +enum FieldId +{ + kNOCSRElementsFieldId = 0, + kAttestationSignatureFieldId = 1, +}; + +struct Type +{ +public: + // TODO + + CHIP_ERROR Decode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace OpCSRResponseCommandParams + +} // namespace OperationalCredentials + +// PowerSource Cluster Commands +namespace PowerSource { + +} // namespace PowerSource + +// PressureMeasurement Cluster Commands +namespace PressureMeasurement { + +} // namespace PressureMeasurement + +// PumpConfigurationAndControl Cluster Commands +namespace PumpConfigurationAndControl { + +} // namespace PumpConfigurationAndControl + +// RelativeHumidityMeasurement Cluster Commands +namespace RelativeHumidityMeasurement { + +} // namespace RelativeHumidityMeasurement + +// Scenes Cluster Commands +namespace Scenes { + +namespace AddSceneCommandParams { +enum FieldId +{ + kGroupIdFieldId = 0, + kSceneIdFieldId = 1, + kTransitionTimeFieldId = 2, + kSceneNameFieldId = 3, + kClusterIdFieldId = 4, + kLengthFieldId = 5, + kValueFieldId = 6, +}; + +struct Type +{ +public: + uint16_t groupId; + uint8_t sceneId; + uint16_t transitionTime; + Span sceneName; + uint32_t clusterId; + uint8_t length; + uint8_t value; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace AddSceneCommandParams +namespace GetSceneMembershipCommandParams { +enum FieldId +{ + kGroupIdFieldId = 0, +}; + +struct Type +{ +public: + uint16_t groupId; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace GetSceneMembershipCommandParams +namespace RecallSceneCommandParams { +enum FieldId +{ + kGroupIdFieldId = 0, + kSceneIdFieldId = 1, + kTransitionTimeFieldId = 2, +}; + +struct Type +{ +public: + uint16_t groupId; + uint8_t sceneId; + uint16_t transitionTime; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace RecallSceneCommandParams +namespace RemoveAllScenesCommandParams { +enum FieldId +{ + kGroupIdFieldId = 0, +}; + +struct Type +{ +public: + uint16_t groupId; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace RemoveAllScenesCommandParams +namespace RemoveSceneCommandParams { +enum FieldId +{ + kGroupIdFieldId = 0, + kSceneIdFieldId = 1, +}; + +struct Type +{ +public: + uint16_t groupId; + uint8_t sceneId; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace RemoveSceneCommandParams +namespace StoreSceneCommandParams { +enum FieldId +{ + kGroupIdFieldId = 0, + kSceneIdFieldId = 1, +}; + +struct Type +{ +public: + uint16_t groupId; + uint8_t sceneId; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace StoreSceneCommandParams +namespace ViewSceneCommandParams { +enum FieldId +{ + kGroupIdFieldId = 0, + kSceneIdFieldId = 1, +}; + +struct Type +{ +public: + uint16_t groupId; + uint8_t sceneId; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace ViewSceneCommandParams + +namespace AddSceneResponseCommandParams { +enum FieldId +{ + kStatusFieldId = 0, + kGroupIdFieldId = 1, + kSceneIdFieldId = 2, +}; + +struct Type +{ +public: + // TODO + + CHIP_ERROR Decode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace AddSceneResponseCommandParams +namespace GetSceneMembershipResponseCommandParams { +enum FieldId +{ + kStatusFieldId = 0, + kCapacityFieldId = 1, + kGroupIdFieldId = 2, + kSceneCountFieldId = 3, + kSceneListFieldId = 4, +}; + +struct Type +{ +public: + // TODO + + CHIP_ERROR Decode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace GetSceneMembershipResponseCommandParams +namespace RemoveAllScenesResponseCommandParams { +enum FieldId +{ + kStatusFieldId = 0, + kGroupIdFieldId = 1, +}; + +struct Type +{ +public: + // TODO + + CHIP_ERROR Decode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace RemoveAllScenesResponseCommandParams +namespace RemoveSceneResponseCommandParams { +enum FieldId +{ + kStatusFieldId = 0, + kGroupIdFieldId = 1, + kSceneIdFieldId = 2, +}; + +struct Type +{ +public: + // TODO + + CHIP_ERROR Decode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace RemoveSceneResponseCommandParams +namespace StoreSceneResponseCommandParams { +enum FieldId +{ + kStatusFieldId = 0, + kGroupIdFieldId = 1, + kSceneIdFieldId = 2, +}; + +struct Type +{ +public: + // TODO + + CHIP_ERROR Decode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace StoreSceneResponseCommandParams +namespace ViewSceneResponseCommandParams { +enum FieldId +{ + kStatusFieldId = 0, + kGroupIdFieldId = 1, + kSceneIdFieldId = 2, + kTransitionTimeFieldId = 3, + kSceneNameFieldId = 4, + kExtensionFieldSetsFieldId = 5, +}; + +struct Type +{ +public: + // TODO + + CHIP_ERROR Decode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace ViewSceneResponseCommandParams + +} // namespace Scenes + +// SoftwareDiagnostics Cluster Commands +namespace SoftwareDiagnostics { + +namespace ResetWatermarksCommandParams { +enum FieldId +{ +}; + +struct Type +{ +public: + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace ResetWatermarksCommandParams + +} // namespace SoftwareDiagnostics + +// Switch Cluster Commands +namespace Switch { + +} // namespace Switch + +// TvChannel Cluster Commands +namespace TvChannel { + +namespace ChangeChannelCommandParams { +enum FieldId +{ + kMatchFieldId = 0, +}; + +struct Type +{ +public: + Span match; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace ChangeChannelCommandParams +namespace ChangeChannelByNumberCommandParams { +enum FieldId +{ + kMajorNumberFieldId = 0, + kMinorNumberFieldId = 1, +}; + +struct Type +{ +public: + uint16_t majorNumber; + uint16_t minorNumber; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace ChangeChannelByNumberCommandParams +namespace SkipChannelCommandParams { +enum FieldId +{ + kCountFieldId = 0, +}; + +struct Type +{ +public: + uint16_t count; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace SkipChannelCommandParams + +namespace ChangeChannelResponseCommandParams { +enum FieldId +{ + kChannelMatchFieldId = 0, + kErrorTypeFieldId = 1, +}; + +struct Type +{ +public: + // TODO + + CHIP_ERROR Decode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace ChangeChannelResponseCommandParams + +} // namespace TvChannel + +// TargetNavigator Cluster Commands +namespace TargetNavigator { + +namespace NavigateTargetCommandParams { +enum FieldId +{ + kTargetFieldId = 0, + kDataFieldId = 1, +}; + +struct Type +{ +public: + uint8_t target; + Span data; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace NavigateTargetCommandParams + +namespace NavigateTargetResponseCommandParams { +enum FieldId +{ + kStatusFieldId = 0, + kDataFieldId = 1, +}; + +struct Type +{ +public: + // TODO + + CHIP_ERROR Decode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace NavigateTargetResponseCommandParams + +} // namespace TargetNavigator + +// TemperatureMeasurement Cluster Commands +namespace TemperatureMeasurement { + +} // namespace TemperatureMeasurement + +// TestCluster Cluster Commands +namespace TestCluster { + +namespace TestCommandParams { +enum FieldId +{ +}; + +struct Type +{ +public: + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace TestCommandParams +namespace TestAddArgumentsCommandParams { +enum FieldId +{ + kArg1FieldId = 0, + kArg2FieldId = 1, +}; + +struct Type +{ +public: + uint8_t arg1; + uint8_t arg2; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace TestAddArgumentsCommandParams +namespace TestNotHandledCommandParams { +enum FieldId +{ +}; + +struct Type +{ +public: + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace TestNotHandledCommandParams +namespace TestSpecificCommandParams { +enum FieldId +{ +}; + +struct Type +{ +public: + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace TestSpecificCommandParams +namespace TestUnknownCommandCommandParams { +enum FieldId +{ +}; + +struct Type +{ +public: + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace TestUnknownCommandCommandParams + +namespace TestAddArgumentsResponseCommandParams { +enum FieldId +{ + kReturnValueFieldId = 0, +}; + +struct Type +{ +public: + // TODO + + CHIP_ERROR Decode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace TestAddArgumentsResponseCommandParams +namespace TestSpecificResponseCommandParams { +enum FieldId +{ + kReturnValueFieldId = 0, +}; + +struct Type +{ +public: + // TODO + + CHIP_ERROR Decode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace TestSpecificResponseCommandParams + +} // namespace TestCluster + +// Thermostat Cluster Commands +namespace Thermostat { + +namespace ClearWeeklyScheduleCommandParams { +enum FieldId +{ +}; + +struct Type +{ +public: + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace ClearWeeklyScheduleCommandParams +namespace GetRelayStatusLogCommandParams { +enum FieldId +{ +}; + +struct Type +{ +public: + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace GetRelayStatusLogCommandParams +namespace GetWeeklyScheduleCommandParams { +enum FieldId +{ + kDaysToReturnFieldId = 0, + kModeToReturnFieldId = 1, +}; + +struct Type +{ +public: + uint8_t daysToReturn; + uint8_t modeToReturn; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace GetWeeklyScheduleCommandParams +namespace SetWeeklyScheduleCommandParams { +enum FieldId +{ + kNumberOfTransitionsForSequenceFieldId = 0, + kDayOfWeekForSequenceFieldId = 1, + kModeForSequenceFieldId = 2, + kPayloadFieldId = 3, +}; + +struct Type +{ +public: + uint8_t numberOfTransitionsForSequence; + uint8_t dayOfWeekForSequence; + uint8_t modeForSequence; + DataModel::List payload; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace SetWeeklyScheduleCommandParams +namespace SetpointRaiseLowerCommandParams { +enum FieldId +{ + kModeFieldId = 0, + kAmountFieldId = 1, +}; + +struct Type +{ +public: + SetpointAdjustMode mode; + int8_t amount; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace SetpointRaiseLowerCommandParams + +} // namespace Thermostat + +// ThermostatUserInterfaceConfiguration Cluster Commands +namespace ThermostatUserInterfaceConfiguration { + +} // namespace ThermostatUserInterfaceConfiguration + +// ThreadNetworkDiagnostics Cluster Commands +namespace ThreadNetworkDiagnostics { + +namespace ResetCountsCommandParams { +enum FieldId +{ +}; + +struct Type +{ +public: + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace ResetCountsCommandParams + +} // namespace ThreadNetworkDiagnostics + +// WakeOnLan Cluster Commands +namespace WakeOnLan { + +} // namespace WakeOnLan + +// WiFiNetworkDiagnostics Cluster Commands +namespace WiFiNetworkDiagnostics { + +namespace ResetCountsCommandParams { +enum FieldId +{ +}; + +struct Type +{ +public: + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace ResetCountsCommandParams + +} // namespace WiFiNetworkDiagnostics + +// WindowCovering Cluster Commands +namespace WindowCovering { + +namespace DownOrCloseCommandParams { +enum FieldId +{ +}; + +struct Type +{ +public: + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace DownOrCloseCommandParams +namespace GoToLiftPercentageCommandParams { +enum FieldId +{ + kLiftPercentageValueFieldId = 0, + kLiftPercent100thsValueFieldId = 1, +}; + +struct Type +{ +public: + uint8_t liftPercentageValue; + uint16_t liftPercent100thsValue; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace GoToLiftPercentageCommandParams +namespace GoToLiftValueCommandParams { +enum FieldId +{ + kLiftValueFieldId = 0, +}; + +struct Type +{ +public: + uint16_t liftValue; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace GoToLiftValueCommandParams +namespace GoToTiltPercentageCommandParams { +enum FieldId +{ + kTiltPercentageValueFieldId = 0, + kTiltPercent100thsValueFieldId = 1, +}; + +struct Type +{ +public: + uint8_t tiltPercentageValue; + uint16_t tiltPercent100thsValue; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace GoToTiltPercentageCommandParams +namespace GoToTiltValueCommandParams { +enum FieldId +{ + kTiltValueFieldId = 0, +}; + +struct Type +{ +public: + uint16_t tiltValue; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace GoToTiltValueCommandParams +namespace StopMotionCommandParams { +enum FieldId +{ +}; + +struct Type +{ +public: + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace StopMotionCommandParams +namespace UpOrOpenCommandParams { +enum FieldId +{ +}; + +struct Type +{ +public: + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace UpOrOpenCommandParams + +} // namespace WindowCovering + +} // namespace clusters +} // namespace app +} // namespace chip diff --git a/zzz_generated/lighting-app/zap-generated/CHIPClusters.cpp b/zzz_generated/lighting-app/zap-generated/CHIPClusters.cpp index c109f5d26e71e1..ca3b114d56d24e 100644 --- a/zzz_generated/lighting-app/zap-generated/CHIPClusters.cpp +++ b/zzz_generated/lighting-app/zap-generated/CHIPClusters.cpp @@ -21,20 +21,28 @@ #include +#include #include +#include +#include #include #include #include +#include #include +#include #include #include #include #include #include +#include namespace chip { +using namespace app; using namespace app::Clusters; +using namespace app::clusters; using namespace System; using namespace Encoding::LittleEndian; @@ -44,6 +52,15 @@ namespace Controller { // TODO(#4503): length should be passed to commands when byte string is in argument list. // TODO(#4503): Commands should take group id as an argument. +namespace { +void onClusterObjectCommandSenderFinal(CommandSender * sender, + app::ClusterObjectCommandSenderCallback * _this) +{ + Platform::Delete(sender); + Platform::Delete(_this); +} +} // namespace + // OnOff Cluster Commands // OnOff Cluster Attributes CHIP_ERROR OnOffCluster::ReadAttributeOnOff(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback) diff --git a/zzz_generated/lighting-app/zap-generated/CHIPClusters.h b/zzz_generated/lighting-app/zap-generated/CHIPClusters.h index b2bd05d1461070..f9500390d1208e 100644 --- a/zzz_generated/lighting-app/zap-generated/CHIPClusters.h +++ b/zzz_generated/lighting-app/zap-generated/CHIPClusters.h @@ -23,10 +23,14 @@ #include #include +#include + #include #include #include +#include + namespace chip { namespace Controller { diff --git a/zzz_generated/lighting-app/zap-generated/cluster_objects_commands.cpp b/zzz_generated/lighting-app/zap-generated/cluster_objects_commands.cpp new file mode 100644 index 00000000000000..6592b98cabffcb --- /dev/null +++ b/zzz_generated/lighting-app/zap-generated/cluster_objects_commands.cpp @@ -0,0 +1,36 @@ +/* + * + * 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 "cluster_objects_commands.h" + +#include + +#pragma GCC diagnostic ignored "-Wstack-usage=" + +namespace chip { +namespace app { +namespace clusters { + +namespace OnOff { + +} + +} // namespace clusters +} // namespace app +} // namespace chip diff --git a/zzz_generated/lighting-app/zap-generated/cluster_objects_commands.h b/zzz_generated/lighting-app/zap-generated/cluster_objects_commands.h new file mode 100644 index 00000000000000..3ef2b7220f4841 --- /dev/null +++ b/zzz_generated/lighting-app/zap-generated/cluster_objects_commands.h @@ -0,0 +1,40 @@ +/* + * + * 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 + +#pragma once + +#include +#include +#include +#include +#include +#include + +namespace chip { +namespace app { +namespace clusters { + +// OnOff Cluster Commands +namespace OnOff { + +} // namespace OnOff + +} // namespace clusters +} // namespace app +} // namespace chip diff --git a/zzz_generated/lock-app/zap-generated/cluster_objects_commands.cpp b/zzz_generated/lock-app/zap-generated/cluster_objects_commands.cpp new file mode 100644 index 00000000000000..93855c49854709 --- /dev/null +++ b/zzz_generated/lock-app/zap-generated/cluster_objects_commands.cpp @@ -0,0 +1,32 @@ +/* + * + * 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 "cluster_objects_commands.h" + +#include + +#pragma GCC diagnostic ignored "-Wstack-usage=" + +namespace chip { +namespace app { +namespace clusters { + +} // namespace clusters +} // namespace app +} // namespace chip diff --git a/zzz_generated/lock-app/zap-generated/cluster_objects_commands.h b/zzz_generated/lock-app/zap-generated/cluster_objects_commands.h new file mode 100644 index 00000000000000..b9f9a986dc7233 --- /dev/null +++ b/zzz_generated/lock-app/zap-generated/cluster_objects_commands.h @@ -0,0 +1,35 @@ +/* + * + * 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 + +#pragma once + +#include +#include +#include +#include +#include +#include + +namespace chip { +namespace app { +namespace clusters { + +} // namespace clusters +} // namespace app +} // namespace chip diff --git a/zzz_generated/ota-provider-app/zap-generated/cluster_objects_commands.cpp b/zzz_generated/ota-provider-app/zap-generated/cluster_objects_commands.cpp new file mode 100644 index 00000000000000..93855c49854709 --- /dev/null +++ b/zzz_generated/ota-provider-app/zap-generated/cluster_objects_commands.cpp @@ -0,0 +1,32 @@ +/* + * + * 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 "cluster_objects_commands.h" + +#include + +#pragma GCC diagnostic ignored "-Wstack-usage=" + +namespace chip { +namespace app { +namespace clusters { + +} // namespace clusters +} // namespace app +} // namespace chip diff --git a/zzz_generated/ota-provider-app/zap-generated/cluster_objects_commands.h b/zzz_generated/ota-provider-app/zap-generated/cluster_objects_commands.h new file mode 100644 index 00000000000000..b9f9a986dc7233 --- /dev/null +++ b/zzz_generated/ota-provider-app/zap-generated/cluster_objects_commands.h @@ -0,0 +1,35 @@ +/* + * + * 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 + +#pragma once + +#include +#include +#include +#include +#include +#include + +namespace chip { +namespace app { +namespace clusters { + +} // namespace clusters +} // namespace app +} // namespace chip diff --git a/zzz_generated/ota-requestor-app/zap-generated/CHIPClusters.cpp b/zzz_generated/ota-requestor-app/zap-generated/CHIPClusters.cpp index 14db328cf47c0c..261fc6f471d704 100644 --- a/zzz_generated/ota-requestor-app/zap-generated/CHIPClusters.cpp +++ b/zzz_generated/ota-requestor-app/zap-generated/CHIPClusters.cpp @@ -21,20 +21,28 @@ #include +#include #include +#include +#include #include #include #include +#include #include +#include #include #include #include #include #include +#include namespace chip { +using namespace app; using namespace app::Clusters; +using namespace app::clusters; using namespace System; using namespace Encoding::LittleEndian; @@ -44,15 +52,49 @@ namespace Controller { // TODO(#4503): length should be passed to commands when byte string is in argument list. // TODO(#4503): Commands should take group id as an argument. +namespace { +void onClusterObjectCommandSenderFinal(CommandSender * sender, + app::ClusterObjectCommandSenderCallback * _this) +{ + Platform::Delete(sender); + Platform::Delete(_this); +} +} // namespace + // OtaSoftwareUpdateProvider Cluster Commands +CHIP_ERROR OtaSoftwareUpdateProviderCluster::ApplyUpdateRequest( + OnApplyUpdateRequestCommandResponseCallbackFunct onSuccess, OnCommandErrorCallbackFunct onFailure, + const app::clusters::OtaSoftwareUpdateProvider::ApplyUpdateRequestCommandParams::Type & params) +{ + using ResponseCallbackType = clusters::OtaSoftwareUpdateProvider::ApplyUpdateRequestResponseCommandParams::Type; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, + OtaSoftwareUpdateProvider::Commands::Ids::ApplyUpdateRequest, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR OtaSoftwareUpdateProviderCluster::ApplyUpdateRequest(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, chip::ByteSpan updateToken, uint32_t newVersion) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -64,8 +106,11 @@ CHIP_ERROR OtaSoftwareUpdateProviderCluster::ApplyUpdateRequest(Callback::Cancel OtaSoftwareUpdateProvider::Commands::Ids::ApplyUpdateRequest, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -77,27 +122,50 @@ CHIP_ERROR OtaSoftwareUpdateProviderCluster::ApplyUpdateRequest(Callback::Cancel SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR OtaSoftwareUpdateProviderCluster::NotifyUpdateApplied( + OnNotifyUpdateAppliedCommandResponseCallbackFunct onSuccess, OnCommandErrorCallbackFunct onFailure, + const app::clusters::OtaSoftwareUpdateProvider::NotifyUpdateAppliedCommandParams::Type & params) +{ + using ResponseCallbackType = void; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, + OtaSoftwareUpdateProvider::Commands::Ids::NotifyUpdateApplied, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR OtaSoftwareUpdateProviderCluster::NotifyUpdateApplied(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, chip::ByteSpan updateToken, uint32_t currentVersion) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -109,8 +177,11 @@ CHIP_ERROR OtaSoftwareUpdateProviderCluster::NotifyUpdateApplied(Callback::Cance OtaSoftwareUpdateProvider::Commands::Ids::NotifyUpdateApplied, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -122,19 +193,44 @@ CHIP_ERROR OtaSoftwareUpdateProviderCluster::NotifyUpdateApplied(Callback::Cance SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR +OtaSoftwareUpdateProviderCluster::QueryImage(OnQueryImageCommandResponseCallbackFunct onSuccess, + OnCommandErrorCallbackFunct onFailure, + const app::clusters::OtaSoftwareUpdateProvider::QueryImageCommandParams::Type & params) +{ + using ResponseCallbackType = clusters::OtaSoftwareUpdateProvider::QueryImageResponseCommandParams::Type; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, + OtaSoftwareUpdateProvider::Commands::Ids::QueryImage, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR OtaSoftwareUpdateProviderCluster::QueryImage(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t vendorId, uint16_t productId, uint16_t imageType, uint16_t hardwareVersion, @@ -142,10 +238,9 @@ CHIP_ERROR OtaSoftwareUpdateProviderCluster::QueryImage(Callback::Cancelable * o chip::ByteSpan location, bool requestorCanConsent, chip::ByteSpan metadataForProvider) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -157,8 +252,11 @@ CHIP_ERROR OtaSoftwareUpdateProviderCluster::QueryImage(Callback::Cancelable * o OtaSoftwareUpdateProvider::Commands::Ids::QueryImage, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -184,16 +282,14 @@ CHIP_ERROR OtaSoftwareUpdateProviderCluster::QueryImage(Callback::Cancelable * o SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } diff --git a/zzz_generated/ota-requestor-app/zap-generated/CHIPClusters.h b/zzz_generated/ota-requestor-app/zap-generated/CHIPClusters.h index d583ad2950dcfa..baf7935551756c 100644 --- a/zzz_generated/ota-requestor-app/zap-generated/CHIPClusters.h +++ b/zzz_generated/ota-requestor-app/zap-generated/CHIPClusters.h @@ -23,10 +23,14 @@ #include #include +#include + #include #include #include +#include + namespace chip { namespace Controller { @@ -46,6 +50,20 @@ class DLL_EXPORT OtaSoftwareUpdateProviderCluster : public ClusterBase uint8_t protocolsSupported, chip::ByteSpan location, bool requestorCanConsent, chip::ByteSpan metadataForProvider); + // Cluster Commands (Cluster Object Implementation) + using OnCommandErrorCallbackFunct = std::function; + using OnApplyUpdateRequestCommandResponseCallbackFunct = + std::function; + CHIP_ERROR ApplyUpdateRequest(OnApplyUpdateRequestCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::OtaSoftwareUpdateProvider::ApplyUpdateRequestCommandParams::Type & params); + using OnNotifyUpdateAppliedCommandResponseCallbackFunct = std::function; + CHIP_ERROR NotifyUpdateApplied(OnNotifyUpdateAppliedCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::OtaSoftwareUpdateProvider::NotifyUpdateAppliedCommandParams::Type & params); + using OnQueryImageCommandResponseCallbackFunct = + std::function; + CHIP_ERROR QueryImage(OnQueryImageCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::OtaSoftwareUpdateProvider::QueryImageCommandParams::Type & params); + // Cluster Attributes CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); diff --git a/zzz_generated/ota-requestor-app/zap-generated/cluster_objects_commands.cpp b/zzz_generated/ota-requestor-app/zap-generated/cluster_objects_commands.cpp new file mode 100644 index 00000000000000..2545d861dfe9cf --- /dev/null +++ b/zzz_generated/ota-requestor-app/zap-generated/cluster_objects_commands.cpp @@ -0,0 +1,95 @@ +/* + * + * 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 "cluster_objects_commands.h" + +#include + +#pragma GCC diagnostic ignored "-Wstack-usage=" + +namespace chip { +namespace app { +namespace clusters { + +namespace OtaSoftwareUpdateProvider { +namespace ApplyUpdateRequestCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kUpdateTokenFieldId), updateToken)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kNewVersionFieldId), newVersion)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace ApplyUpdateRequestCommandParams +namespace NotifyUpdateAppliedCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kUpdateTokenFieldId), updateToken)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kCurrentVersionFieldId), currentVersion)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace NotifyUpdateAppliedCommandParams +namespace QueryImageCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kVendorIdFieldId), vendorId)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kProductIdFieldId), productId)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kImageTypeFieldId), imageType)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kHardwareVersionFieldId), hardwareVersion)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kCurrentVersionFieldId), currentVersion)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kProtocolsSupportedFieldId), protocolsSupported)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kLocationFieldId), location)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kRequestorCanConsentFieldId), requestorCanConsent)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kMetadataForProviderFieldId), metadataForProvider)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace QueryImageCommandParams + +namespace ApplyUpdateRequestResponseCommandParams { +CHIP_ERROR Type::Decode(TLV::TLVReader & reader) +{ + return CHIP_ERROR_NOT_IMPLEMENTED; +} +} // namespace ApplyUpdateRequestResponseCommandParams +namespace QueryImageResponseCommandParams { +CHIP_ERROR Type::Decode(TLV::TLVReader & reader) +{ + return CHIP_ERROR_NOT_IMPLEMENTED; +} +} // namespace QueryImageResponseCommandParams + +} // namespace OtaSoftwareUpdateProvider + +} // namespace clusters +} // namespace app +} // namespace chip diff --git a/zzz_generated/ota-requestor-app/zap-generated/cluster_objects_commands.h b/zzz_generated/ota-requestor-app/zap-generated/cluster_objects_commands.h new file mode 100644 index 00000000000000..27db1ef87042b2 --- /dev/null +++ b/zzz_generated/ota-requestor-app/zap-generated/cluster_objects_commands.h @@ -0,0 +1,139 @@ +/* + * + * 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 + +#pragma once + +#include +#include +#include +#include +#include +#include + +namespace chip { +namespace app { +namespace clusters { + +// OtaSoftwareUpdateProvider Cluster Commands +namespace OtaSoftwareUpdateProvider { + +namespace ApplyUpdateRequestCommandParams { +enum FieldId +{ + kUpdateTokenFieldId = 0, + kNewVersionFieldId = 1, +}; + +struct Type +{ +public: + chip::ByteSpan updateToken; + uint32_t newVersion; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace ApplyUpdateRequestCommandParams +namespace NotifyUpdateAppliedCommandParams { +enum FieldId +{ + kUpdateTokenFieldId = 0, + kCurrentVersionFieldId = 1, +}; + +struct Type +{ +public: + chip::ByteSpan updateToken; + uint32_t currentVersion; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace NotifyUpdateAppliedCommandParams +namespace QueryImageCommandParams { +enum FieldId +{ + kVendorIdFieldId = 0, + kProductIdFieldId = 1, + kImageTypeFieldId = 2, + kHardwareVersionFieldId = 3, + kCurrentVersionFieldId = 4, + kProtocolsSupportedFieldId = 5, + kLocationFieldId = 6, + kRequestorCanConsentFieldId = 7, + kMetadataForProviderFieldId = 8, +}; + +struct Type +{ +public: + uint16_t vendorId; + uint16_t productId; + uint16_t imageType; + uint16_t hardwareVersion; + uint32_t currentVersion; + OTADownloadProtocol protocolsSupported; + Span location; + bool requestorCanConsent; + chip::ByteSpan metadataForProvider; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace QueryImageCommandParams + +namespace ApplyUpdateRequestResponseCommandParams { +enum FieldId +{ + kActionFieldId = 0, + kDelayedActionTimeFieldId = 1, +}; + +struct Type +{ +public: + // TODO + + CHIP_ERROR Decode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace ApplyUpdateRequestResponseCommandParams +namespace QueryImageResponseCommandParams { +enum FieldId +{ + kStatusFieldId = 0, + kDelayedActionTimeFieldId = 1, + kImageURIFieldId = 2, + kSoftwareVersionFieldId = 3, + kUpdateTokenFieldId = 4, + kUserConsentNeededFieldId = 5, + kMetadataForRequestorFieldId = 6, +}; + +struct Type +{ +public: + // TODO + + CHIP_ERROR Decode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace QueryImageResponseCommandParams + +} // namespace OtaSoftwareUpdateProvider + +} // namespace clusters +} // namespace app +} // namespace chip diff --git a/zzz_generated/pump-app/zap-generated/CHIPClusters.cpp b/zzz_generated/pump-app/zap-generated/CHIPClusters.cpp index 1bd21851b35b88..413fdd4cbc46fb 100644 --- a/zzz_generated/pump-app/zap-generated/CHIPClusters.cpp +++ b/zzz_generated/pump-app/zap-generated/CHIPClusters.cpp @@ -21,20 +21,28 @@ #include +#include #include +#include +#include #include #include #include +#include #include +#include #include #include #include #include #include +#include namespace chip { +using namespace app; using namespace app::Clusters; +using namespace app::clusters; using namespace System; using namespace Encoding::LittleEndian; @@ -44,6 +52,15 @@ namespace Controller { // TODO(#4503): length should be passed to commands when byte string is in argument list. // TODO(#4503): Commands should take group id as an argument. +namespace { +void onClusterObjectCommandSenderFinal(CommandSender * sender, + app::ClusterObjectCommandSenderCallback * _this) +{ + Platform::Delete(sender); + Platform::Delete(_this); +} +} // namespace + // FlowMeasurement Cluster Commands // FlowMeasurement Cluster Attributes CHIP_ERROR FlowMeasurementCluster::ReadAttributeMeasuredValue(Callback::Cancelable * onSuccessCallback, diff --git a/zzz_generated/pump-app/zap-generated/CHIPClusters.h b/zzz_generated/pump-app/zap-generated/CHIPClusters.h index 5b0a1f53a33a04..fe5441de8fc628 100644 --- a/zzz_generated/pump-app/zap-generated/CHIPClusters.h +++ b/zzz_generated/pump-app/zap-generated/CHIPClusters.h @@ -23,10 +23,14 @@ #include #include +#include + #include #include #include +#include + namespace chip { namespace Controller { diff --git a/zzz_generated/pump-app/zap-generated/cluster_objects_commands.cpp b/zzz_generated/pump-app/zap-generated/cluster_objects_commands.cpp new file mode 100644 index 00000000000000..182edac56dc5d7 --- /dev/null +++ b/zzz_generated/pump-app/zap-generated/cluster_objects_commands.cpp @@ -0,0 +1,42 @@ +/* + * + * 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 "cluster_objects_commands.h" + +#include + +#pragma GCC diagnostic ignored "-Wstack-usage=" + +namespace chip { +namespace app { +namespace clusters { + +namespace FlowMeasurement { + +} +namespace PressureMeasurement { + +} +namespace TemperatureMeasurement { + +} + +} // namespace clusters +} // namespace app +} // namespace chip diff --git a/zzz_generated/pump-app/zap-generated/cluster_objects_commands.h b/zzz_generated/pump-app/zap-generated/cluster_objects_commands.h new file mode 100644 index 00000000000000..622f49fa6feffb --- /dev/null +++ b/zzz_generated/pump-app/zap-generated/cluster_objects_commands.h @@ -0,0 +1,50 @@ +/* + * + * 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 + +#pragma once + +#include +#include +#include +#include +#include +#include + +namespace chip { +namespace app { +namespace clusters { + +// FlowMeasurement Cluster Commands +namespace FlowMeasurement { + +} // namespace FlowMeasurement + +// PressureMeasurement Cluster Commands +namespace PressureMeasurement { + +} // namespace PressureMeasurement + +// TemperatureMeasurement Cluster Commands +namespace TemperatureMeasurement { + +} // namespace TemperatureMeasurement + +} // namespace clusters +} // namespace app +} // namespace chip diff --git a/zzz_generated/pump-controller-app/zap-generated/CHIPClusters.cpp b/zzz_generated/pump-controller-app/zap-generated/CHIPClusters.cpp index 9e87b2bbc094e2..99339b5004b808 100644 --- a/zzz_generated/pump-controller-app/zap-generated/CHIPClusters.cpp +++ b/zzz_generated/pump-controller-app/zap-generated/CHIPClusters.cpp @@ -21,20 +21,28 @@ #include +#include #include +#include +#include #include #include #include +#include #include +#include #include #include #include #include #include +#include namespace chip { +using namespace app; using namespace app::Clusters; +using namespace app::clusters; using namespace System; using namespace Encoding::LittleEndian; @@ -44,6 +52,15 @@ namespace Controller { // TODO(#4503): length should be passed to commands when byte string is in argument list. // TODO(#4503): Commands should take group id as an argument. +namespace { +void onClusterObjectCommandSenderFinal(CommandSender * sender, + app::ClusterObjectCommandSenderCallback * _this) +{ + Platform::Delete(sender); + Platform::Delete(_this); +} +} // namespace + // FlowMeasurement Cluster Commands // FlowMeasurement Cluster Attributes CHIP_ERROR FlowMeasurementCluster::ReadAttributeMeasuredValue(Callback::Cancelable * onSuccessCallback, @@ -114,13 +131,36 @@ CHIP_ERROR FlowMeasurementCluster::ReadAttributeClusterRevision(Callback::Cancel } // LevelControl Cluster Commands +CHIP_ERROR LevelControlCluster::Move(OnMoveCommandResponseCallbackFunct onSuccess, OnCommandErrorCallbackFunct onFailure, + const app::clusters::LevelControl::MoveCommandParams::Type & params) +{ + using ResponseCallbackType = void; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, LevelControl::Commands::Ids::Move, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR LevelControlCluster::Move(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint8_t moveMode, uint8_t rate, uint8_t optionMask, uint8_t optionOverride) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -131,8 +171,11 @@ CHIP_ERROR LevelControlCluster::Move(Callback::Cancelable * onSuccessCallback, C app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, LevelControl::Commands::Ids::Move, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -148,26 +191,48 @@ CHIP_ERROR LevelControlCluster::Move(Callback::Cancelable * onSuccessCallback, C SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR LevelControlCluster::MoveToLevel(OnMoveToLevelCommandResponseCallbackFunct onSuccess, + OnCommandErrorCallbackFunct onFailure, + const app::clusters::LevelControl::MoveToLevelCommandParams::Type & params) +{ + using ResponseCallbackType = void; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, LevelControl::Commands::Ids::MoveToLevel, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR LevelControlCluster::MoveToLevel(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint8_t level, uint16_t transitionTime, uint8_t optionMask, uint8_t optionOverride) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -178,8 +243,11 @@ CHIP_ERROR LevelControlCluster::MoveToLevel(Callback::Cancelable * onSuccessCall app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, LevelControl::Commands::Ids::MoveToLevel, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -195,27 +263,50 @@ CHIP_ERROR LevelControlCluster::MoveToLevel(Callback::Cancelable * onSuccessCall SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR +LevelControlCluster::MoveToLevelWithOnOff(OnMoveToLevelWithOnOffCommandResponseCallbackFunct onSuccess, + OnCommandErrorCallbackFunct onFailure, + const app::clusters::LevelControl::MoveToLevelWithOnOffCommandParams::Type & params) +{ + using ResponseCallbackType = void; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, LevelControl::Commands::Ids::MoveToLevelWithOnOff, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR LevelControlCluster::MoveToLevelWithOnOff(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint8_t level, uint16_t transitionTime) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -226,8 +317,11 @@ CHIP_ERROR LevelControlCluster::MoveToLevelWithOnOff(Callback::Cancelable * onSu app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, LevelControl::Commands::Ids::MoveToLevelWithOnOff, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -239,26 +333,48 @@ CHIP_ERROR LevelControlCluster::MoveToLevelWithOnOff(Callback::Cancelable * onSu SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR LevelControlCluster::MoveWithOnOff(OnMoveWithOnOffCommandResponseCallbackFunct onSuccess, + OnCommandErrorCallbackFunct onFailure, + const app::clusters::LevelControl::MoveWithOnOffCommandParams::Type & params) +{ + using ResponseCallbackType = void; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, LevelControl::Commands::Ids::MoveWithOnOff, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR LevelControlCluster::MoveWithOnOff(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint8_t moveMode, uint8_t rate) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -269,8 +385,11 @@ CHIP_ERROR LevelControlCluster::MoveWithOnOff(Callback::Cancelable * onSuccessCa app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, LevelControl::Commands::Ids::MoveWithOnOff, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -282,27 +401,48 @@ CHIP_ERROR LevelControlCluster::MoveWithOnOff(Callback::Cancelable * onSuccessCa SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR LevelControlCluster::Step(OnStepCommandResponseCallbackFunct onSuccess, OnCommandErrorCallbackFunct onFailure, + const app::clusters::LevelControl::StepCommandParams::Type & params) +{ + using ResponseCallbackType = void; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, LevelControl::Commands::Ids::Step, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR LevelControlCluster::Step(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint8_t stepMode, uint8_t stepSize, uint16_t transitionTime, uint8_t optionMask, uint8_t optionOverride) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -313,8 +453,11 @@ CHIP_ERROR LevelControlCluster::Step(Callback::Cancelable * onSuccessCallback, C app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, LevelControl::Commands::Ids::Step, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -332,26 +475,48 @@ CHIP_ERROR LevelControlCluster::Step(Callback::Cancelable * onSuccessCallback, C SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR LevelControlCluster::StepWithOnOff(OnStepWithOnOffCommandResponseCallbackFunct onSuccess, + OnCommandErrorCallbackFunct onFailure, + const app::clusters::LevelControl::StepWithOnOffCommandParams::Type & params) +{ + using ResponseCallbackType = void; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, LevelControl::Commands::Ids::StepWithOnOff, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR LevelControlCluster::StepWithOnOff(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint8_t stepMode, uint8_t stepSize, uint16_t transitionTime) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -362,8 +527,11 @@ CHIP_ERROR LevelControlCluster::StepWithOnOff(Callback::Cancelable * onSuccessCa app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, LevelControl::Commands::Ids::StepWithOnOff, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -377,26 +545,47 @@ CHIP_ERROR LevelControlCluster::StepWithOnOff(Callback::Cancelable * onSuccessCa SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR LevelControlCluster::Stop(OnStopCommandResponseCallbackFunct onSuccess, OnCommandErrorCallbackFunct onFailure, + const app::clusters::LevelControl::StopCommandParams::Type & params) +{ + using ResponseCallbackType = void; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, LevelControl::Commands::Ids::Stop, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR LevelControlCluster::Stop(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint8_t optionMask, uint8_t optionOverride) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -407,8 +596,11 @@ CHIP_ERROR LevelControlCluster::Stop(Callback::Cancelable * onSuccessCallback, C app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, LevelControl::Commands::Ids::Stop, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -420,25 +612,47 @@ CHIP_ERROR LevelControlCluster::Stop(Callback::Cancelable * onSuccessCallback, C SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR LevelControlCluster::StopWithOnOff(OnStopWithOnOffCommandResponseCallbackFunct onSuccess, + OnCommandErrorCallbackFunct onFailure, + const app::clusters::LevelControl::StopWithOnOffCommandParams::Type & params) +{ + using ResponseCallbackType = void; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, LevelControl::Commands::Ids::StopWithOnOff, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR LevelControlCluster::StopWithOnOff(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -449,8 +663,11 @@ CHIP_ERROR LevelControlCluster::StopWithOnOff(Callback::Cancelable * onSuccessCa app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, LevelControl::Commands::Ids::StopWithOnOff, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); // Command takes no arguments. @@ -458,16 +675,14 @@ CHIP_ERROR LevelControlCluster::StopWithOnOff(Callback::Cancelable * onSuccessCa SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } @@ -516,12 +731,35 @@ CHIP_ERROR LevelControlCluster::ReadAttributeClusterRevision(Callback::Cancelabl } // OnOff Cluster Commands +CHIP_ERROR OnOffCluster::Off(OnOffCommandResponseCallbackFunct onSuccess, OnCommandErrorCallbackFunct onFailure, + const app::clusters::OnOff::OffCommandParams::Type & params) +{ + using ResponseCallbackType = void; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, OnOff::Commands::Ids::Off, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR OnOffCluster::Off(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -532,8 +770,11 @@ CHIP_ERROR OnOffCluster::Off(Callback::Cancelable * onSuccessCallback, Callback: app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, OnOff::Commands::Ids::Off, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); // Command takes no arguments. @@ -541,25 +782,46 @@ CHIP_ERROR OnOffCluster::Off(Callback::Cancelable * onSuccessCallback, Callback: SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR OnOffCluster::On(OnOnCommandResponseCallbackFunct onSuccess, OnCommandErrorCallbackFunct onFailure, + const app::clusters::OnOff::OnCommandParams::Type & params) +{ + using ResponseCallbackType = void; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, OnOff::Commands::Ids::On, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR OnOffCluster::On(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -570,8 +832,11 @@ CHIP_ERROR OnOffCluster::On(Callback::Cancelable * onSuccessCallback, Callback:: app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, OnOff::Commands::Ids::On, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); // Command takes no arguments. @@ -579,25 +844,46 @@ CHIP_ERROR OnOffCluster::On(Callback::Cancelable * onSuccessCallback, Callback:: SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR OnOffCluster::Toggle(OnToggleCommandResponseCallbackFunct onSuccess, OnCommandErrorCallbackFunct onFailure, + const app::clusters::OnOff::ToggleCommandParams::Type & params) +{ + using ResponseCallbackType = void; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, OnOff::Commands::Ids::Toggle, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR OnOffCluster::Toggle(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -608,8 +894,11 @@ CHIP_ERROR OnOffCluster::Toggle(Callback::Cancelable * onSuccessCallback, Callba app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, OnOff::Commands::Ids::Toggle, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); // Command takes no arguments. @@ -617,16 +906,14 @@ CHIP_ERROR OnOffCluster::Toggle(Callback::Cancelable * onSuccessCallback, Callba SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } diff --git a/zzz_generated/pump-controller-app/zap-generated/CHIPClusters.h b/zzz_generated/pump-controller-app/zap-generated/CHIPClusters.h index b8a4ade7078f54..53dad1095ac631 100644 --- a/zzz_generated/pump-controller-app/zap-generated/CHIPClusters.h +++ b/zzz_generated/pump-controller-app/zap-generated/CHIPClusters.h @@ -23,10 +23,14 @@ #include #include +#include + #include #include #include +#include + namespace chip { namespace Controller { @@ -69,6 +73,33 @@ class DLL_EXPORT LevelControlCluster : public ClusterBase uint8_t optionOverride); CHIP_ERROR StopWithOnOff(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + // Cluster Commands (Cluster Object Implementation) + using OnCommandErrorCallbackFunct = std::function; + using OnMoveCommandResponseCallbackFunct = std::function; + CHIP_ERROR Move(OnMoveCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::LevelControl::MoveCommandParams::Type & params); + using OnMoveToLevelCommandResponseCallbackFunct = std::function; + CHIP_ERROR MoveToLevel(OnMoveToLevelCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::LevelControl::MoveToLevelCommandParams::Type & params); + using OnMoveToLevelWithOnOffCommandResponseCallbackFunct = std::function; + CHIP_ERROR MoveToLevelWithOnOff(OnMoveToLevelWithOnOffCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::LevelControl::MoveToLevelWithOnOffCommandParams::Type & params); + using OnMoveWithOnOffCommandResponseCallbackFunct = std::function; + CHIP_ERROR MoveWithOnOff(OnMoveWithOnOffCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::LevelControl::MoveWithOnOffCommandParams::Type & params); + using OnStepCommandResponseCallbackFunct = std::function; + CHIP_ERROR Step(OnStepCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::LevelControl::StepCommandParams::Type & params); + using OnStepWithOnOffCommandResponseCallbackFunct = std::function; + CHIP_ERROR StepWithOnOff(OnStepWithOnOffCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::LevelControl::StepWithOnOffCommandParams::Type & params); + using OnStopCommandResponseCallbackFunct = std::function; + CHIP_ERROR Stop(OnStopCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::LevelControl::StopCommandParams::Type & params); + using OnStopWithOnOffCommandResponseCallbackFunct = std::function; + CHIP_ERROR StopWithOnOff(OnStopWithOnOffCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::LevelControl::StopWithOnOffCommandParams::Type & params); + // Cluster Attributes CHIP_ERROR ReadAttributeCurrentLevel(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); @@ -90,6 +121,18 @@ class DLL_EXPORT OnOffCluster : public ClusterBase CHIP_ERROR On(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR Toggle(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + // Cluster Commands (Cluster Object Implementation) + using OnCommandErrorCallbackFunct = std::function; + using OnOffCommandResponseCallbackFunct = std::function; + CHIP_ERROR Off(OnOffCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::OnOff::OffCommandParams::Type & params); + using OnOnCommandResponseCallbackFunct = std::function; + CHIP_ERROR On(OnOnCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::OnOff::OnCommandParams::Type & params); + using OnToggleCommandResponseCallbackFunct = std::function; + CHIP_ERROR Toggle(OnToggleCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::OnOff::ToggleCommandParams::Type & params); + // Cluster Attributes CHIP_ERROR ReadAttributeOnOff(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); diff --git a/zzz_generated/pump-controller-app/zap-generated/cluster_objects_commands.cpp b/zzz_generated/pump-controller-app/zap-generated/cluster_objects_commands.cpp new file mode 100644 index 00000000000000..2cb9e0dffe5008 --- /dev/null +++ b/zzz_generated/pump-controller-app/zap-generated/cluster_objects_commands.cpp @@ -0,0 +1,194 @@ +/* + * + * 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 "cluster_objects_commands.h" + +#include + +#pragma GCC diagnostic ignored "-Wstack-usage=" + +namespace chip { +namespace app { +namespace clusters { + +namespace FlowMeasurement { + +} +namespace LevelControl { +namespace MoveCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kMoveModeFieldId), moveMode)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kRateFieldId), rate)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kOptionMaskFieldId), optionMask)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kOptionOverrideFieldId), optionOverride)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace MoveCommandParams +namespace MoveToLevelCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kLevelFieldId), level)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kTransitionTimeFieldId), transitionTime)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kOptionMaskFieldId), optionMask)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kOptionOverrideFieldId), optionOverride)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace MoveToLevelCommandParams +namespace MoveToLevelWithOnOffCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kLevelFieldId), level)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kTransitionTimeFieldId), transitionTime)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace MoveToLevelWithOnOffCommandParams +namespace MoveWithOnOffCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kMoveModeFieldId), moveMode)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kRateFieldId), rate)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace MoveWithOnOffCommandParams +namespace StepCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kStepModeFieldId), stepMode)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kStepSizeFieldId), stepSize)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kTransitionTimeFieldId), transitionTime)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kOptionMaskFieldId), optionMask)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kOptionOverrideFieldId), optionOverride)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace StepCommandParams +namespace StepWithOnOffCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kStepModeFieldId), stepMode)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kStepSizeFieldId), stepSize)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kTransitionTimeFieldId), transitionTime)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace StepWithOnOffCommandParams +namespace StopCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kOptionMaskFieldId), optionMask)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kOptionOverrideFieldId), optionOverride)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace StopCommandParams +namespace StopWithOnOffCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace StopWithOnOffCommandParams + +} // namespace LevelControl +namespace OnOff { +namespace OffCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace OffCommandParams +namespace OnCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace OnCommandParams +namespace ToggleCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace ToggleCommandParams + +} // namespace OnOff +namespace PressureMeasurement { + +} +namespace PumpConfigurationAndControl { + +} +namespace TemperatureMeasurement { + +} + +} // namespace clusters +} // namespace app +} // namespace chip diff --git a/zzz_generated/pump-controller-app/zap-generated/cluster_objects_commands.h b/zzz_generated/pump-controller-app/zap-generated/cluster_objects_commands.h new file mode 100644 index 00000000000000..cb96dfb5727d17 --- /dev/null +++ b/zzz_generated/pump-controller-app/zap-generated/cluster_objects_commands.h @@ -0,0 +1,239 @@ +/* + * + * 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 + +#pragma once + +#include +#include +#include +#include +#include +#include + +namespace chip { +namespace app { +namespace clusters { + +// FlowMeasurement Cluster Commands +namespace FlowMeasurement { + +} // namespace FlowMeasurement + +// LevelControl Cluster Commands +namespace LevelControl { + +namespace MoveCommandParams { +enum FieldId +{ + kMoveModeFieldId = 0, + kRateFieldId = 1, + kOptionMaskFieldId = 2, + kOptionOverrideFieldId = 3, +}; + +struct Type +{ +public: + MoveMode moveMode; + uint8_t rate; + uint8_t optionMask; + uint8_t optionOverride; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace MoveCommandParams +namespace MoveToLevelCommandParams { +enum FieldId +{ + kLevelFieldId = 0, + kTransitionTimeFieldId = 1, + kOptionMaskFieldId = 2, + kOptionOverrideFieldId = 3, +}; + +struct Type +{ +public: + uint8_t level; + uint16_t transitionTime; + uint8_t optionMask; + uint8_t optionOverride; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace MoveToLevelCommandParams +namespace MoveToLevelWithOnOffCommandParams { +enum FieldId +{ + kLevelFieldId = 0, + kTransitionTimeFieldId = 1, +}; + +struct Type +{ +public: + uint8_t level; + uint16_t transitionTime; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace MoveToLevelWithOnOffCommandParams +namespace MoveWithOnOffCommandParams { +enum FieldId +{ + kMoveModeFieldId = 0, + kRateFieldId = 1, +}; + +struct Type +{ +public: + MoveMode moveMode; + uint8_t rate; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace MoveWithOnOffCommandParams +namespace StepCommandParams { +enum FieldId +{ + kStepModeFieldId = 0, + kStepSizeFieldId = 1, + kTransitionTimeFieldId = 2, + kOptionMaskFieldId = 3, + kOptionOverrideFieldId = 4, +}; + +struct Type +{ +public: + StepMode stepMode; + uint8_t stepSize; + uint16_t transitionTime; + uint8_t optionMask; + uint8_t optionOverride; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace StepCommandParams +namespace StepWithOnOffCommandParams { +enum FieldId +{ + kStepModeFieldId = 0, + kStepSizeFieldId = 1, + kTransitionTimeFieldId = 2, +}; + +struct Type +{ +public: + StepMode stepMode; + uint8_t stepSize; + uint16_t transitionTime; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace StepWithOnOffCommandParams +namespace StopCommandParams { +enum FieldId +{ + kOptionMaskFieldId = 0, + kOptionOverrideFieldId = 1, +}; + +struct Type +{ +public: + uint8_t optionMask; + uint8_t optionOverride; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace StopCommandParams +namespace StopWithOnOffCommandParams { +enum FieldId +{ +}; + +struct Type +{ +public: + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace StopWithOnOffCommandParams + +} // namespace LevelControl + +// OnOff Cluster Commands +namespace OnOff { + +namespace OffCommandParams { +enum FieldId +{ +}; + +struct Type +{ +public: + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace OffCommandParams +namespace OnCommandParams { +enum FieldId +{ +}; + +struct Type +{ +public: + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace OnCommandParams +namespace ToggleCommandParams { +enum FieldId +{ +}; + +struct Type +{ +public: + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace ToggleCommandParams + +} // namespace OnOff + +// PressureMeasurement Cluster Commands +namespace PressureMeasurement { + +} // namespace PressureMeasurement + +// PumpConfigurationAndControl Cluster Commands +namespace PumpConfigurationAndControl { + +} // namespace PumpConfigurationAndControl + +// TemperatureMeasurement Cluster Commands +namespace TemperatureMeasurement { + +} // namespace TemperatureMeasurement + +} // namespace clusters +} // namespace app +} // namespace chip diff --git a/zzz_generated/temperature-measurement-app/zap-generated/cluster_objects_commands.cpp b/zzz_generated/temperature-measurement-app/zap-generated/cluster_objects_commands.cpp new file mode 100644 index 00000000000000..93855c49854709 --- /dev/null +++ b/zzz_generated/temperature-measurement-app/zap-generated/cluster_objects_commands.cpp @@ -0,0 +1,32 @@ +/* + * + * 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 "cluster_objects_commands.h" + +#include + +#pragma GCC diagnostic ignored "-Wstack-usage=" + +namespace chip { +namespace app { +namespace clusters { + +} // namespace clusters +} // namespace app +} // namespace chip diff --git a/zzz_generated/temperature-measurement-app/zap-generated/cluster_objects_commands.h b/zzz_generated/temperature-measurement-app/zap-generated/cluster_objects_commands.h new file mode 100644 index 00000000000000..b9f9a986dc7233 --- /dev/null +++ b/zzz_generated/temperature-measurement-app/zap-generated/cluster_objects_commands.h @@ -0,0 +1,35 @@ +/* + * + * 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 + +#pragma once + +#include +#include +#include +#include +#include +#include + +namespace chip { +namespace app { +namespace clusters { + +} // namespace clusters +} // namespace app +} // namespace chip diff --git a/zzz_generated/thermostat/zap-generated/cluster_objects_commands.cpp b/zzz_generated/thermostat/zap-generated/cluster_objects_commands.cpp new file mode 100644 index 00000000000000..93855c49854709 --- /dev/null +++ b/zzz_generated/thermostat/zap-generated/cluster_objects_commands.cpp @@ -0,0 +1,32 @@ +/* + * + * 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 "cluster_objects_commands.h" + +#include + +#pragma GCC diagnostic ignored "-Wstack-usage=" + +namespace chip { +namespace app { +namespace clusters { + +} // namespace clusters +} // namespace app +} // namespace chip diff --git a/zzz_generated/thermostat/zap-generated/cluster_objects_commands.h b/zzz_generated/thermostat/zap-generated/cluster_objects_commands.h new file mode 100644 index 00000000000000..b9f9a986dc7233 --- /dev/null +++ b/zzz_generated/thermostat/zap-generated/cluster_objects_commands.h @@ -0,0 +1,35 @@ +/* + * + * 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 + +#pragma once + +#include +#include +#include +#include +#include +#include + +namespace chip { +namespace app { +namespace clusters { + +} // namespace clusters +} // namespace app +} // namespace chip diff --git a/zzz_generated/tv-app/zap-generated/CHIPClusters.cpp b/zzz_generated/tv-app/zap-generated/CHIPClusters.cpp index 6169ae7777b2a6..464fa1bc6008de 100644 --- a/zzz_generated/tv-app/zap-generated/CHIPClusters.cpp +++ b/zzz_generated/tv-app/zap-generated/CHIPClusters.cpp @@ -21,20 +21,28 @@ #include +#include #include +#include +#include #include #include #include +#include #include +#include #include #include #include #include #include +#include namespace chip { +using namespace app; using namespace app::Clusters; +using namespace app::clusters; using namespace System; using namespace Encoding::LittleEndian; @@ -44,15 +52,48 @@ namespace Controller { // TODO(#4503): length should be passed to commands when byte string is in argument list. // TODO(#4503): Commands should take group id as an argument. +namespace { +void onClusterObjectCommandSenderFinal(CommandSender * sender, + app::ClusterObjectCommandSenderCallback * _this) +{ + Platform::Delete(sender); + Platform::Delete(_this); +} +} // namespace + // GeneralCommissioning Cluster Commands +CHIP_ERROR +GeneralCommissioningCluster::ArmFailSafe(OnArmFailSafeCommandResponseCallbackFunct onSuccess, OnCommandErrorCallbackFunct onFailure, + const app::clusters::GeneralCommissioning::ArmFailSafeCommandParams::Type & params) +{ + using ResponseCallbackType = clusters::GeneralCommissioning::ArmFailSafeResponseCommandParams::Type; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, GeneralCommissioning::Commands::Ids::ArmFailSafe, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR GeneralCommissioningCluster::ArmFailSafe(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t expiryLengthSeconds, uint64_t breadcrumb, uint32_t timeoutMs) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -63,8 +104,11 @@ CHIP_ERROR GeneralCommissioningCluster::ArmFailSafe(Callback::Cancelable * onSuc app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, GeneralCommissioning::Commands::Ids::ArmFailSafe, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -78,26 +122,49 @@ CHIP_ERROR GeneralCommissioningCluster::ArmFailSafe(Callback::Cancelable * onSuc SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR GeneralCommissioningCluster::CommissioningComplete( + OnCommissioningCompleteCommandResponseCallbackFunct onSuccess, OnCommandErrorCallbackFunct onFailure, + const app::clusters::GeneralCommissioning::CommissioningCompleteCommandParams::Type & params) +{ + using ResponseCallbackType = clusters::GeneralCommissioning::CommissioningCompleteResponseCommandParams::Type; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, + GeneralCommissioning::Commands::Ids::CommissioningComplete, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR GeneralCommissioningCluster::CommissioningComplete(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -109,8 +176,11 @@ CHIP_ERROR GeneralCommissioningCluster::CommissioningComplete(Callback::Cancelab GeneralCommissioning::Commands::Ids::CommissioningComplete, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); // Command takes no arguments. @@ -118,27 +188,50 @@ CHIP_ERROR GeneralCommissioningCluster::CommissioningComplete(Callback::Cancelab SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR GeneralCommissioningCluster::SetRegulatoryConfig( + OnSetRegulatoryConfigCommandResponseCallbackFunct onSuccess, OnCommandErrorCallbackFunct onFailure, + const app::clusters::GeneralCommissioning::SetRegulatoryConfigCommandParams::Type & params) +{ + using ResponseCallbackType = clusters::GeneralCommissioning::SetRegulatoryConfigResponseCommandParams::Type; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, + GeneralCommissioning::Commands::Ids::SetRegulatoryConfig, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR GeneralCommissioningCluster::SetRegulatoryConfig(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint8_t location, chip::ByteSpan countryCode, uint64_t breadcrumb, uint32_t timeoutMs) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -150,8 +243,11 @@ CHIP_ERROR GeneralCommissioningCluster::SetRegulatoryConfig(Callback::Cancelable GeneralCommissioning::Commands::Ids::SetRegulatoryConfig, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -167,16 +263,14 @@ CHIP_ERROR GeneralCommissioningCluster::SetRegulatoryConfig(Callback::Cancelable SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } @@ -235,14 +329,40 @@ CHIP_ERROR GeneralCommissioningCluster::ReadAttributeClusterRevision(Callback::C } // NetworkCommissioning Cluster Commands +CHIP_ERROR +NetworkCommissioningCluster::DisableNetwork(OnDisableNetworkCommandResponseCallbackFunct onSuccess, + OnCommandErrorCallbackFunct onFailure, + const app::clusters::NetworkCommissioning::DisableNetworkCommandParams::Type & params) +{ + using ResponseCallbackType = clusters::NetworkCommissioning::DisableNetworkResponseCommandParams::Type; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, + NetworkCommissioning::Commands::Ids::DisableNetwork, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR NetworkCommissioningCluster::DisableNetwork(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, chip::ByteSpan networkID, uint64_t breadcrumb, uint32_t timeoutMs) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -254,8 +374,11 @@ CHIP_ERROR NetworkCommissioningCluster::DisableNetwork(Callback::Cancelable * on NetworkCommissioning::Commands::Ids::DisableNetwork, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -269,27 +392,51 @@ CHIP_ERROR NetworkCommissioningCluster::DisableNetwork(Callback::Cancelable * on SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR +NetworkCommissioningCluster::EnableNetwork(OnEnableNetworkCommandResponseCallbackFunct onSuccess, + OnCommandErrorCallbackFunct onFailure, + const app::clusters::NetworkCommissioning::EnableNetworkCommandParams::Type & params) +{ + using ResponseCallbackType = clusters::NetworkCommissioning::EnableNetworkResponseCommandParams::Type; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, + NetworkCommissioning::Commands::Ids::EnableNetwork, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR NetworkCommissioningCluster::EnableNetwork(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, chip::ByteSpan networkID, uint64_t breadcrumb, uint32_t timeoutMs) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -301,8 +448,11 @@ CHIP_ERROR NetworkCommissioningCluster::EnableNetwork(Callback::Cancelable * onS NetworkCommissioning::Commands::Ids::EnableNetwork, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -316,27 +466,50 @@ CHIP_ERROR NetworkCommissioningCluster::EnableNetwork(Callback::Cancelable * onS SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR NetworkCommissioningCluster::GetLastNetworkCommissioningResult( + OnGetLastNetworkCommissioningResultCommandResponseCallbackFunct onSuccess, OnCommandErrorCallbackFunct onFailure, + const app::clusters::NetworkCommissioning::GetLastNetworkCommissioningResultCommandParams::Type & params) +{ + using ResponseCallbackType = void; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, + NetworkCommissioning::Commands::Ids::GetLastNetworkCommissioningResult, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR NetworkCommissioningCluster::GetLastNetworkCommissioningResult(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint32_t timeoutMs) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -348,8 +521,11 @@ CHIP_ERROR NetworkCommissioningCluster::GetLastNetworkCommissioningResult(Callba NetworkCommissioning::Commands::Ids::GetLastNetworkCommissioningResult, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -359,27 +535,51 @@ CHIP_ERROR NetworkCommissioningCluster::GetLastNetworkCommissioningResult(Callba SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR +NetworkCommissioningCluster::RemoveNetwork(OnRemoveNetworkCommandResponseCallbackFunct onSuccess, + OnCommandErrorCallbackFunct onFailure, + const app::clusters::NetworkCommissioning::RemoveNetworkCommandParams::Type & params) +{ + using ResponseCallbackType = clusters::NetworkCommissioning::RemoveNetworkResponseCommandParams::Type; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, + NetworkCommissioning::Commands::Ids::RemoveNetwork, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR NetworkCommissioningCluster::RemoveNetwork(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, chip::ByteSpan networkID, uint64_t breadcrumb, uint32_t timeoutMs) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -391,8 +591,11 @@ CHIP_ERROR NetworkCommissioningCluster::RemoveNetwork(Callback::Cancelable * onS NetworkCommissioning::Commands::Ids::RemoveNetwork, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -406,27 +609,50 @@ CHIP_ERROR NetworkCommissioningCluster::RemoveNetwork(Callback::Cancelable * onS SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR +NetworkCommissioningCluster::ScanNetworks(OnScanNetworksCommandResponseCallbackFunct onSuccess, + OnCommandErrorCallbackFunct onFailure, + const app::clusters::NetworkCommissioning::ScanNetworksCommandParams::Type & params) +{ + using ResponseCallbackType = clusters::NetworkCommissioning::ScanNetworksResponseCommandParams::Type; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, NetworkCommissioning::Commands::Ids::ScanNetworks, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR NetworkCommissioningCluster::ScanNetworks(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, chip::ByteSpan ssid, uint64_t breadcrumb, uint32_t timeoutMs) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -437,8 +663,11 @@ CHIP_ERROR NetworkCommissioningCluster::ScanNetworks(Callback::Cancelable * onSu app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, NetworkCommissioning::Commands::Ids::ScanNetworks, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -452,16 +681,14 @@ CHIP_ERROR NetworkCommissioningCluster::ScanNetworks(Callback::Cancelable * onSu SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } @@ -479,14 +706,38 @@ CHIP_ERROR NetworkCommissioningCluster::ReadAttributeClusterRevision(Callback::C } // OperationalCredentials Cluster Commands +CHIP_ERROR OperationalCredentialsCluster::AddNOC(OnAddNOCCommandResponseCallbackFunct onSuccess, + OnCommandErrorCallbackFunct onFailure, + const app::clusters::OperationalCredentials::AddNOCCommandParams::Type & params) +{ + using ResponseCallbackType = clusters::OperationalCredentials::NOCResponseCommandParams::Type; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, OperationalCredentials::Commands::Ids::AddNOC, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR OperationalCredentialsCluster::AddNOC(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, chip::ByteSpan nOCValue, chip::ByteSpan iCACValue, chip::ByteSpan iPKValue, chip::NodeId caseAdminNode, uint16_t adminVendorId) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -497,8 +748,11 @@ CHIP_ERROR OperationalCredentialsCluster::AddNOC(Callback::Cancelable * onSucces app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, OperationalCredentials::Commands::Ids::AddNOC, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -516,27 +770,50 @@ CHIP_ERROR OperationalCredentialsCluster::AddNOC(Callback::Cancelable * onSucces SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR OperationalCredentialsCluster::AddTrustedRootCertificate( + OnAddTrustedRootCertificateCommandResponseCallbackFunct onSuccess, OnCommandErrorCallbackFunct onFailure, + const app::clusters::OperationalCredentials::AddTrustedRootCertificateCommandParams::Type & params) +{ + using ResponseCallbackType = void; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, + OperationalCredentials::Commands::Ids::AddTrustedRootCertificate, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR OperationalCredentialsCluster::AddTrustedRootCertificate(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, chip::ByteSpan rootCertificate) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -548,8 +825,11 @@ CHIP_ERROR OperationalCredentialsCluster::AddTrustedRootCertificate(Callback::Ca OperationalCredentials::Commands::Ids::AddTrustedRootCertificate, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -559,27 +839,50 @@ CHIP_ERROR OperationalCredentialsCluster::AddTrustedRootCertificate(Callback::Ca SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR OperationalCredentialsCluster::AttestationRequest( + OnAttestationRequestCommandResponseCallbackFunct onSuccess, OnCommandErrorCallbackFunct onFailure, + const app::clusters::OperationalCredentials::AttestationRequestCommandParams::Type & params) +{ + using ResponseCallbackType = clusters::OperationalCredentials::AttestationResponseCommandParams::Type; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, + OperationalCredentials::Commands::Ids::AttestationRequest, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR OperationalCredentialsCluster::AttestationRequest(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, chip::ByteSpan attestationNonce) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -591,8 +894,11 @@ CHIP_ERROR OperationalCredentialsCluster::AttestationRequest(Callback::Cancelabl OperationalCredentials::Commands::Ids::AttestationRequest, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -602,26 +908,49 @@ CHIP_ERROR OperationalCredentialsCluster::AttestationRequest(Callback::Cancelabl SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR OperationalCredentialsCluster::CertificateChainRequest( + OnCertificateChainRequestCommandResponseCallbackFunct onSuccess, OnCommandErrorCallbackFunct onFailure, + const app::clusters::OperationalCredentials::CertificateChainRequestCommandParams::Type & params) +{ + using ResponseCallbackType = clusters::OperationalCredentials::CertificateChainResponseCommandParams::Type; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, + OperationalCredentials::Commands::Ids::CertificateChainRequest, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR OperationalCredentialsCluster::CertificateChainRequest(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint8_t certificateType) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -633,8 +962,11 @@ CHIP_ERROR OperationalCredentialsCluster::CertificateChainRequest(Callback::Canc OperationalCredentials::Commands::Ids::CertificateChainRequest, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -644,26 +976,50 @@ CHIP_ERROR OperationalCredentialsCluster::CertificateChainRequest(Callback::Canc SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR +OperationalCredentialsCluster::OpCSRRequest(OnOpCSRRequestCommandResponseCallbackFunct onSuccess, + OnCommandErrorCallbackFunct onFailure, + const app::clusters::OperationalCredentials::OpCSRRequestCommandParams::Type & params) +{ + using ResponseCallbackType = clusters::OperationalCredentials::OpCSRResponseCommandParams::Type; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, + OperationalCredentials::Commands::Ids::OpCSRRequest, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR OperationalCredentialsCluster::OpCSRRequest(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, chip::ByteSpan cSRNonce) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -675,8 +1031,11 @@ CHIP_ERROR OperationalCredentialsCluster::OpCSRRequest(Callback::Cancelable * on OperationalCredentials::Commands::Ids::OpCSRRequest, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -686,26 +1045,50 @@ CHIP_ERROR OperationalCredentialsCluster::OpCSRRequest(Callback::Cancelable * on SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR +OperationalCredentialsCluster::RemoveFabric(OnRemoveFabricCommandResponseCallbackFunct onSuccess, + OnCommandErrorCallbackFunct onFailure, + const app::clusters::OperationalCredentials::RemoveFabricCommandParams::Type & params) +{ + using ResponseCallbackType = clusters::OperationalCredentials::NOCResponseCommandParams::Type; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, + OperationalCredentials::Commands::Ids::RemoveFabric, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR OperationalCredentialsCluster::RemoveFabric(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint8_t fabricIndex) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -717,8 +1100,11 @@ CHIP_ERROR OperationalCredentialsCluster::RemoveFabric(Callback::Cancelable * on OperationalCredentials::Commands::Ids::RemoveFabric, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -728,26 +1114,49 @@ CHIP_ERROR OperationalCredentialsCluster::RemoveFabric(Callback::Cancelable * on SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } +CHIP_ERROR OperationalCredentialsCluster::UpdateFabricLabel( + OnUpdateFabricLabelCommandResponseCallbackFunct onSuccess, OnCommandErrorCallbackFunct onFailure, + const app::clusters::OperationalCredentials::UpdateFabricLabelCommandParams::Type & params) +{ + using ResponseCallbackType = clusters::OperationalCredentials::NOCResponseCommandParams::Type; + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, + OperationalCredentials::Commands::Ids::UpdateFabricLabel, + (app::CommandPathFlags::kEndpointIdValid) }; + + auto callback = Platform::MakeUnique>( + onSuccess, + onFailure, + onClusterObjectCommandSenderFinal, + )); + + auto sender = Platform::MakeUnique(callback.get()); + + ReturnErrorOnFailure(sender->EncodeFullCommand(cmdParams, params)); + ReturnErrorOnFailure(mDevice->SendCommands(sender.get())); + + sender.release(); + callback.release(); + return CHIP_NO_ERROR; +} + CHIP_ERROR OperationalCredentialsCluster::UpdateFabricLabel(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, chip::ByteSpan label) { - CHIP_ERROR err = CHIP_NO_ERROR; - app::CommandSender * sender = nullptr; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; // Used when encoding non-empty command. Suppress error message when encoding empty commands. (void) writer; @@ -759,8 +1168,11 @@ CHIP_ERROR OperationalCredentialsCluster::UpdateFabricLabel(Callback::Cancelable OperationalCredentials::Commands::Ids::UpdateFabricLabel, (app::CommandPathFlags::kEndpointIdValid) }; - SuccessOrExit(err = app::InteractionModelEngine::GetInstance()->NewCommandSender(&sender)); + CommandSenderHandler sender(Platform::New(mDevice->GetInteractionModelDelegate())); + + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + SuccessOrExit(err = sender->Init(mDevice->GetExchangeManager())); SuccessOrExit(err = sender->PrepareCommand(cmdParams)); VerifyOrExit((writer = sender->GetCommandDataElementTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); @@ -770,16 +1182,14 @@ CHIP_ERROR OperationalCredentialsCluster::UpdateFabricLabel(Callback::Cancelable SuccessOrExit(err = sender->FinishCommand()); // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender, onSuccessCallback, onFailureCallback); + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - err = mDevice->SendCommands(sender); + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); exit: - // On error, we are responsible to close the sender. - if (err != CHIP_NO_ERROR && sender != nullptr) - { - sender->Shutdown(); - } return err; } diff --git a/zzz_generated/tv-app/zap-generated/CHIPClusters.h b/zzz_generated/tv-app/zap-generated/CHIPClusters.h index a3553d65d91567..c2ee967ae81fc5 100644 --- a/zzz_generated/tv-app/zap-generated/CHIPClusters.h +++ b/zzz_generated/tv-app/zap-generated/CHIPClusters.h @@ -23,10 +23,14 @@ #include #include +#include + #include #include #include +#include + namespace chip { namespace Controller { @@ -43,6 +47,21 @@ class DLL_EXPORT GeneralCommissioningCluster : public ClusterBase CHIP_ERROR SetRegulatoryConfig(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint8_t location, chip::ByteSpan countryCode, uint64_t breadcrumb, uint32_t timeoutMs); + // Cluster Commands (Cluster Object Implementation) + using OnCommandErrorCallbackFunct = std::function; + using OnArmFailSafeCommandResponseCallbackFunct = + std::function; + CHIP_ERROR ArmFailSafe(OnArmFailSafeCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::GeneralCommissioning::ArmFailSafeCommandParams::Type & params); + using OnCommissioningCompleteCommandResponseCallbackFunct = + std::function; + CHIP_ERROR CommissioningComplete(OnCommissioningCompleteCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::GeneralCommissioning::CommissioningCompleteCommandParams::Type & params); + using OnSetRegulatoryConfigCommandResponseCallbackFunct = + std::function; + CHIP_ERROR SetRegulatoryConfig(OnSetRegulatoryConfigCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::GeneralCommissioning::SetRegulatoryConfigCommandParams::Type & params); + // Cluster Attributes CHIP_ERROR ReadAttributeBreadcrumb(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR ReadAttributeBasicCommissioningInfoList(Callback::Cancelable * onSuccessCallback, @@ -72,6 +91,29 @@ class DLL_EXPORT NetworkCommissioningCluster : public ClusterBase CHIP_ERROR ScanNetworks(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, chip::ByteSpan ssid, uint64_t breadcrumb, uint32_t timeoutMs); + // Cluster Commands (Cluster Object Implementation) + using OnCommandErrorCallbackFunct = std::function; + using OnDisableNetworkCommandResponseCallbackFunct = + std::function; + CHIP_ERROR DisableNetwork(OnDisableNetworkCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::NetworkCommissioning::DisableNetworkCommandParams::Type & params); + using OnEnableNetworkCommandResponseCallbackFunct = + std::function; + CHIP_ERROR EnableNetwork(OnEnableNetworkCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::NetworkCommissioning::EnableNetworkCommandParams::Type & params); + using OnGetLastNetworkCommissioningResultCommandResponseCallbackFunct = std::function; + CHIP_ERROR GetLastNetworkCommissioningResult( + OnGetLastNetworkCommissioningResultCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::NetworkCommissioning::GetLastNetworkCommissioningResultCommandParams::Type & params); + using OnRemoveNetworkCommandResponseCallbackFunct = + std::function; + CHIP_ERROR RemoveNetwork(OnRemoveNetworkCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::NetworkCommissioning::RemoveNetworkCommandParams::Type & params); + using OnScanNetworksCommandResponseCallbackFunct = + std::function; + CHIP_ERROR ScanNetworks(OnScanNetworksCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::NetworkCommissioning::ScanNetworksCommandParams::Type & params); + // Cluster Attributes CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); @@ -100,6 +142,38 @@ class DLL_EXPORT OperationalCredentialsCluster : public ClusterBase CHIP_ERROR UpdateFabricLabel(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, chip::ByteSpan label); + // Cluster Commands (Cluster Object Implementation) + using OnCommandErrorCallbackFunct = std::function; + using OnAddNOCCommandResponseCallbackFunct = + std::function; + CHIP_ERROR AddNOC(OnAddNOCCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::OperationalCredentials::AddNOCCommandParams::Type & params); + using OnAddTrustedRootCertificateCommandResponseCallbackFunct = std::function; + CHIP_ERROR + AddTrustedRootCertificate(OnAddTrustedRootCertificateCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::OperationalCredentials::AddTrustedRootCertificateCommandParams::Type & params); + using OnAttestationRequestCommandResponseCallbackFunct = + std::function; + CHIP_ERROR AttestationRequest(OnAttestationRequestCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::OperationalCredentials::AttestationRequestCommandParams::Type & params); + using OnCertificateChainRequestCommandResponseCallbackFunct = + std::function; + CHIP_ERROR + CertificateChainRequest(OnCertificateChainRequestCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::OperationalCredentials::CertificateChainRequestCommandParams::Type & params); + using OnOpCSRRequestCommandResponseCallbackFunct = + std::function; + CHIP_ERROR OpCSRRequest(OnOpCSRRequestCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::OperationalCredentials::OpCSRRequestCommandParams::Type & params); + using OnRemoveFabricCommandResponseCallbackFunct = + std::function; + CHIP_ERROR RemoveFabric(OnRemoveFabricCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::OperationalCredentials::RemoveFabricCommandParams::Type & params); + using OnUpdateFabricLabelCommandResponseCallbackFunct = + std::function; + CHIP_ERROR UpdateFabricLabel(OnUpdateFabricLabelCommandResponseCallbackFunct, OnCommandErrorCallbackFunct, + const app::clusters::OperationalCredentials::UpdateFabricLabelCommandParams::Type & params); + // Cluster Attributes CHIP_ERROR ReadAttributeFabricsList(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR ReadAttributeSupportedFabrics(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); diff --git a/zzz_generated/tv-app/zap-generated/cluster_objects_commands.cpp b/zzz_generated/tv-app/zap-generated/cluster_objects_commands.cpp new file mode 100644 index 00000000000000..e921bfc0415aa0 --- /dev/null +++ b/zzz_generated/tv-app/zap-generated/cluster_objects_commands.cpp @@ -0,0 +1,331 @@ +/* + * + * 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 "cluster_objects_commands.h" + +#include + +#pragma GCC diagnostic ignored "-Wstack-usage=" + +namespace chip { +namespace app { +namespace clusters { + +namespace GeneralCommissioning { +namespace ArmFailSafeCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kExpiryLengthSecondsFieldId), expiryLengthSeconds)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kBreadcrumbFieldId), breadcrumb)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kTimeoutMsFieldId), timeoutMs)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace ArmFailSafeCommandParams +namespace CommissioningCompleteCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace CommissioningCompleteCommandParams +namespace SetRegulatoryConfigCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kLocationFieldId), location)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kCountryCodeFieldId), countryCode)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kBreadcrumbFieldId), breadcrumb)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kTimeoutMsFieldId), timeoutMs)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace SetRegulatoryConfigCommandParams + +namespace ArmFailSafeResponseCommandParams { +CHIP_ERROR Type::Decode(TLV::TLVReader & reader) +{ + return CHIP_ERROR_NOT_IMPLEMENTED; +} +} // namespace ArmFailSafeResponseCommandParams +namespace CommissioningCompleteResponseCommandParams { +CHIP_ERROR Type::Decode(TLV::TLVReader & reader) +{ + return CHIP_ERROR_NOT_IMPLEMENTED; +} +} // namespace CommissioningCompleteResponseCommandParams +namespace SetRegulatoryConfigResponseCommandParams { +CHIP_ERROR Type::Decode(TLV::TLVReader & reader) +{ + return CHIP_ERROR_NOT_IMPLEMENTED; +} +} // namespace SetRegulatoryConfigResponseCommandParams + +} // namespace GeneralCommissioning +namespace NetworkCommissioning { +namespace DisableNetworkCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kNetworkIDFieldId), networkID)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kBreadcrumbFieldId), breadcrumb)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kTimeoutMsFieldId), timeoutMs)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace DisableNetworkCommandParams +namespace EnableNetworkCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kNetworkIDFieldId), networkID)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kBreadcrumbFieldId), breadcrumb)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kTimeoutMsFieldId), timeoutMs)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace EnableNetworkCommandParams +namespace GetLastNetworkCommissioningResultCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kTimeoutMsFieldId), timeoutMs)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace GetLastNetworkCommissioningResultCommandParams +namespace RemoveNetworkCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kNetworkIDFieldId), networkID)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kBreadcrumbFieldId), breadcrumb)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kTimeoutMsFieldId), timeoutMs)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace RemoveNetworkCommandParams +namespace ScanNetworksCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kSsidFieldId), ssid)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kBreadcrumbFieldId), breadcrumb)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kTimeoutMsFieldId), timeoutMs)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace ScanNetworksCommandParams + +namespace AddThreadNetworkResponseCommandParams { +CHIP_ERROR Type::Decode(TLV::TLVReader & reader) +{ + return CHIP_ERROR_NOT_IMPLEMENTED; +} +} // namespace AddThreadNetworkResponseCommandParams +namespace AddWiFiNetworkResponseCommandParams { +CHIP_ERROR Type::Decode(TLV::TLVReader & reader) +{ + return CHIP_ERROR_NOT_IMPLEMENTED; +} +} // namespace AddWiFiNetworkResponseCommandParams +namespace DisableNetworkResponseCommandParams { +CHIP_ERROR Type::Decode(TLV::TLVReader & reader) +{ + return CHIP_ERROR_NOT_IMPLEMENTED; +} +} // namespace DisableNetworkResponseCommandParams +namespace EnableNetworkResponseCommandParams { +CHIP_ERROR Type::Decode(TLV::TLVReader & reader) +{ + return CHIP_ERROR_NOT_IMPLEMENTED; +} +} // namespace EnableNetworkResponseCommandParams +namespace RemoveNetworkResponseCommandParams { +CHIP_ERROR Type::Decode(TLV::TLVReader & reader) +{ + return CHIP_ERROR_NOT_IMPLEMENTED; +} +} // namespace RemoveNetworkResponseCommandParams +namespace ScanNetworksResponseCommandParams { +CHIP_ERROR Type::Decode(TLV::TLVReader & reader) +{ + return CHIP_ERROR_NOT_IMPLEMENTED; +} +} // namespace ScanNetworksResponseCommandParams +namespace UpdateThreadNetworkResponseCommandParams { +CHIP_ERROR Type::Decode(TLV::TLVReader & reader) +{ + return CHIP_ERROR_NOT_IMPLEMENTED; +} +} // namespace UpdateThreadNetworkResponseCommandParams +namespace UpdateWiFiNetworkResponseCommandParams { +CHIP_ERROR Type::Decode(TLV::TLVReader & reader) +{ + return CHIP_ERROR_NOT_IMPLEMENTED; +} +} // namespace UpdateWiFiNetworkResponseCommandParams + +} // namespace NetworkCommissioning +namespace OperationalCredentials { +namespace AddNOCCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kNOCValueFieldId), nOCValue)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kICACValueFieldId), iCACValue)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kIPKValueFieldId), iPKValue)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kCaseAdminNodeFieldId), caseAdminNode)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kAdminVendorIdFieldId), adminVendorId)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace AddNOCCommandParams +namespace AddTrustedRootCertificateCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kRootCertificateFieldId), rootCertificate)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace AddTrustedRootCertificateCommandParams +namespace AttestationRequestCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kAttestationNonceFieldId), attestationNonce)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace AttestationRequestCommandParams +namespace CertificateChainRequestCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kCertificateTypeFieldId), certificateType)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace CertificateChainRequestCommandParams +namespace OpCSRRequestCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kCSRNonceFieldId), cSRNonce)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace OpCSRRequestCommandParams +namespace RemoveFabricCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kFabricIndexFieldId), fabricIndex)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace RemoveFabricCommandParams +namespace UpdateFabricLabelCommandParams { + +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, uint64_t tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(kLabelFieldId), label)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +} // namespace UpdateFabricLabelCommandParams + +namespace AttestationResponseCommandParams { +CHIP_ERROR Type::Decode(TLV::TLVReader & reader) +{ + return CHIP_ERROR_NOT_IMPLEMENTED; +} +} // namespace AttestationResponseCommandParams +namespace CertificateChainResponseCommandParams { +CHIP_ERROR Type::Decode(TLV::TLVReader & reader) +{ + return CHIP_ERROR_NOT_IMPLEMENTED; +} +} // namespace CertificateChainResponseCommandParams +namespace NOCResponseCommandParams { +CHIP_ERROR Type::Decode(TLV::TLVReader & reader) +{ + return CHIP_ERROR_NOT_IMPLEMENTED; +} +} // namespace NOCResponseCommandParams +namespace OpCSRResponseCommandParams { +CHIP_ERROR Type::Decode(TLV::TLVReader & reader) +{ + return CHIP_ERROR_NOT_IMPLEMENTED; +} +} // namespace OpCSRResponseCommandParams + +} // namespace OperationalCredentials + +} // namespace clusters +} // namespace app +} // namespace chip diff --git a/zzz_generated/tv-app/zap-generated/cluster_objects_commands.h b/zzz_generated/tv-app/zap-generated/cluster_objects_commands.h new file mode 100644 index 00000000000000..cb5915d9f198d3 --- /dev/null +++ b/zzz_generated/tv-app/zap-generated/cluster_objects_commands.h @@ -0,0 +1,524 @@ +/* + * + * 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 + +#pragma once + +#include +#include +#include +#include +#include +#include + +namespace chip { +namespace app { +namespace clusters { + +// GeneralCommissioning Cluster Commands +namespace GeneralCommissioning { + +namespace ArmFailSafeCommandParams { +enum FieldId +{ + kExpiryLengthSecondsFieldId = 0, + kBreadcrumbFieldId = 1, + kTimeoutMsFieldId = 2, +}; + +struct Type +{ +public: + uint16_t expiryLengthSeconds; + uint64_t breadcrumb; + uint32_t timeoutMs; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace ArmFailSafeCommandParams +namespace CommissioningCompleteCommandParams { +enum FieldId +{ +}; + +struct Type +{ +public: + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace CommissioningCompleteCommandParams +namespace SetRegulatoryConfigCommandParams { +enum FieldId +{ + kLocationFieldId = 0, + kCountryCodeFieldId = 1, + kBreadcrumbFieldId = 2, + kTimeoutMsFieldId = 3, +}; + +struct Type +{ +public: + RegulatoryLocationType location; + Span countryCode; + uint64_t breadcrumb; + uint32_t timeoutMs; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace SetRegulatoryConfigCommandParams + +namespace ArmFailSafeResponseCommandParams { +enum FieldId +{ + kErrorCodeFieldId = 0, + kDebugTextFieldId = 1, +}; + +struct Type +{ +public: + // TODO + + CHIP_ERROR Decode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace ArmFailSafeResponseCommandParams +namespace CommissioningCompleteResponseCommandParams { +enum FieldId +{ + kErrorCodeFieldId = 0, + kDebugTextFieldId = 1, +}; + +struct Type +{ +public: + // TODO + + CHIP_ERROR Decode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace CommissioningCompleteResponseCommandParams +namespace SetRegulatoryConfigResponseCommandParams { +enum FieldId +{ + kErrorCodeFieldId = 0, + kDebugTextFieldId = 1, +}; + +struct Type +{ +public: + // TODO + + CHIP_ERROR Decode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace SetRegulatoryConfigResponseCommandParams + +} // namespace GeneralCommissioning + +// NetworkCommissioning Cluster Commands +namespace NetworkCommissioning { + +namespace DisableNetworkCommandParams { +enum FieldId +{ + kNetworkIDFieldId = 0, + kBreadcrumbFieldId = 1, + kTimeoutMsFieldId = 2, +}; + +struct Type +{ +public: + chip::ByteSpan networkID; + uint64_t breadcrumb; + uint32_t timeoutMs; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace DisableNetworkCommandParams +namespace EnableNetworkCommandParams { +enum FieldId +{ + kNetworkIDFieldId = 0, + kBreadcrumbFieldId = 1, + kTimeoutMsFieldId = 2, +}; + +struct Type +{ +public: + chip::ByteSpan networkID; + uint64_t breadcrumb; + uint32_t timeoutMs; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace EnableNetworkCommandParams +namespace GetLastNetworkCommissioningResultCommandParams { +enum FieldId +{ + kTimeoutMsFieldId = 0, +}; + +struct Type +{ +public: + uint32_t timeoutMs; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace GetLastNetworkCommissioningResultCommandParams +namespace RemoveNetworkCommandParams { +enum FieldId +{ + kNetworkIDFieldId = 0, + kBreadcrumbFieldId = 1, + kTimeoutMsFieldId = 2, +}; + +struct Type +{ +public: + chip::ByteSpan networkID; + uint64_t breadcrumb; + uint32_t timeoutMs; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace RemoveNetworkCommandParams +namespace ScanNetworksCommandParams { +enum FieldId +{ + kSsidFieldId = 0, + kBreadcrumbFieldId = 1, + kTimeoutMsFieldId = 2, +}; + +struct Type +{ +public: + chip::ByteSpan ssid; + uint64_t breadcrumb; + uint32_t timeoutMs; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace ScanNetworksCommandParams + +namespace AddThreadNetworkResponseCommandParams { +enum FieldId +{ + kErrorCodeFieldId = 0, + kDebugTextFieldId = 1, +}; + +struct Type +{ +public: + // TODO + + CHIP_ERROR Decode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace AddThreadNetworkResponseCommandParams +namespace AddWiFiNetworkResponseCommandParams { +enum FieldId +{ + kErrorCodeFieldId = 0, + kDebugTextFieldId = 1, +}; + +struct Type +{ +public: + // TODO + + CHIP_ERROR Decode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace AddWiFiNetworkResponseCommandParams +namespace DisableNetworkResponseCommandParams { +enum FieldId +{ + kErrorCodeFieldId = 0, + kDebugTextFieldId = 1, +}; + +struct Type +{ +public: + // TODO + + CHIP_ERROR Decode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace DisableNetworkResponseCommandParams +namespace EnableNetworkResponseCommandParams { +enum FieldId +{ + kErrorCodeFieldId = 0, + kDebugTextFieldId = 1, +}; + +struct Type +{ +public: + // TODO + + CHIP_ERROR Decode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace EnableNetworkResponseCommandParams +namespace RemoveNetworkResponseCommandParams { +enum FieldId +{ + kErrorCodeFieldId = 0, + kDebugTextFieldId = 1, +}; + +struct Type +{ +public: + // TODO + + CHIP_ERROR Decode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace RemoveNetworkResponseCommandParams +namespace ScanNetworksResponseCommandParams { +enum FieldId +{ + kErrorCodeFieldId = 0, + kDebugTextFieldId = 1, + kWifiScanResultsFieldId = 2, + kThreadScanResultsFieldId = 3, +}; + +struct Type +{ +public: + // TODO + + CHIP_ERROR Decode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace ScanNetworksResponseCommandParams +namespace UpdateThreadNetworkResponseCommandParams { +enum FieldId +{ + kErrorCodeFieldId = 0, + kDebugTextFieldId = 1, +}; + +struct Type +{ +public: + // TODO + + CHIP_ERROR Decode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace UpdateThreadNetworkResponseCommandParams +namespace UpdateWiFiNetworkResponseCommandParams { +enum FieldId +{ + kErrorCodeFieldId = 0, + kDebugTextFieldId = 1, +}; + +struct Type +{ +public: + // TODO + + CHIP_ERROR Decode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace UpdateWiFiNetworkResponseCommandParams + +} // namespace NetworkCommissioning + +// OperationalCredentials Cluster Commands +namespace OperationalCredentials { + +namespace AddNOCCommandParams { +enum FieldId +{ + kNOCValueFieldId = 0, + kICACValueFieldId = 1, + kIPKValueFieldId = 2, + kCaseAdminNodeFieldId = 3, + kAdminVendorIdFieldId = 4, +}; + +struct Type +{ +public: + chip::ByteSpan nOCValue; + chip::ByteSpan iCACValue; + chip::ByteSpan iPKValue; + uint64_t caseAdminNode; + uint16_t adminVendorId; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace AddNOCCommandParams +namespace AddTrustedRootCertificateCommandParams { +enum FieldId +{ + kRootCertificateFieldId = 0, +}; + +struct Type +{ +public: + chip::ByteSpan rootCertificate; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace AddTrustedRootCertificateCommandParams +namespace AttestationRequestCommandParams { +enum FieldId +{ + kAttestationNonceFieldId = 0, +}; + +struct Type +{ +public: + chip::ByteSpan attestationNonce; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace AttestationRequestCommandParams +namespace CertificateChainRequestCommandParams { +enum FieldId +{ + kCertificateTypeFieldId = 0, +}; + +struct Type +{ +public: + uint8_t certificateType; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace CertificateChainRequestCommandParams +namespace OpCSRRequestCommandParams { +enum FieldId +{ + kCSRNonceFieldId = 0, +}; + +struct Type +{ +public: + chip::ByteSpan cSRNonce; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace OpCSRRequestCommandParams +namespace RemoveFabricCommandParams { +enum FieldId +{ + kFabricIndexFieldId = 0, +}; + +struct Type +{ +public: + uint8_t fabricIndex; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace RemoveFabricCommandParams +namespace UpdateFabricLabelCommandParams { +enum FieldId +{ + kLabelFieldId = 0, +}; + +struct Type +{ +public: + Span label; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace UpdateFabricLabelCommandParams + +namespace AttestationResponseCommandParams { +enum FieldId +{ + kAttestationElementsFieldId = 0, + kSignatureFieldId = 1, +}; + +struct Type +{ +public: + // TODO + + CHIP_ERROR Decode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace AttestationResponseCommandParams +namespace CertificateChainResponseCommandParams { +enum FieldId +{ + kCertificateFieldId = 0, +}; + +struct Type +{ +public: + // TODO + + CHIP_ERROR Decode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace CertificateChainResponseCommandParams +namespace NOCResponseCommandParams { +enum FieldId +{ + kStatusCodeFieldId = 0, + kFabricIndexFieldId = 1, + kDebugTextFieldId = 2, +}; + +struct Type +{ +public: + // TODO + + CHIP_ERROR Decode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace NOCResponseCommandParams +namespace OpCSRResponseCommandParams { +enum FieldId +{ + kNOCSRElementsFieldId = 0, + kAttestationSignatureFieldId = 1, +}; + +struct Type +{ +public: + // TODO + + CHIP_ERROR Decode(TLV::TLVWriter & writer, uint64_t tag) const; +}; +} // namespace OpCSRResponseCommandParams + +} // namespace OperationalCredentials + +} // namespace clusters +} // namespace app +} // namespace chip diff --git a/zzz_generated/tv-casting-app/zap-generated/cluster_objects_commands.cpp b/zzz_generated/tv-casting-app/zap-generated/cluster_objects_commands.cpp new file mode 100644 index 00000000000000..93855c49854709 --- /dev/null +++ b/zzz_generated/tv-casting-app/zap-generated/cluster_objects_commands.cpp @@ -0,0 +1,32 @@ +/* + * + * 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 "cluster_objects_commands.h" + +#include + +#pragma GCC diagnostic ignored "-Wstack-usage=" + +namespace chip { +namespace app { +namespace clusters { + +} // namespace clusters +} // namespace app +} // namespace chip diff --git a/zzz_generated/tv-casting-app/zap-generated/cluster_objects_commands.h b/zzz_generated/tv-casting-app/zap-generated/cluster_objects_commands.h new file mode 100644 index 00000000000000..b9f9a986dc7233 --- /dev/null +++ b/zzz_generated/tv-casting-app/zap-generated/cluster_objects_commands.h @@ -0,0 +1,35 @@ +/* + * + * 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 + +#pragma once + +#include +#include +#include +#include +#include +#include + +namespace chip { +namespace app { +namespace clusters { + +} // namespace clusters +} // namespace app +} // namespace chip diff --git a/zzz_generated/window-app/zap-generated/cluster_objects_commands.cpp b/zzz_generated/window-app/zap-generated/cluster_objects_commands.cpp new file mode 100644 index 00000000000000..93855c49854709 --- /dev/null +++ b/zzz_generated/window-app/zap-generated/cluster_objects_commands.cpp @@ -0,0 +1,32 @@ +/* + * + * 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 "cluster_objects_commands.h" + +#include + +#pragma GCC diagnostic ignored "-Wstack-usage=" + +namespace chip { +namespace app { +namespace clusters { + +} // namespace clusters +} // namespace app +} // namespace chip diff --git a/zzz_generated/window-app/zap-generated/cluster_objects_commands.h b/zzz_generated/window-app/zap-generated/cluster_objects_commands.h new file mode 100644 index 00000000000000..b9f9a986dc7233 --- /dev/null +++ b/zzz_generated/window-app/zap-generated/cluster_objects_commands.h @@ -0,0 +1,35 @@ +/* + * + * 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 + +#pragma once + +#include +#include +#include +#include +#include +#include + +namespace chip { +namespace app { +namespace clusters { + +} // namespace clusters +} // namespace app +} // namespace chip