| /* |
| * |
| * 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 "CHIPClusters.h" |
| |
| #include <app-common/zap-generated/ids/Attributes.h> |
| #include <zap-generated/CHIPClientCallbacks.h> |
| |
| namespace chip { |
| |
| using namespace app::Clusters; |
| using namespace System; |
| using namespace Encoding::LittleEndian; |
| |
| namespace Controller { |
| |
| // TODO(#4502): onCompletion is not used by IM for now. |
| // 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. |
| |
| // AccessControl Cluster Commands |
| |
| // AccountLogin Cluster Commands |
| CHIP_ERROR AccountLoginCluster::GetSetupPIN(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, |
| chip::CharSpan tempAccountIdentifier) |
| { |
| 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, AccountLogin::Commands::GetSetupPIN::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // tempAccountIdentifier: charString |
| SuccessOrExit(err = writer->PutString(TLV::ContextTag(argSeqNumber++), tempAccountIdentifier)); |
| |
| 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 AccountLoginCluster::Login(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, |
| chip::CharSpan tempAccountIdentifier, chip::CharSpan setupPIN) |
| { |
| 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, AccountLogin::Commands::Login::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // tempAccountIdentifier: charString |
| SuccessOrExit(err = writer->PutString(TLV::ContextTag(argSeqNumber++), tempAccountIdentifier)); |
| // setupPIN: charString |
| SuccessOrExit(err = writer->PutString(TLV::ContextTag(argSeqNumber++), setupPIN)); |
| |
| 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 AccountLoginCluster::Logout(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, AccountLogin::Commands::Logout::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| // Command takes no arguments. |
| |
| 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; |
| } |
| |
| // AdministratorCommissioning Cluster Commands |
| CHIP_ERROR AdministratorCommissioningCluster::OpenBasicCommissioningWindow(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback, |
| uint16_t commissioningTimeout) |
| { |
| 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, |
| AdministratorCommissioning::Commands::OpenBasicCommissioningWindow::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // commissioningTimeout: int16u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), commissioningTimeout)); |
| |
| 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 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; |
| 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, |
| AdministratorCommissioning::Commands::OpenCommissioningWindow::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // commissioningTimeout: int16u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), commissioningTimeout)); |
| // PAKEVerifier: octetString |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), PAKEVerifier)); |
| // discriminator: int16u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), discriminator)); |
| // iterations: int32u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), iterations)); |
| // salt: octetString |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), salt)); |
| // passcodeID: int16u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), passcodeID)); |
| |
| 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 AdministratorCommissioningCluster::RevokeCommissioning(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, |
| AdministratorCommissioning::Commands::RevokeCommissioning::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| // Command takes no arguments. |
| |
| 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; |
| } |
| |
| // ApplicationBasic Cluster Commands |
| CHIP_ERROR ApplicationBasicCluster::ChangeStatus(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, |
| uint8_t status) |
| { |
| 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, ApplicationBasic::Commands::ChangeStatus::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // status: applicationBasicStatus |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), status)); |
| |
| 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; |
| } |
| |
| // ApplicationLauncher Cluster Commands |
| CHIP_ERROR ApplicationLauncherCluster::HideApp(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, |
| uint16_t catalogVendorId, chip::CharSpan applicationId) |
| { |
| 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, ApplicationLauncher::Commands::HideApp::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // catalogVendorId: int16u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), catalogVendorId)); |
| // applicationId: charString |
| SuccessOrExit(err = writer->PutString(TLV::ContextTag(argSeqNumber++), applicationId)); |
| |
| 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 ApplicationLauncherCluster::LaunchApp(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, |
| chip::CharSpan data, uint16_t catalogVendorId, chip::CharSpan applicationId) |
| { |
| 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, ApplicationLauncher::Commands::LaunchApp::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // data: charString |
| SuccessOrExit(err = writer->PutString(TLV::ContextTag(argSeqNumber++), data)); |
| // catalogVendorId: int16u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), catalogVendorId)); |
| // applicationId: charString |
| SuccessOrExit(err = writer->PutString(TLV::ContextTag(argSeqNumber++), applicationId)); |
| |
| 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 ApplicationLauncherCluster::StopApp(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, |
| uint16_t catalogVendorId, chip::CharSpan applicationId) |
| { |
| 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, ApplicationLauncher::Commands::StopApp::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // catalogVendorId: int16u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), catalogVendorId)); |
| // applicationId: charString |
| SuccessOrExit(err = writer->PutString(TLV::ContextTag(argSeqNumber++), applicationId)); |
| |
| 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; |
| } |
| |
| // AudioOutput Cluster Commands |
| CHIP_ERROR AudioOutputCluster::RenameOutput(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, |
| uint8_t index, chip::CharSpan name) |
| { |
| 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, AudioOutput::Commands::RenameOutput::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // index: int8u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), index)); |
| // name: charString |
| SuccessOrExit(err = writer->PutString(TLV::ContextTag(argSeqNumber++), name)); |
| |
| 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 AudioOutputCluster::SelectOutput(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, |
| uint8_t index) |
| { |
| 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, AudioOutput::Commands::SelectOutput::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // index: int8u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), index)); |
| |
| 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; |
| } |
| |
| // BarrierControl Cluster Commands |
| CHIP_ERROR BarrierControlCluster::BarrierControlGoToPercent(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback, uint8_t percentOpen) |
| { |
| 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, |
| BarrierControl::Commands::BarrierControlGoToPercent::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // percentOpen: int8u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), percentOpen)); |
| |
| 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 BarrierControlCluster::BarrierControlStop(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, BarrierControl::Commands::BarrierControlStop::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| // Command takes no arguments. |
| |
| 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; |
| } |
| |
| // Basic Cluster Commands |
| CHIP_ERROR BasicCluster::MfgSpecificPing(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, Basic::Commands::MfgSpecificPing::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| // Command takes no arguments. |
| |
| 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; |
| } |
| |
| // BinaryInputBasic Cluster Commands |
| |
| // Binding Cluster Commands |
| 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; |
| 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, Binding::Commands::Bind::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // nodeId: nodeId |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), nodeId)); |
| // groupId: groupId |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), groupId)); |
| // endpointId: endpointNo |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), endpointId)); |
| // clusterId: clusterId |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), clusterId)); |
| |
| 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 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; |
| 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, Binding::Commands::Unbind::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // nodeId: nodeId |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), nodeId)); |
| // groupId: groupId |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), groupId)); |
| // endpointId: endpointNo |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), endpointId)); |
| // clusterId: clusterId |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), clusterId)); |
| |
| 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; |
| } |
| |
| // BooleanState Cluster Commands |
| |
| // BridgedActions Cluster Commands |
| CHIP_ERROR BridgedActionsCluster::DisableAction(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, |
| uint16_t actionID, uint32_t invokeID) |
| { |
| 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, BridgedActions::Commands::DisableAction::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // actionID: int16u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), actionID)); |
| // invokeID: int32u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), invokeID)); |
| |
| 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 BridgedActionsCluster::DisableActionWithDuration(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback, uint16_t actionID, |
| uint32_t invokeID, uint32_t duration) |
| { |
| 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, |
| BridgedActions::Commands::DisableActionWithDuration::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // actionID: int16u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), actionID)); |
| // invokeID: int32u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), invokeID)); |
| // duration: int32u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), duration)); |
| |
| 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 BridgedActionsCluster::EnableAction(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, |
| uint16_t actionID, uint32_t invokeID) |
| { |
| 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, BridgedActions::Commands::EnableAction::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // actionID: int16u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), actionID)); |
| // invokeID: int32u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), invokeID)); |
| |
| 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 BridgedActionsCluster::EnableActionWithDuration(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback, uint16_t actionID, |
| uint32_t invokeID, uint32_t duration) |
| { |
| 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, |
| BridgedActions::Commands::EnableActionWithDuration::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // actionID: int16u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), actionID)); |
| // invokeID: int32u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), invokeID)); |
| // duration: int32u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), duration)); |
| |
| 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 BridgedActionsCluster::InstantAction(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, |
| uint16_t actionID, uint32_t invokeID) |
| { |
| 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, BridgedActions::Commands::InstantAction::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // actionID: int16u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), actionID)); |
| // invokeID: int32u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), invokeID)); |
| |
| 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 BridgedActionsCluster::InstantActionWithTransition(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback, uint16_t actionID, |
| uint32_t invokeID, uint16_t transitionTime) |
| { |
| 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, |
| BridgedActions::Commands::InstantActionWithTransition::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // actionID: int16u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), actionID)); |
| // invokeID: int32u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), invokeID)); |
| // transitionTime: int16u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), transitionTime)); |
| |
| 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 BridgedActionsCluster::PauseAction(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, |
| uint16_t actionID, uint32_t invokeID) |
| { |
| 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, BridgedActions::Commands::PauseAction::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // actionID: int16u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), actionID)); |
| // invokeID: int32u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), invokeID)); |
| |
| 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 BridgedActionsCluster::PauseActionWithDuration(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback, uint16_t actionID, |
| uint32_t invokeID, uint32_t duration) |
| { |
| 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, |
| BridgedActions::Commands::PauseActionWithDuration::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // actionID: int16u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), actionID)); |
| // invokeID: int32u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), invokeID)); |
| // duration: int32u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), duration)); |
| |
| 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 BridgedActionsCluster::ResumeAction(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, |
| uint16_t actionID, uint32_t invokeID) |
| { |
| 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, BridgedActions::Commands::ResumeAction::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // actionID: int16u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), actionID)); |
| // invokeID: int32u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), invokeID)); |
| |
| 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 BridgedActionsCluster::StartAction(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, |
| uint16_t actionID, uint32_t invokeID) |
| { |
| 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, BridgedActions::Commands::StartAction::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // actionID: int16u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), actionID)); |
| // invokeID: int32u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), invokeID)); |
| |
| 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 BridgedActionsCluster::StartActionWithDuration(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback, uint16_t actionID, |
| uint32_t invokeID, uint32_t duration) |
| { |
| 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, |
| BridgedActions::Commands::StartActionWithDuration::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // actionID: int16u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), actionID)); |
| // invokeID: int32u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), invokeID)); |
| // duration: int32u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), duration)); |
| |
| 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 BridgedActionsCluster::StopAction(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, |
| uint16_t actionID, uint32_t invokeID) |
| { |
| 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, BridgedActions::Commands::StopAction::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // actionID: int16u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), actionID)); |
| // invokeID: int32u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), invokeID)); |
| |
| 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; |
| } |
| |
| // BridgedDeviceBasic Cluster Commands |
| |
| // Channel Cluster Commands |
| CHIP_ERROR ChannelCluster::ChangeChannel(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, |
| chip::CharSpan match) |
| { |
| 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, Channel::Commands::ChangeChannel::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // match: charString |
| SuccessOrExit(err = writer->PutString(TLV::ContextTag(argSeqNumber++), match)); |
| |
| 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 ChannelCluster::ChangeChannelByNumber(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, |
| uint16_t majorNumber, uint16_t minorNumber) |
| { |
| 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, Channel::Commands::ChangeChannelByNumber::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // majorNumber: int16u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), majorNumber)); |
| // minorNumber: int16u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), minorNumber)); |
| |
| 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 ChannelCluster::SkipChannel(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, |
| uint16_t count) |
| { |
| 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, Channel::Commands::SkipChannel::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // count: int16u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), count)); |
| |
| 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; |
| } |
| |
| // ColorControl Cluster Commands |
| 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; |
| 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, ColorControl::Commands::ColorLoopSet::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // updateFlags: colorLoopUpdateFlags |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), updateFlags)); |
| // action: colorLoopAction |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), action)); |
| // direction: colorLoopDirection |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), direction)); |
| // time: int16u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), time)); |
| // startHue: int16u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), startHue)); |
| // optionsMask: bitmap8 |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), optionsMask)); |
| // optionsOverride: bitmap8 |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), optionsOverride)); |
| |
| 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 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; |
| 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, ColorControl::Commands::EnhancedMoveHue::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // moveMode: hueMoveMode |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), moveMode)); |
| // rate: int16u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), rate)); |
| // optionsMask: bitmap8 |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), optionsMask)); |
| // optionsOverride: bitmap8 |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), optionsOverride)); |
| |
| 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 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; |
| 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, ColorControl::Commands::EnhancedMoveToHue::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // enhancedHue: int16u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), enhancedHue)); |
| // direction: hueDirection |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), direction)); |
| // transitionTime: int16u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), transitionTime)); |
| // optionsMask: bitmap8 |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), optionsMask)); |
| // optionsOverride: bitmap8 |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), optionsOverride)); |
| |
| 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 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; |
| 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, |
| ColorControl::Commands::EnhancedMoveToHueAndSaturation::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // enhancedHue: int16u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), enhancedHue)); |
| // saturation: int8u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), saturation)); |
| // transitionTime: int16u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), transitionTime)); |
| // optionsMask: bitmap8 |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), optionsMask)); |
| // optionsOverride: bitmap8 |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), optionsOverride)); |
| |
| 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 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; |
| 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, ColorControl::Commands::EnhancedStepHue::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // stepMode: hueStepMode |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), stepMode)); |
| // stepSize: int16u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), stepSize)); |
| // transitionTime: int16u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), transitionTime)); |
| // optionsMask: bitmap8 |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), optionsMask)); |
| // optionsOverride: bitmap8 |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), optionsOverride)); |
| |
| 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 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; |
| 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, ColorControl::Commands::MoveColor::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // rateX: int16s |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), rateX)); |
| // rateY: int16s |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), rateY)); |
| // optionsMask: bitmap8 |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), optionsMask)); |
| // optionsOverride: bitmap8 |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), optionsOverride)); |
| |
| 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 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; |
| 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, ColorControl::Commands::MoveColorTemperature::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // moveMode: hueMoveMode |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), moveMode)); |
| // rate: int16u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), rate)); |
| // colorTemperatureMinimum: int16u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), colorTemperatureMinimum)); |
| // colorTemperatureMaximum: int16u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), colorTemperatureMaximum)); |
| // optionsMask: bitmap8 |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), optionsMask)); |
| // optionsOverride: bitmap8 |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), optionsOverride)); |
| |
| 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 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; |
| 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, ColorControl::Commands::MoveHue::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // moveMode: hueMoveMode |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), moveMode)); |
| // rate: int8u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), rate)); |
| // optionsMask: bitmap8 |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), optionsMask)); |
| // optionsOverride: bitmap8 |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), optionsOverride)); |
| |
| 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 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); |
| |
| app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, ColorControl::Commands::MoveSaturation::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // moveMode: saturationMoveMode |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), moveMode)); |
| // rate: int8u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), rate)); |
| // optionsMask: bitmap8 |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), optionsMask)); |
| // optionsOverride: bitmap8 |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), optionsOverride)); |
| |
| 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 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; |
| 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, ColorControl::Commands::MoveToColor::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // colorX: int16u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), colorX)); |
| // colorY: int16u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), colorY)); |
| // transitionTime: int16u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), transitionTime)); |
| // optionsMask: bitmap8 |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), optionsMask)); |
| // optionsOverride: bitmap8 |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), optionsOverride)); |
| |
| 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 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; |
| 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, |
| ColorControl::Commands::MoveToColorTemperature::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // colorTemperature: int16u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), colorTemperature)); |
| // transitionTime: int16u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), transitionTime)); |
| // optionsMask: bitmap8 |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), optionsMask)); |
| // optionsOverride: bitmap8 |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), optionsOverride)); |
| |
| 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 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; |
| 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, ColorControl::Commands::MoveToHue::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // hue: int8u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), hue)); |
| // direction: hueDirection |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), direction)); |
| // transitionTime: int16u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), transitionTime)); |
| // optionsMask: bitmap8 |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), optionsMask)); |
| // optionsOverride: bitmap8 |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), optionsOverride)); |
| |
| 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 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; |
| 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, |
| ColorControl::Commands::MoveToHueAndSaturation::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // hue: int8u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), hue)); |
| // saturation: int8u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), saturation)); |
| // transitionTime: int16u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), transitionTime)); |
| // optionsMask: bitmap8 |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), optionsMask)); |
| // optionsOverride: bitmap8 |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), optionsOverride)); |
| |
| 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 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; |
| 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, ColorControl::Commands::MoveToSaturation::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // saturation: int8u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), saturation)); |
| // transitionTime: int16u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), transitionTime)); |
| // optionsMask: bitmap8 |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), optionsMask)); |
| // optionsOverride: bitmap8 |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), optionsOverride)); |
| |
| 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 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; |
| 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, ColorControl::Commands::StepColor::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // stepX: int16s |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), stepX)); |
| // stepY: int16s |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), stepY)); |
| // transitionTime: int16u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), transitionTime)); |
| // optionsMask: bitmap8 |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), optionsMask)); |
| // optionsOverride: bitmap8 |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), optionsOverride)); |
| |
| 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 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; |
| 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, ColorControl::Commands::StepColorTemperature::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // stepMode: hueStepMode |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), stepMode)); |
| // stepSize: int16u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), stepSize)); |
| // transitionTime: int16u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), transitionTime)); |
| // colorTemperatureMinimum: int16u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), colorTemperatureMinimum)); |
| // colorTemperatureMaximum: int16u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), colorTemperatureMaximum)); |
| // optionsMask: bitmap8 |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), optionsMask)); |
| // optionsOverride: bitmap8 |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), optionsOverride)); |
| |
| 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 ColorControlCluster::StepHue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, |
| uint8_t stepMode, uint8_t stepSize, uint8_t transitionTime, 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); |
| |
| app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, ColorControl::Commands::StepHue::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // stepMode: hueStepMode |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), stepMode)); |
| // stepSize: int8u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), stepSize)); |
| // transitionTime: int8u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), transitionTime)); |
| // optionsMask: bitmap8 |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), optionsMask)); |
| // optionsOverride: bitmap8 |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), optionsOverride)); |
| |
| 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 ColorControlCluster::StepSaturation(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, |
| uint8_t stepMode, uint8_t stepSize, uint8_t transitionTime, 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); |
| |
| app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, ColorControl::Commands::StepSaturation::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // stepMode: saturationStepMode |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), stepMode)); |
| // stepSize: int8u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), stepSize)); |
| // transitionTime: int8u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), transitionTime)); |
| // optionsMask: bitmap8 |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), optionsMask)); |
| // optionsOverride: bitmap8 |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), optionsOverride)); |
| |
| 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 ColorControlCluster::StopMoveStep(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, |
| 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); |
| |
| app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, ColorControl::Commands::StopMoveStep::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // optionsMask: bitmap8 |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), optionsMask)); |
| // optionsOverride: bitmap8 |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), optionsOverride)); |
| |
| 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; |
| } |
| |
| // ContentLauncher Cluster Commands |
| CHIP_ERROR ContentLauncherCluster::LaunchContent(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, |
| bool autoPlay, chip::CharSpan data, uint8_t type, chip::CharSpan value) |
| { |
| 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, ContentLauncher::Commands::LaunchContent::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // autoPlay: boolean |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), autoPlay)); |
| // data: charString |
| SuccessOrExit(err = writer->PutString(TLV::ContextTag(argSeqNumber++), data)); |
| // type: contentLaunchParameterEnum |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), type)); |
| // value: charString |
| SuccessOrExit(err = writer->PutString(TLV::ContextTag(argSeqNumber++), value)); |
| |
| 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 ContentLauncherCluster::LaunchURL(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, |
| chip::CharSpan contentURL, chip::CharSpan displayString, chip::CharSpan providerName) |
| { |
| 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, ContentLauncher::Commands::LaunchURL::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // contentURL: charString |
| SuccessOrExit(err = writer->PutString(TLV::ContextTag(argSeqNumber++), contentURL)); |
| // displayString: charString |
| SuccessOrExit(err = writer->PutString(TLV::ContextTag(argSeqNumber++), displayString)); |
| // providerName: charString |
| SuccessOrExit(err = writer->PutString(TLV::ContextTag(argSeqNumber++), providerName)); |
| |
| 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; |
| } |
| |
| // Descriptor Cluster Commands |
| |
| // DiagnosticLogs Cluster Commands |
| 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; |
| 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, DiagnosticLogs::Commands::RetrieveLogsRequest::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // intent: logsIntent |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), intent)); |
| // requestedProtocol: logsTransferProtocol |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), requestedProtocol)); |
| // transferFileDesignator: octetString |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), transferFileDesignator)); |
| |
| 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; |
| } |
| |
| // DoorLock Cluster Commands |
| CHIP_ERROR DoorLockCluster::ClearCredential(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, |
| uint8_t credentialType, uint16_t credentialIndex) |
| { |
| 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, DoorLock::Commands::ClearCredential::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // credentialType: dlCredentialType |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), credentialType)); |
| // credentialIndex: int16u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), credentialIndex)); |
| |
| 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 DoorLockCluster::ClearUser(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, |
| uint16_t userIndex) |
| { |
| 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, DoorLock::Commands::ClearUser::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // userIndex: int16u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), userIndex)); |
| |
| 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 DoorLockCluster::GetCredentialStatus(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, |
| uint8_t credentialType, uint16_t credentialIndex) |
| { |
| 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, DoorLock::Commands::GetCredentialStatus::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // credentialType: dlCredentialType |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), credentialType)); |
| // credentialIndex: int16u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), credentialIndex)); |
| |
| 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 DoorLockCluster::GetUser(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, |
| uint16_t userIndex) |
| { |
| 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, DoorLock::Commands::GetUser::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // userIndex: int16u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), userIndex)); |
| |
| 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 DoorLockCluster::LockDoor(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, |
| chip::ByteSpan pinCode) |
| { |
| 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, DoorLock::Commands::LockDoor::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // pinCode: octetString |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), pinCode)); |
| |
| 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 DoorLockCluster::SetCredential(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, |
| uint8_t operationType, uint8_t credentialType, uint16_t credentialIndex, |
| chip::ByteSpan credentialData, uint16_t userIndex, uint8_t userStatus) |
| { |
| 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, DoorLock::Commands::SetCredential::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // operationType: dlDataOperationType |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), operationType)); |
| // credentialType: dlCredentialType |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), credentialType)); |
| // credentialIndex: int16u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), credentialIndex)); |
| // credentialData: longOctetString |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), credentialData)); |
| // userIndex: int16u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), userIndex)); |
| // userStatus: dlUserStatus |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), userStatus)); |
| |
| 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 DoorLockCluster::SetUser(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, |
| uint8_t operationType, uint16_t userIndex, chip::CharSpan userName, uint32_t userUniqueId, |
| uint8_t userStatus, uint8_t userType, uint8_t credentialRule) |
| { |
| 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, DoorLock::Commands::SetUser::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // operationType: dlDataOperationType |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), operationType)); |
| // userIndex: int16u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), userIndex)); |
| // userName: charString |
| SuccessOrExit(err = writer->PutString(TLV::ContextTag(argSeqNumber++), userName)); |
| // userUniqueId: int32u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), userUniqueId)); |
| // userStatus: dlUserStatus |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), userStatus)); |
| // userType: dlUserType |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), userType)); |
| // credentialRule: dlCredentialRule |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), credentialRule)); |
| |
| 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 DoorLockCluster::UnlockDoor(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, |
| chip::ByteSpan pinCode) |
| { |
| 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, DoorLock::Commands::UnlockDoor::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // pinCode: octetString |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), pinCode)); |
| |
| 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; |
| } |
| |
| // ElectricalMeasurement Cluster Commands |
| |
| // EthernetNetworkDiagnostics Cluster Commands |
| CHIP_ERROR EthernetNetworkDiagnosticsCluster::ResetCounts(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, |
| EthernetNetworkDiagnostics::Commands::ResetCounts::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| // Command takes no arguments. |
| |
| 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; |
| } |
| |
| // FixedLabel Cluster Commands |
| |
| // FlowMeasurement Cluster Commands |
| |
| // GeneralCommissioning Cluster Commands |
| 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; |
| 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, GeneralCommissioning::Commands::ArmFailSafe::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // expiryLengthSeconds: int16u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), expiryLengthSeconds)); |
| // breadcrumb: int64u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), breadcrumb)); |
| // timeoutMs: int32u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), timeoutMs)); |
| |
| 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 GeneralCommissioningCluster::CommissioningComplete(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, |
| GeneralCommissioning::Commands::CommissioningComplete::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| // Command takes no arguments. |
| |
| 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 GeneralCommissioningCluster::SetRegulatoryConfig(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback, uint8_t location, |
| chip::CharSpan countryCode, uint64_t breadcrumb, uint32_t timeoutMs) |
| { |
| 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, |
| GeneralCommissioning::Commands::SetRegulatoryConfig::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // location: regulatoryLocationType |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), location)); |
| // countryCode: charString |
| SuccessOrExit(err = writer->PutString(TLV::ContextTag(argSeqNumber++), countryCode)); |
| // breadcrumb: int64u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), breadcrumb)); |
| // timeoutMs: int32u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), timeoutMs)); |
| |
| 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; |
| } |
| |
| // GeneralDiagnostics Cluster Commands |
| |
| // GroupKeyManagement Cluster Commands |
| CHIP_ERROR GroupKeyManagementCluster::KeySetRead(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, |
| uint16_t groupKeySetID) |
| { |
| 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, GroupKeyManagement::Commands::KeySetRead::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // groupKeySetID: int16u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), groupKeySetID)); |
| |
| 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 GroupKeyManagementCluster::KeySetReadAllIndices(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback, uint16_t groupKeySetIDs) |
| { |
| 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, |
| GroupKeyManagement::Commands::KeySetReadAllIndices::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // groupKeySetIDs: int16u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), groupKeySetIDs)); |
| |
| 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 GroupKeyManagementCluster::KeySetRemove(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback, uint16_t groupKeySetID) |
| { |
| 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, GroupKeyManagement::Commands::KeySetRemove::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // groupKeySetID: int16u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), groupKeySetID)); |
| |
| 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 GroupKeyManagementCluster::KeySetWrite(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback, uint16_t groupKeySetID, |
| uint8_t securityPolicy, chip::ByteSpan epochKey0, uint64_t epochStartTime0, |
| chip::ByteSpan epochKey1, uint64_t epochStartTime1, chip::ByteSpan epochKey2, |
| uint64_t epochStartTime2) |
| { |
| 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, GroupKeyManagement::Commands::KeySetWrite::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // groupKeySetID: int16u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), groupKeySetID)); |
| // securityPolicy: groupKeySecurityPolicy |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), securityPolicy)); |
| // epochKey0: octetString |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), epochKey0)); |
| // epochStartTime0: int64u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), epochStartTime0)); |
| // epochKey1: octetString |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), epochKey1)); |
| // epochStartTime1: int64u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), epochStartTime1)); |
| // epochKey2: octetString |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), epochKey2)); |
| // epochStartTime2: int64u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), epochStartTime2)); |
| |
| 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; |
| } |
| |
| // Groups Cluster Commands |
| CHIP_ERROR GroupsCluster::AddGroup(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, |
| uint16_t groupId, chip::CharSpan groupName) |
| { |
| 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::AddGroup::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // groupId: int16u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), groupId)); |
| // groupName: charString |
| SuccessOrExit(err = writer->PutString(TLV::ContextTag(argSeqNumber++), groupName)); |
| |
| 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 GroupsCluster::AddGroupIfIdentifying(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, |
| uint16_t groupId, chip::CharSpan groupName) |
| { |
| 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::AddGroupIfIdentifying::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // groupId: int16u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), groupId)); |
| // groupName: charString |
| SuccessOrExit(err = writer->PutString(TLV::ContextTag(argSeqNumber++), groupName)); |
| |
| 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 GroupsCluster::GetGroupMembership(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, |
| uint16_t groupList) |
| { |
| 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::GetGroupMembership::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // groupList: int16u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), groupList)); |
| |
| 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 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::RemoveAllGroups::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| // Command takes no arguments. |
| |
| 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 GroupsCluster::RemoveGroup(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, |
| uint16_t groupId) |
| { |
| 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::RemoveGroup::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // groupId: int16u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), groupId)); |
| |
| 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 GroupsCluster::ViewGroup(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, |
| uint16_t groupId) |
| { |
| 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::ViewGroup::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // groupId: int16u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), groupId)); |
| |
| 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; |
| } |
| |
| // Identify Cluster Commands |
| CHIP_ERROR IdentifyCluster::Identify(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, |
| uint16_t identifyTime) |
| { |
| 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, Identify::Commands::Identify::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // identifyTime: int16u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), identifyTime)); |
| |
| 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 IdentifyCluster::IdentifyQuery(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, Identify::Commands::IdentifyQuery::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| // Command takes no arguments. |
| |
| 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 IdentifyCluster::TriggerEffect(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, |
| uint8_t effectIdentifier, uint8_t effectVariant) |
| { |
| 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, Identify::Commands::TriggerEffect::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // effectIdentifier: identifyEffectIdentifier |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), effectIdentifier)); |
| // effectVariant: identifyEffectVariant |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), effectVariant)); |
| |
| 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; |
| } |
| |
| // IlluminanceMeasurement Cluster Commands |
| |
| // KeypadInput Cluster Commands |
| CHIP_ERROR KeypadInputCluster::SendKey(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, |
| uint8_t keyCode) |
| { |
| 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, KeypadInput::Commands::SendKey::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // keyCode: keypadInputCecKeyCode |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), keyCode)); |
| |
| 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; |
| } |
| |
| // LevelControl Cluster Commands |
| 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; |
| 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, LevelControl::Commands::Move::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // moveMode: moveMode |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), moveMode)); |
| // rate: int8u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), rate)); |
| // optionMask: bitmap8 |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), optionMask)); |
| // optionOverride: bitmap8 |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), optionOverride)); |
| |
| 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 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; |
| 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, LevelControl::Commands::MoveToLevel::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // level: int8u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), level)); |
| // transitionTime: int16u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), transitionTime)); |
| // optionMask: bitmap8 |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), optionMask)); |
| // optionOverride: bitmap8 |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), optionOverride)); |
| |
| 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 LevelControlCluster::MoveToLevelWithOnOff(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback, uint8_t level, |
| uint16_t transitionTime) |
| { |
| 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, LevelControl::Commands::MoveToLevelWithOnOff::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // level: int8u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), level)); |
| // transitionTime: int16u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), transitionTime)); |
| |
| 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 LevelControlCluster::MoveWithOnOff(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, |
| uint8_t moveMode, uint8_t rate) |
| { |
| 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, LevelControl::Commands::MoveWithOnOff::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // moveMode: moveMode |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), moveMode)); |
| // rate: int8u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), rate)); |
| |
| 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 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; |
| 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, LevelControl::Commands::Step::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // stepMode: stepMode |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), stepMode)); |
| // stepSize: int8u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), stepSize)); |
| // transitionTime: int16u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), transitionTime)); |
| // optionMask: bitmap8 |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), optionMask)); |
| // optionOverride: bitmap8 |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), optionOverride)); |
| |
| 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 LevelControlCluster::StepWithOnOff(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, |
| uint8_t stepMode, uint8_t stepSize, uint16_t transitionTime) |
| { |
| 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, LevelControl::Commands::StepWithOnOff::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // stepMode: stepMode |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), stepMode)); |
| // stepSize: int8u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), stepSize)); |
| // transitionTime: int16u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), transitionTime)); |
| |
| 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 LevelControlCluster::Stop(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, |
| uint8_t optionMask, uint8_t optionOverride) |
| { |
| 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, LevelControl::Commands::Stop::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // optionMask: bitmap8 |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), optionMask)); |
| // optionOverride: bitmap8 |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), optionOverride)); |
| |
| 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 LevelControlCluster::StopWithOnOff(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, LevelControl::Commands::StopWithOnOff::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| // Command takes no arguments. |
| |
| 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; |
| } |
| |
| // LowPower Cluster Commands |
| CHIP_ERROR LowPowerCluster::Sleep(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, LowPower::Commands::Sleep::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| // Command takes no arguments. |
| |
| 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; |
| } |
| |
| // MediaInput Cluster Commands |
| CHIP_ERROR MediaInputCluster::HideInputStatus(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, MediaInput::Commands::HideInputStatus::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| // Command takes no arguments. |
| |
| 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 MediaInputCluster::RenameInput(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, |
| uint8_t index, chip::CharSpan name) |
| { |
| 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, MediaInput::Commands::RenameInput::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // index: int8u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), index)); |
| // name: charString |
| SuccessOrExit(err = writer->PutString(TLV::ContextTag(argSeqNumber++), name)); |
| |
| 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 MediaInputCluster::SelectInput(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, |
| uint8_t index) |
| { |
| 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, MediaInput::Commands::SelectInput::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // index: int8u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), index)); |
| |
| 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 MediaInputCluster::ShowInputStatus(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, MediaInput::Commands::ShowInputStatus::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| // Command takes no arguments. |
| |
| 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; |
| } |
| |
| // MediaPlayback Cluster Commands |
| CHIP_ERROR MediaPlaybackCluster::MediaFastForward(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, MediaPlayback::Commands::MediaFastForward::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| // Command takes no arguments. |
| |
| 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::MediaNext(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, MediaPlayback::Commands::MediaNext::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| // Command takes no arguments. |
| |
| 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::MediaPause(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, MediaPlayback::Commands::MediaPause::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| // Command takes no arguments. |
| |
| 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::MediaPlay(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, MediaPlayback::Commands::MediaPlay::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| // Command takes no arguments. |
| |
| 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(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, MediaPlayback::Commands::MediaPrevious::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| // Command takes no arguments. |
| |
| 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::MediaRewind(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, MediaPlayback::Commands::MediaRewind::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| // Command takes no arguments. |
| |
| 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::MediaSeek(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, |
| uint64_t position) |
| { |
| 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, MediaPlayback::Commands::MediaSeek::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // position: int64u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), position)); |
| |
| 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::MediaSkipBackward(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback, uint64_t deltaPositionMilliseconds) |
| { |
| 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, MediaPlayback::Commands::MediaSkipBackward::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // deltaPositionMilliseconds: int64u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), deltaPositionMilliseconds)); |
| |
| 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::MediaSkipForward(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback, uint64_t deltaPositionMilliseconds) |
| { |
| 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, MediaPlayback::Commands::MediaSkipForward::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // deltaPositionMilliseconds: int64u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), deltaPositionMilliseconds)); |
| |
| 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::MediaStartOver(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, MediaPlayback::Commands::MediaStartOver::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| // Command takes no arguments. |
| |
| 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::MediaStop(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, MediaPlayback::Commands::MediaStop::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| // Command takes no arguments. |
| |
| 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; |
| } |
| |
| // ModeSelect Cluster Commands |
| CHIP_ERROR ModeSelectCluster::ChangeToMode(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, |
| uint8_t newMode) |
| { |
| 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, ModeSelect::Commands::ChangeToMode::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // newMode: int8u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), newMode)); |
| |
| 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; |
| } |
| |
| // NetworkCommissioning Cluster Commands |
| CHIP_ERROR NetworkCommissioningCluster::AddOrUpdateThreadNetwork(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback, |
| chip::ByteSpan operationalDataset, uint64_t breadcrumb) |
| { |
| 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, |
| NetworkCommissioning::Commands::AddOrUpdateThreadNetwork::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // operationalDataset: octetString |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), operationalDataset)); |
| // breadcrumb: int64u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), breadcrumb)); |
| |
| 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 NetworkCommissioningCluster::AddOrUpdateWiFiNetwork(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback, chip::ByteSpan ssid, |
| chip::ByteSpan credentials, uint64_t breadcrumb) |
| { |
| 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, |
| NetworkCommissioning::Commands::AddOrUpdateWiFiNetwork::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // ssid: octetString |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), ssid)); |
| // credentials: octetString |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), credentials)); |
| // breadcrumb: int64u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), breadcrumb)); |
| |
| 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 NetworkCommissioningCluster::ConnectNetwork(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback, chip::ByteSpan networkID, |
| uint64_t breadcrumb) |
| { |
| 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, |
| NetworkCommissioning::Commands::ConnectNetwork::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // networkID: octetString |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), networkID)); |
| // breadcrumb: int64u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), breadcrumb)); |
| |
| 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 NetworkCommissioningCluster::RemoveNetwork(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback, chip::ByteSpan networkID, |
| uint64_t breadcrumb) |
| { |
| 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, NetworkCommissioning::Commands::RemoveNetwork::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // networkID: octetString |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), networkID)); |
| // breadcrumb: int64u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), breadcrumb)); |
| |
| 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 NetworkCommissioningCluster::ReorderNetwork(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback, chip::ByteSpan networkID, |
| uint8_t networkIndex, uint64_t breadcrumb) |
| { |
| 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, |
| NetworkCommissioning::Commands::ReorderNetwork::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // networkID: octetString |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), networkID)); |
| // networkIndex: int8u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), networkIndex)); |
| // breadcrumb: int64u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), breadcrumb)); |
| |
| 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 NetworkCommissioningCluster::ScanNetworks(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback, chip::ByteSpan ssid, |
| uint64_t breadcrumb) |
| { |
| 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, NetworkCommissioning::Commands::ScanNetworks::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // ssid: octetString |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), ssid)); |
| // breadcrumb: int64u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), breadcrumb)); |
| |
| 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; |
| } |
| |
| // OtaSoftwareUpdateProvider Cluster Commands |
| CHIP_ERROR OtaSoftwareUpdateProviderCluster::ApplyUpdateRequest(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback, |
| chip::ByteSpan updateToken, uint32_t newVersion) |
| { |
| 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, |
| OtaSoftwareUpdateProvider::Commands::ApplyUpdateRequest::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // updateToken: octetString |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), updateToken)); |
| // newVersion: int32u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), newVersion)); |
| |
| 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 OtaSoftwareUpdateProviderCluster::NotifyUpdateApplied(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback, |
| chip::ByteSpan updateToken, uint32_t softwareVersion) |
| { |
| 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, |
| OtaSoftwareUpdateProvider::Commands::NotifyUpdateApplied::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // updateToken: octetString |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), updateToken)); |
| // softwareVersion: int32u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), softwareVersion)); |
| |
| 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 OtaSoftwareUpdateProviderCluster::QueryImage(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback, chip::VendorId vendorId, |
| uint16_t productId, uint32_t softwareVersion, uint8_t protocolsSupported, |
| uint16_t hardwareVersion, chip::CharSpan location, bool requestorCanConsent, |
| chip::ByteSpan metadataForProvider) |
| { |
| 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, |
| OtaSoftwareUpdateProvider::Commands::QueryImage::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // vendorId: vendorId |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), vendorId)); |
| // productId: int16u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), productId)); |
| // softwareVersion: int32u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), softwareVersion)); |
| // protocolsSupported: OTADownloadProtocol |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), protocolsSupported)); |
| // hardwareVersion: int16u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), hardwareVersion)); |
| // location: charString |
| SuccessOrExit(err = writer->PutString(TLV::ContextTag(argSeqNumber++), location)); |
| // requestorCanConsent: boolean |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), requestorCanConsent)); |
| // metadataForProvider: octetString |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), metadataForProvider)); |
| |
| 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; |
| } |
| |
| // OtaSoftwareUpdateRequestor Cluster Commands |
| CHIP_ERROR OtaSoftwareUpdateRequestorCluster::AnnounceOtaProvider(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback, |
| chip::NodeId providerNodeId, chip::VendorId vendorId, |
| uint8_t announcementReason, chip::ByteSpan metadataForNode, |
| chip::EndpointId endpoint) |
| { |
| 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, |
| OtaSoftwareUpdateRequestor::Commands::AnnounceOtaProvider::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // providerNodeId: nodeId |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), providerNodeId)); |
| // vendorId: vendorId |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), vendorId)); |
| // announcementReason: OTAAnnouncementReason |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), announcementReason)); |
| // metadataForNode: octetString |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), metadataForNode)); |
| // endpoint: endpointNo |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), endpoint)); |
| |
| 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; |
| } |
| |
| // OccupancySensing Cluster Commands |
| |
| // OnOff Cluster Commands |
| CHIP_ERROR OnOffCluster::Off(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, OnOff::Commands::Off::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| // Command takes no arguments. |
| |
| 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(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, |
| uint8_t effectId, uint8_t effectVariant) |
| { |
| 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, OnOff::Commands::OffWithEffect::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // effectId: onOffEffectIdentifier |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), effectId)); |
| // effectVariant: onOffDelayedAllOffEffectVariant |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), effectVariant)); |
| |
| 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::On(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, OnOff::Commands::On::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| // Command takes no arguments. |
| |
| 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::OnWithRecallGlobalScene(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, OnOff::Commands::OnWithRecallGlobalScene::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| // Command takes no arguments. |
| |
| 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::OnWithTimedOff(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, |
| uint8_t onOffControl, uint16_t onTime, uint16_t offWaitTime) |
| { |
| 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, OnOff::Commands::OnWithTimedOff::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // onOffControl: onOffControl |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), onOffControl)); |
| // onTime: int16u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), onTime)); |
| // offWaitTime: int16u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), offWaitTime)); |
| |
| 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::Toggle(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, OnOff::Commands::Toggle::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| // Command takes no arguments. |
| |
| 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; |
| } |
| |
| // OnOffSwitchConfiguration Cluster Commands |
| |
| // OperationalCredentials Cluster Commands |
| 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; |
| 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, OperationalCredentials::Commands::AddNOC::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // NOCValue: octetString |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), NOCValue)); |
| // ICACValue: octetString |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), ICACValue)); |
| // IPKValue: octetString |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), IPKValue)); |
| // caseAdminNode: nodeId |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), caseAdminNode)); |
| // adminVendorId: int16u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), adminVendorId)); |
| |
| 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 OperationalCredentialsCluster::AddTrustedRootCertificate(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback, |
| chip::ByteSpan rootCertificate) |
| { |
| 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, |
| OperationalCredentials::Commands::AddTrustedRootCertificate::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // rootCertificate: octetString |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), rootCertificate)); |
| |
| 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 OperationalCredentialsCluster::AttestationRequest(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback, |
| chip::ByteSpan attestationNonce) |
| { |
| 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, |
| OperationalCredentials::Commands::AttestationRequest::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // attestationNonce: octetString |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), attestationNonce)); |
| |
| 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 OperationalCredentialsCluster::CertificateChainRequest(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback, uint8_t certificateType) |
| { |
| 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, |
| OperationalCredentials::Commands::CertificateChainRequest::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // certificateType: int8u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), certificateType)); |
| |
| 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 OperationalCredentialsCluster::OpCSRRequest(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback, chip::ByteSpan CSRNonce) |
| { |
| 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, |
| OperationalCredentials::Commands::OpCSRRequest::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // CSRNonce: octetString |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), CSRNonce)); |
| |
| 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 OperationalCredentialsCluster::RemoveFabric(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback, uint8_t fabricIndex) |
| { |
| 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, |
| OperationalCredentials::Commands::RemoveFabric::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // fabricIndex: int8u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), fabricIndex)); |
| |
| 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 OperationalCredentialsCluster::RemoveTrustedRootCertificate(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback, |
| chip::ByteSpan trustedRootIdentifier) |
| { |
| 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, |
| OperationalCredentials::Commands::RemoveTrustedRootCertificate::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // trustedRootIdentifier: octetString |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), trustedRootIdentifier)); |
| |
| 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 OperationalCredentialsCluster::UpdateFabricLabel(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback, chip::CharSpan label) |
| { |
| 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, |
| OperationalCredentials::Commands::UpdateFabricLabel::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // label: charString |
| SuccessOrExit(err = writer->PutString(TLV::ContextTag(argSeqNumber++), label)); |
| |
| 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 OperationalCredentialsCluster::UpdateNOC(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback, chip::ByteSpan NOCValue, |
| chip::ByteSpan ICACValue) |
| { |
| 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, OperationalCredentials::Commands::UpdateNOC::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // NOCValue: octetString |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), NOCValue)); |
| // ICACValue: octetString |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), ICACValue)); |
| |
| 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; |
| } |
| |
| // PowerSource Cluster Commands |
| |
| // PowerSourceConfiguration Cluster Commands |
| |
| // PressureMeasurement Cluster Commands |
| |
| // PumpConfigurationAndControl Cluster Commands |
| |
| // RelativeHumidityMeasurement Cluster Commands |
| |
| // Scenes Cluster Commands |
| CHIP_ERROR ScenesCluster::AddScene(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, |
| uint16_t groupId, uint8_t sceneId, uint16_t transitionTime, chip::CharSpan sceneName, |
| chip::ClusterId clusterId, uint8_t length, uint8_t value) |
| { |
| 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, Scenes::Commands::AddScene::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // groupId: int16u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), groupId)); |
| // sceneId: int8u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), sceneId)); |
| // transitionTime: int16u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), transitionTime)); |
| // sceneName: charString |
| SuccessOrExit(err = writer->PutString(TLV::ContextTag(argSeqNumber++), sceneName)); |
| // clusterId: clusterId |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), clusterId)); |
| // length: int8u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), length)); |
| // value: int8u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), value)); |
| |
| 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 ScenesCluster::GetSceneMembership(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, |
| uint16_t groupId) |
| { |
| 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, Scenes::Commands::GetSceneMembership::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // groupId: int16u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), groupId)); |
| |
| 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 ScenesCluster::RecallScene(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, |
| uint16_t groupId, uint8_t sceneId, uint16_t transitionTime) |
| { |
| 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, Scenes::Commands::RecallScene::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // groupId: int16u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), groupId)); |
| // sceneId: int8u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), sceneId)); |
| // transitionTime: int16u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), transitionTime)); |
| |
| 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 ScenesCluster::RemoveAllScenes(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, |
| uint16_t groupId) |
| { |
| 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, Scenes::Commands::RemoveAllScenes::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // groupId: int16u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), groupId)); |
| |
| 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 ScenesCluster::RemoveScene(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, |
| uint16_t groupId, uint8_t sceneId) |
| { |
| 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, Scenes::Commands::RemoveScene::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // groupId: int16u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), groupId)); |
| // sceneId: int8u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), sceneId)); |
| |
| 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 ScenesCluster::StoreScene(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, |
| uint16_t groupId, uint8_t sceneId) |
| { |
| 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, Scenes::Commands::StoreScene::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // groupId: int16u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), groupId)); |
| // sceneId: int8u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), sceneId)); |
| |
| 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 ScenesCluster::ViewScene(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, |
| uint16_t groupId, uint8_t sceneId) |
| { |
| 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, Scenes::Commands::ViewScene::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // groupId: int16u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), groupId)); |
| // sceneId: int8u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), sceneId)); |
| |
| 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; |
| } |
| |
| // SoftwareDiagnostics Cluster Commands |
| CHIP_ERROR SoftwareDiagnosticsCluster::ResetWatermarks(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, |
| SoftwareDiagnostics::Commands::ResetWatermarks::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| // Command takes no arguments. |
| |
| 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; |
| } |
| |
| // Switch Cluster Commands |
| |
| // TargetNavigator Cluster Commands |
| CHIP_ERROR TargetNavigatorCluster::NavigateTarget(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback, uint8_t target, chip::CharSpan data) |
| { |
| 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, TargetNavigator::Commands::NavigateTarget::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // target: int8u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), target)); |
| // data: charString |
| SuccessOrExit(err = writer->PutString(TLV::ContextTag(argSeqNumber++), data)); |
| |
| 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; |
| } |
| |
| // TemperatureMeasurement Cluster Commands |
| |
| // TestCluster Cluster Commands |
| CHIP_ERROR TestClusterCluster::SimpleStructEchoRequest(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback, uint8_t a, bool b, uint8_t c, |
| chip::ByteSpan d, chip::CharSpan e, uint8_t f, float g, double h) |
| { |
| 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, |
| TestCluster::Commands::SimpleStructEchoRequest::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // a: int8u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), a)); |
| // b: boolean |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), b)); |
| // c: simpleEnum |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), c)); |
| // d: octetString |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), d)); |
| // e: charString |
| SuccessOrExit(err = writer->PutString(TLV::ContextTag(argSeqNumber++), e)); |
| // f: simpleBitmap |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), f)); |
| // g: single |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), g)); |
| // h: double |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), h)); |
| |
| 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 TestClusterCluster::Test(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, TestCluster::Commands::Test::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| // Command takes no arguments. |
| |
| 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 TestClusterCluster::TestAddArguments(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, |
| uint8_t arg1, uint8_t arg2) |
| { |
| 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, TestCluster::Commands::TestAddArguments::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // arg1: int8u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), arg1)); |
| // arg2: int8u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), arg2)); |
| |
| 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 TestClusterCluster::TestEnumsRequest(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, |
| chip::VendorId arg1, uint8_t arg2) |
| { |
| 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, TestCluster::Commands::TestEnumsRequest::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // arg1: vendorId |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), arg1)); |
| // arg2: simpleEnum |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), arg2)); |
| |
| 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 TestClusterCluster::TestListInt8UArgumentRequest(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback, uint8_t arg1) |
| { |
| 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, |
| TestCluster::Commands::TestListInt8UArgumentRequest::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // arg1: int8u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), arg1)); |
| |
| 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 TestClusterCluster::TestListInt8UReverseRequest(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback, uint8_t arg1) |
| { |
| 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, |
| TestCluster::Commands::TestListInt8UReverseRequest::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // arg1: int8u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), arg1)); |
| |
| 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 TestClusterCluster::TestListNestedStructListArgumentRequest(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback, uint8_t a, bool b, |
| uint32_t e, chip::ByteSpan f, uint8_t g) |
| { |
| 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, |
| TestCluster::Commands::TestListNestedStructListArgumentRequest::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // a: int8u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), a)); |
| // b: boolean |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), b)); |
| // e: int32u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), e)); |
| // f: octetString |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), f)); |
| // g: int8u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), g)); |
| |
| 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 TestClusterCluster::TestListStructArgumentRequest(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback, uint8_t a, bool b, uint8_t c, |
| chip::ByteSpan d, chip::CharSpan e, uint8_t f, float g, double h) |
| { |
| 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, |
| TestCluster::Commands::TestListStructArgumentRequest::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // a: int8u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), a)); |
| // b: boolean |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), b)); |
| // c: simpleEnum |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), c)); |
| // d: octetString |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), d)); |
| // e: charString |
| SuccessOrExit(err = writer->PutString(TLV::ContextTag(argSeqNumber++), e)); |
| // f: simpleBitmap |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), f)); |
| // g: single |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), g)); |
| // h: double |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), h)); |
| |
| 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 TestClusterCluster::TestNestedStructArgumentRequest(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback, uint8_t a, bool b) |
| { |
| 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, |
| TestCluster::Commands::TestNestedStructArgumentRequest::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // a: int8u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), a)); |
| // b: boolean |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), b)); |
| |
| 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 TestClusterCluster::TestNestedStructListArgumentRequest(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback, uint8_t a, bool b, |
| uint32_t e, chip::ByteSpan f, uint8_t g) |
| { |
| 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, |
| TestCluster::Commands::TestNestedStructListArgumentRequest::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // a: int8u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), a)); |
| // b: boolean |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), b)); |
| // e: int32u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), e)); |
| // f: octetString |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), f)); |
| // g: int8u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), g)); |
| |
| 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 TestClusterCluster::TestNotHandled(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, TestCluster::Commands::TestNotHandled::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| // Command takes no arguments. |
| |
| 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 TestClusterCluster::TestNullableOptionalRequest(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback, uint8_t arg1) |
| { |
| 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, |
| TestCluster::Commands::TestNullableOptionalRequest::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // arg1: int8u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), arg1)); |
| |
| 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 TestClusterCluster::TestSimpleOptionalArgumentRequest(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback, bool arg1) |
| { |
| 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, |
| TestCluster::Commands::TestSimpleOptionalArgumentRequest::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // arg1: boolean |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), arg1)); |
| |
| 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 TestClusterCluster::TestSpecific(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, TestCluster::Commands::TestSpecific::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| // Command takes no arguments. |
| |
| 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 TestClusterCluster::TestStructArgumentRequest(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback, uint8_t a, bool b, uint8_t c, |
| chip::ByteSpan d, chip::CharSpan e, uint8_t f, float g, double h) |
| { |
| 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, |
| TestCluster::Commands::TestStructArgumentRequest::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // a: int8u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), a)); |
| // b: boolean |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), b)); |
| // c: simpleEnum |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), c)); |
| // d: octetString |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), d)); |
| // e: charString |
| SuccessOrExit(err = writer->PutString(TLV::ContextTag(argSeqNumber++), e)); |
| // f: simpleBitmap |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), f)); |
| // g: single |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), g)); |
| // h: double |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), h)); |
| |
| 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 TestClusterCluster::TestUnknownCommand(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, TestCluster::Commands::TestUnknownCommand::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| // Command takes no arguments. |
| |
| 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 TestClusterCluster::TimedInvokeRequest(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, TestCluster::Commands::TimedInvokeRequest::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| // Command takes no arguments. |
| |
| 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; |
| } |
| |
| // Thermostat Cluster Commands |
| CHIP_ERROR ThermostatCluster::ClearWeeklySchedule(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, Thermostat::Commands::ClearWeeklySchedule::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| // Command takes no arguments. |
| |
| 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 ThermostatCluster::GetRelayStatusLog(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, Thermostat::Commands::GetRelayStatusLog::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| // Command takes no arguments. |
| |
| 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 ThermostatCluster::GetWeeklySchedule(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, |
| uint8_t daysToReturn, uint8_t modeToReturn) |
| { |
| 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, Thermostat::Commands::GetWeeklySchedule::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // daysToReturn: dayOfWeek |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), daysToReturn)); |
| // modeToReturn: modeForSequence |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), modeToReturn)); |
| |
| 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 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; |
| 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, Thermostat::Commands::SetWeeklySchedule::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // numberOfTransitionsForSequence: enum8 |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), numberOfTransitionsForSequence)); |
| // dayOfWeekForSequence: dayOfWeek |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), dayOfWeekForSequence)); |
| // modeForSequence: modeForSequence |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), modeForSequence)); |
| // payload: int8u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), payload)); |
| |
| 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 ThermostatCluster::SetpointRaiseLower(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, |
| uint8_t mode, int8_t amount) |
| { |
| 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, Thermostat::Commands::SetpointRaiseLower::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // mode: setpointAdjustMode |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), mode)); |
| // amount: int8s |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), amount)); |
| |
| 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; |
| } |
| |
| // ThermostatUserInterfaceConfiguration Cluster Commands |
| |
| // ThreadNetworkDiagnostics Cluster Commands |
| CHIP_ERROR ThreadNetworkDiagnosticsCluster::ResetCounts(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, |
| ThreadNetworkDiagnostics::Commands::ResetCounts::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| // Command takes no arguments. |
| |
| 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; |
| } |
| |
| // UserLabel Cluster Commands |
| |
| // WakeOnLan Cluster Commands |
| |
| // WiFiNetworkDiagnostics Cluster Commands |
| CHIP_ERROR WiFiNetworkDiagnosticsCluster::ResetCounts(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, WiFiNetworkDiagnostics::Commands::ResetCounts::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| // Command takes no arguments. |
| |
| 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; |
| } |
| |
| // WindowCovering Cluster Commands |
| CHIP_ERROR WindowCoveringCluster::DownOrClose(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, WindowCovering::Commands::DownOrClose::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| // Command takes no arguments. |
| |
| 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 WindowCoveringCluster::GoToLiftPercentage(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback, uint8_t liftPercentageValue, |
| uint16_t liftPercent100thsValue) |
| { |
| 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, WindowCovering::Commands::GoToLiftPercentage::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // liftPercentageValue: int8u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), liftPercentageValue)); |
| // liftPercent100thsValue: int16u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), liftPercent100thsValue)); |
| |
| 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 WindowCoveringCluster::GoToLiftValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, |
| uint16_t liftValue) |
| { |
| 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, WindowCovering::Commands::GoToLiftValue::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // liftValue: int16u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), liftValue)); |
| |
| 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 WindowCoveringCluster::GoToTiltPercentage(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback, uint8_t tiltPercentageValue, |
| uint16_t tiltPercent100thsValue) |
| { |
| 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, WindowCovering::Commands::GoToTiltPercentage::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // tiltPercentageValue: int8u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), tiltPercentageValue)); |
| // tiltPercent100thsValue: int16u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), tiltPercent100thsValue)); |
| |
| 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 WindowCoveringCluster::GoToTiltValue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, |
| uint16_t tiltValue) |
| { |
| 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, WindowCovering::Commands::GoToTiltValue::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); |
| // tiltValue: int16u |
| SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), tiltValue)); |
| |
| 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 WindowCoveringCluster::StopMotion(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, WindowCovering::Commands::StopMotion::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| // Command takes no arguments. |
| |
| 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 WindowCoveringCluster::UpOrOpen(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, WindowCovering::Commands::UpOrOpen::Id, |
| (app::CommandPathFlags::kEndpointIdValid) }; |
| |
| CommandSenderHandle sender( |
| Platform::New<app::CommandSender>(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); |
| |
| VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); |
| |
| SuccessOrExit(err = sender->PrepareCommand(cmdParams)); |
| |
| // Command takes no arguments. |
| |
| 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; |
| } |
| |
| } // namespace Controller |
| } // namespace chip |
