| /* |
| * |
| * 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/chip-zcl-zpro-codec-api.h> |
| #include <support/ReturnMacros.h> |
| |
| namespace chip { |
| 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. |
| |
| // BarrierControl Cluster Commands |
| CHIP_ERROR BarrierControlCluster::BarrierControlGoToPercent(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback, uint8_t percentOpen) |
| { |
| #ifdef CHIP_APP_USE_INTERACTION_MODEL |
| VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE); |
| (void) onCompletion; |
| |
| app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kBarrierControlGoToPercentCommandId, |
| (chip::app::Command::kCommandPathFlag_EndpointIdValid) }; |
| app::Command * ZCLcommand = mDevice->GetCommandSender(); |
| |
| TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter(); |
| |
| TLV::TLVType dummyType = TLV::kTLVType_NotSpecified; |
| ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType)); |
| |
| uint8_t argSeqNumber = 0; |
| // percentOpen: int8u |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), percentOpen)); |
| |
| ReturnErrorOnFailure(writer.EndContainer(dummyType)); |
| ReturnErrorOnFailure(writer.Finalize()); |
| ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams)); |
| |
| return mDevice->SendCommands(); |
| #else |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = |
| encodeBarrierControlClusterBarrierControlGoToPercentCommand(seqNum, mEndpoint, percentOpen); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| #endif |
| } |
| |
| CHIP_ERROR BarrierControlCluster::BarrierControlStop(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback) |
| { |
| #ifdef CHIP_APP_USE_INTERACTION_MODEL |
| VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE); |
| (void) onCompletion; |
| |
| app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kBarrierControlStopCommandId, |
| (chip::app::Command::kCommandPathFlag_EndpointIdValid) }; |
| app::Command * ZCLcommand = mDevice->GetCommandSender(); |
| |
| TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter(); |
| |
| TLV::TLVType dummyType = TLV::kTLVType_NotSpecified; |
| ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType)); |
| |
| // Command takes no arguments. |
| |
| ReturnErrorOnFailure(writer.EndContainer(dummyType)); |
| ReturnErrorOnFailure(writer.Finalize()); |
| ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams)); |
| |
| return mDevice->SendCommands(); |
| #else |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeBarrierControlClusterBarrierControlStopCommand(seqNum, mEndpoint); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| #endif |
| } |
| |
| // BarrierControl Cluster Attributes |
| CHIP_ERROR BarrierControlCluster::DiscoverAttributes(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeBarrierControlClusterDiscoverAttributes(seqNum, mEndpoint); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| CHIP_ERROR BarrierControlCluster::ReadAttributeBarrierMovingState(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeBarrierControlClusterReadBarrierMovingStateAttribute(seqNum, mEndpoint); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| |
| CHIP_ERROR BarrierControlCluster::ReadAttributeBarrierSafetyStatus(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeBarrierControlClusterReadBarrierSafetyStatusAttribute(seqNum, mEndpoint); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| |
| CHIP_ERROR BarrierControlCluster::ReadAttributeBarrierCapabilities(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeBarrierControlClusterReadBarrierCapabilitiesAttribute(seqNum, mEndpoint); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| |
| CHIP_ERROR BarrierControlCluster::ReadAttributeBarrierPosition(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeBarrierControlClusterReadBarrierPositionAttribute(seqNum, mEndpoint); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| |
| CHIP_ERROR BarrierControlCluster::ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeBarrierControlClusterReadClusterRevisionAttribute(seqNum, mEndpoint); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| |
| // Basic Cluster Commands |
| CHIP_ERROR BasicCluster::MfgSpecificPing(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback) |
| { |
| #ifdef CHIP_APP_USE_INTERACTION_MODEL |
| VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE); |
| (void) onCompletion; |
| |
| app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kMfgSpecificPingCommandId, |
| (chip::app::Command::kCommandPathFlag_EndpointIdValid) }; |
| app::Command * ZCLcommand = mDevice->GetCommandSender(); |
| |
| TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter(); |
| |
| TLV::TLVType dummyType = TLV::kTLVType_NotSpecified; |
| ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType)); |
| |
| // Command takes no arguments. |
| |
| ReturnErrorOnFailure(writer.EndContainer(dummyType)); |
| ReturnErrorOnFailure(writer.Finalize()); |
| ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams)); |
| |
| return mDevice->SendCommands(); |
| #else |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeBasicClusterMfgSpecificPingCommand(seqNum, mEndpoint); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| #endif |
| } |
| |
| CHIP_ERROR BasicCluster::ResetToFactoryDefaults(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback) |
| { |
| #ifdef CHIP_APP_USE_INTERACTION_MODEL |
| VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE); |
| (void) onCompletion; |
| |
| app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kResetToFactoryDefaultsCommandId, |
| (chip::app::Command::kCommandPathFlag_EndpointIdValid) }; |
| app::Command * ZCLcommand = mDevice->GetCommandSender(); |
| |
| TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter(); |
| |
| TLV::TLVType dummyType = TLV::kTLVType_NotSpecified; |
| ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType)); |
| |
| // Command takes no arguments. |
| |
| ReturnErrorOnFailure(writer.EndContainer(dummyType)); |
| ReturnErrorOnFailure(writer.Finalize()); |
| ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams)); |
| |
| return mDevice->SendCommands(); |
| #else |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeBasicClusterResetToFactoryDefaultsCommand(seqNum, mEndpoint); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| #endif |
| } |
| |
| // Basic Cluster Attributes |
| CHIP_ERROR BasicCluster::DiscoverAttributes(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeBasicClusterDiscoverAttributes(seqNum, mEndpoint); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| CHIP_ERROR BasicCluster::ReadAttributeZclVersion(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeBasicClusterReadZclVersionAttribute(seqNum, mEndpoint); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| |
| CHIP_ERROR BasicCluster::ReadAttributePowerSource(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeBasicClusterReadPowerSourceAttribute(seqNum, mEndpoint); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| |
| CHIP_ERROR BasicCluster::ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeBasicClusterReadClusterRevisionAttribute(seqNum, mEndpoint); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| |
| // 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) |
| { |
| #ifdef CHIP_APP_USE_INTERACTION_MODEL |
| VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE); |
| (void) onCompletion; |
| |
| app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kBindCommandId, |
| (chip::app::Command::kCommandPathFlag_EndpointIdValid) }; |
| app::Command * ZCLcommand = mDevice->GetCommandSender(); |
| |
| TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter(); |
| |
| TLV::TLVType dummyType = TLV::kTLVType_NotSpecified; |
| ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType)); |
| |
| uint8_t argSeqNumber = 0; |
| // nodeId: nodeId |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), nodeId)); |
| // groupId: groupId |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), groupId)); |
| // endpointId: endpointId |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), endpointId)); |
| // clusterId: clusterId |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), clusterId)); |
| |
| ReturnErrorOnFailure(writer.EndContainer(dummyType)); |
| ReturnErrorOnFailure(writer.Finalize()); |
| ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams)); |
| |
| return mDevice->SendCommands(); |
| #else |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeBindingClusterBindCommand(seqNum, mEndpoint, nodeId, groupId, endpointId, clusterId); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| #endif |
| } |
| |
| CHIP_ERROR BindingCluster::Unbind(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, |
| chip::NodeId nodeId, chip::GroupId groupId, chip::EndpointId endpointId, |
| chip::ClusterId clusterId) |
| { |
| #ifdef CHIP_APP_USE_INTERACTION_MODEL |
| VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE); |
| (void) onCompletion; |
| |
| app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kUnbindCommandId, |
| (chip::app::Command::kCommandPathFlag_EndpointIdValid) }; |
| app::Command * ZCLcommand = mDevice->GetCommandSender(); |
| |
| TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter(); |
| |
| TLV::TLVType dummyType = TLV::kTLVType_NotSpecified; |
| ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType)); |
| |
| uint8_t argSeqNumber = 0; |
| // nodeId: nodeId |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), nodeId)); |
| // groupId: groupId |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), groupId)); |
| // endpointId: endpointId |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), endpointId)); |
| // clusterId: clusterId |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), clusterId)); |
| |
| ReturnErrorOnFailure(writer.EndContainer(dummyType)); |
| ReturnErrorOnFailure(writer.Finalize()); |
| ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams)); |
| |
| return mDevice->SendCommands(); |
| #else |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = |
| encodeBindingClusterUnbindCommand(seqNum, mEndpoint, nodeId, groupId, endpointId, clusterId); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| #endif |
| } |
| |
| // Binding Cluster Attributes |
| CHIP_ERROR BindingCluster::DiscoverAttributes(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeBindingClusterDiscoverAttributes(seqNum, mEndpoint); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| CHIP_ERROR BindingCluster::ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeBindingClusterReadClusterRevisionAttribute(seqNum, mEndpoint); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| |
| // ColorControl Cluster Commands |
| CHIP_ERROR ColorControlCluster::MoveColor(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, |
| int16_t rateX, int16_t rateY, uint8_t optionsMask, uint8_t optionsOverride) |
| { |
| #ifdef CHIP_APP_USE_INTERACTION_MODEL |
| VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE); |
| (void) onCompletion; |
| |
| app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kMoveColorCommandId, |
| (chip::app::Command::kCommandPathFlag_EndpointIdValid) }; |
| app::Command * ZCLcommand = mDevice->GetCommandSender(); |
| |
| TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter(); |
| |
| TLV::TLVType dummyType = TLV::kTLVType_NotSpecified; |
| ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType)); |
| |
| uint8_t argSeqNumber = 0; |
| // rateX: int16s |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), rateX)); |
| // rateY: int16s |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), rateY)); |
| // optionsMask: bitmap8 |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), optionsMask)); |
| // optionsOverride: bitmap8 |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), optionsOverride)); |
| |
| ReturnErrorOnFailure(writer.EndContainer(dummyType)); |
| ReturnErrorOnFailure(writer.Finalize()); |
| ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams)); |
| |
| return mDevice->SendCommands(); |
| #else |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = |
| encodeColorControlClusterMoveColorCommand(seqNum, mEndpoint, rateX, rateY, optionsMask, optionsOverride); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| #endif |
| } |
| |
| 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) |
| { |
| #ifdef CHIP_APP_USE_INTERACTION_MODEL |
| VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE); |
| (void) onCompletion; |
| |
| app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kMoveColorTemperatureCommandId, |
| (chip::app::Command::kCommandPathFlag_EndpointIdValid) }; |
| app::Command * ZCLcommand = mDevice->GetCommandSender(); |
| |
| TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter(); |
| |
| TLV::TLVType dummyType = TLV::kTLVType_NotSpecified; |
| ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType)); |
| |
| uint8_t argSeqNumber = 0; |
| // moveMode: hueMoveMode |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), moveMode)); |
| // rate: int16u |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), rate)); |
| // colorTemperatureMinimum: int16u |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), colorTemperatureMinimum)); |
| // colorTemperatureMaximum: int16u |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), colorTemperatureMaximum)); |
| // optionsMask: bitmap8 |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), optionsMask)); |
| // optionsOverride: bitmap8 |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), optionsOverride)); |
| |
| ReturnErrorOnFailure(writer.EndContainer(dummyType)); |
| ReturnErrorOnFailure(writer.Finalize()); |
| ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams)); |
| |
| return mDevice->SendCommands(); |
| #else |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeColorControlClusterMoveColorTemperatureCommand( |
| seqNum, mEndpoint, moveMode, rate, colorTemperatureMinimum, colorTemperatureMaximum, optionsMask, optionsOverride); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| #endif |
| } |
| |
| CHIP_ERROR ColorControlCluster::MoveHue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, |
| uint8_t moveMode, uint8_t rate, uint8_t optionsMask, uint8_t optionsOverride) |
| { |
| #ifdef CHIP_APP_USE_INTERACTION_MODEL |
| VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE); |
| (void) onCompletion; |
| |
| app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kMoveHueCommandId, |
| (chip::app::Command::kCommandPathFlag_EndpointIdValid) }; |
| app::Command * ZCLcommand = mDevice->GetCommandSender(); |
| |
| TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter(); |
| |
| TLV::TLVType dummyType = TLV::kTLVType_NotSpecified; |
| ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType)); |
| |
| uint8_t argSeqNumber = 0; |
| // moveMode: hueMoveMode |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), moveMode)); |
| // rate: int8u |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), rate)); |
| // optionsMask: bitmap8 |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), optionsMask)); |
| // optionsOverride: bitmap8 |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), optionsOverride)); |
| |
| ReturnErrorOnFailure(writer.EndContainer(dummyType)); |
| ReturnErrorOnFailure(writer.Finalize()); |
| ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams)); |
| |
| return mDevice->SendCommands(); |
| #else |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = |
| encodeColorControlClusterMoveHueCommand(seqNum, mEndpoint, moveMode, rate, optionsMask, optionsOverride); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| #endif |
| } |
| |
| CHIP_ERROR ColorControlCluster::MoveSaturation(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, |
| uint8_t moveMode, uint8_t rate, uint8_t optionsMask, uint8_t optionsOverride) |
| { |
| #ifdef CHIP_APP_USE_INTERACTION_MODEL |
| VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE); |
| (void) onCompletion; |
| |
| app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kMoveSaturationCommandId, |
| (chip::app::Command::kCommandPathFlag_EndpointIdValid) }; |
| app::Command * ZCLcommand = mDevice->GetCommandSender(); |
| |
| TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter(); |
| |
| TLV::TLVType dummyType = TLV::kTLVType_NotSpecified; |
| ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType)); |
| |
| uint8_t argSeqNumber = 0; |
| // moveMode: saturationMoveMode |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), moveMode)); |
| // rate: int8u |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), rate)); |
| // optionsMask: bitmap8 |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), optionsMask)); |
| // optionsOverride: bitmap8 |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), optionsOverride)); |
| |
| ReturnErrorOnFailure(writer.EndContainer(dummyType)); |
| ReturnErrorOnFailure(writer.Finalize()); |
| ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams)); |
| |
| return mDevice->SendCommands(); |
| #else |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = |
| encodeColorControlClusterMoveSaturationCommand(seqNum, mEndpoint, moveMode, rate, optionsMask, optionsOverride); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| #endif |
| } |
| |
| 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) |
| { |
| #ifdef CHIP_APP_USE_INTERACTION_MODEL |
| VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE); |
| (void) onCompletion; |
| |
| app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kMoveToColorCommandId, |
| (chip::app::Command::kCommandPathFlag_EndpointIdValid) }; |
| app::Command * ZCLcommand = mDevice->GetCommandSender(); |
| |
| TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter(); |
| |
| TLV::TLVType dummyType = TLV::kTLVType_NotSpecified; |
| ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType)); |
| |
| uint8_t argSeqNumber = 0; |
| // colorX: int16u |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), colorX)); |
| // colorY: int16u |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), colorY)); |
| // transitionTime: int16u |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), transitionTime)); |
| // optionsMask: bitmap8 |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), optionsMask)); |
| // optionsOverride: bitmap8 |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), optionsOverride)); |
| |
| ReturnErrorOnFailure(writer.EndContainer(dummyType)); |
| ReturnErrorOnFailure(writer.Finalize()); |
| ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams)); |
| |
| return mDevice->SendCommands(); |
| #else |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeColorControlClusterMoveToColorCommand(seqNum, mEndpoint, colorX, colorY, |
| transitionTime, optionsMask, optionsOverride); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| #endif |
| } |
| |
| CHIP_ERROR ColorControlCluster::MoveToColorTemperature(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback, uint16_t colorTemperature, |
| uint16_t transitionTime, uint8_t optionsMask, uint8_t optionsOverride) |
| { |
| #ifdef CHIP_APP_USE_INTERACTION_MODEL |
| VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE); |
| (void) onCompletion; |
| |
| app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kMoveToColorTemperatureCommandId, |
| (chip::app::Command::kCommandPathFlag_EndpointIdValid) }; |
| app::Command * ZCLcommand = mDevice->GetCommandSender(); |
| |
| TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter(); |
| |
| TLV::TLVType dummyType = TLV::kTLVType_NotSpecified; |
| ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType)); |
| |
| uint8_t argSeqNumber = 0; |
| // colorTemperature: int16u |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), colorTemperature)); |
| // transitionTime: int16u |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), transitionTime)); |
| // optionsMask: bitmap8 |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), optionsMask)); |
| // optionsOverride: bitmap8 |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), optionsOverride)); |
| |
| ReturnErrorOnFailure(writer.EndContainer(dummyType)); |
| ReturnErrorOnFailure(writer.Finalize()); |
| ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams)); |
| |
| return mDevice->SendCommands(); |
| #else |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeColorControlClusterMoveToColorTemperatureCommand( |
| seqNum, mEndpoint, colorTemperature, transitionTime, optionsMask, optionsOverride); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| #endif |
| } |
| |
| 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) |
| { |
| #ifdef CHIP_APP_USE_INTERACTION_MODEL |
| VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE); |
| (void) onCompletion; |
| |
| app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kMoveToHueCommandId, |
| (chip::app::Command::kCommandPathFlag_EndpointIdValid) }; |
| app::Command * ZCLcommand = mDevice->GetCommandSender(); |
| |
| TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter(); |
| |
| TLV::TLVType dummyType = TLV::kTLVType_NotSpecified; |
| ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType)); |
| |
| uint8_t argSeqNumber = 0; |
| // hue: int8u |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), hue)); |
| // direction: hueDirection |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), direction)); |
| // transitionTime: int16u |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), transitionTime)); |
| // optionsMask: bitmap8 |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), optionsMask)); |
| // optionsOverride: bitmap8 |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), optionsOverride)); |
| |
| ReturnErrorOnFailure(writer.EndContainer(dummyType)); |
| ReturnErrorOnFailure(writer.Finalize()); |
| ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams)); |
| |
| return mDevice->SendCommands(); |
| #else |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = |
| encodeColorControlClusterMoveToHueCommand(seqNum, mEndpoint, hue, direction, transitionTime, optionsMask, optionsOverride); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| #endif |
| } |
| |
| 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) |
| { |
| #ifdef CHIP_APP_USE_INTERACTION_MODEL |
| VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE); |
| (void) onCompletion; |
| |
| app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kMoveToHueAndSaturationCommandId, |
| (chip::app::Command::kCommandPathFlag_EndpointIdValid) }; |
| app::Command * ZCLcommand = mDevice->GetCommandSender(); |
| |
| TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter(); |
| |
| TLV::TLVType dummyType = TLV::kTLVType_NotSpecified; |
| ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType)); |
| |
| uint8_t argSeqNumber = 0; |
| // hue: int8u |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), hue)); |
| // saturation: int8u |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), saturation)); |
| // transitionTime: int16u |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), transitionTime)); |
| // optionsMask: bitmap8 |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), optionsMask)); |
| // optionsOverride: bitmap8 |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), optionsOverride)); |
| |
| ReturnErrorOnFailure(writer.EndContainer(dummyType)); |
| ReturnErrorOnFailure(writer.Finalize()); |
| ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams)); |
| |
| return mDevice->SendCommands(); |
| #else |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeColorControlClusterMoveToHueAndSaturationCommand( |
| seqNum, mEndpoint, hue, saturation, transitionTime, optionsMask, optionsOverride); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| #endif |
| } |
| |
| CHIP_ERROR ColorControlCluster::MoveToSaturation(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, |
| uint8_t saturation, uint16_t transitionTime, uint8_t optionsMask, |
| uint8_t optionsOverride) |
| { |
| #ifdef CHIP_APP_USE_INTERACTION_MODEL |
| VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE); |
| (void) onCompletion; |
| |
| app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kMoveToSaturationCommandId, |
| (chip::app::Command::kCommandPathFlag_EndpointIdValid) }; |
| app::Command * ZCLcommand = mDevice->GetCommandSender(); |
| |
| TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter(); |
| |
| TLV::TLVType dummyType = TLV::kTLVType_NotSpecified; |
| ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType)); |
| |
| uint8_t argSeqNumber = 0; |
| // saturation: int8u |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), saturation)); |
| // transitionTime: int16u |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), transitionTime)); |
| // optionsMask: bitmap8 |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), optionsMask)); |
| // optionsOverride: bitmap8 |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), optionsOverride)); |
| |
| ReturnErrorOnFailure(writer.EndContainer(dummyType)); |
| ReturnErrorOnFailure(writer.Finalize()); |
| ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams)); |
| |
| return mDevice->SendCommands(); |
| #else |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeColorControlClusterMoveToSaturationCommand( |
| seqNum, mEndpoint, saturation, transitionTime, optionsMask, optionsOverride); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| #endif |
| } |
| |
| 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) |
| { |
| #ifdef CHIP_APP_USE_INTERACTION_MODEL |
| VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE); |
| (void) onCompletion; |
| |
| app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kStepColorCommandId, |
| (chip::app::Command::kCommandPathFlag_EndpointIdValid) }; |
| app::Command * ZCLcommand = mDevice->GetCommandSender(); |
| |
| TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter(); |
| |
| TLV::TLVType dummyType = TLV::kTLVType_NotSpecified; |
| ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType)); |
| |
| uint8_t argSeqNumber = 0; |
| // stepX: int16s |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), stepX)); |
| // stepY: int16s |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), stepY)); |
| // transitionTime: int16u |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), transitionTime)); |
| // optionsMask: bitmap8 |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), optionsMask)); |
| // optionsOverride: bitmap8 |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), optionsOverride)); |
| |
| ReturnErrorOnFailure(writer.EndContainer(dummyType)); |
| ReturnErrorOnFailure(writer.Finalize()); |
| ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams)); |
| |
| return mDevice->SendCommands(); |
| #else |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = |
| encodeColorControlClusterStepColorCommand(seqNum, mEndpoint, stepX, stepY, transitionTime, optionsMask, optionsOverride); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| #endif |
| } |
| |
| 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) |
| { |
| #ifdef CHIP_APP_USE_INTERACTION_MODEL |
| VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE); |
| (void) onCompletion; |
| |
| app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kStepColorTemperatureCommandId, |
| (chip::app::Command::kCommandPathFlag_EndpointIdValid) }; |
| app::Command * ZCLcommand = mDevice->GetCommandSender(); |
| |
| TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter(); |
| |
| TLV::TLVType dummyType = TLV::kTLVType_NotSpecified; |
| ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType)); |
| |
| uint8_t argSeqNumber = 0; |
| // stepMode: hueStepMode |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), stepMode)); |
| // stepSize: int16u |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), stepSize)); |
| // transitionTime: int16u |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), transitionTime)); |
| // colorTemperatureMinimum: int16u |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), colorTemperatureMinimum)); |
| // colorTemperatureMaximum: int16u |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), colorTemperatureMaximum)); |
| // optionsMask: bitmap8 |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), optionsMask)); |
| // optionsOverride: bitmap8 |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), optionsOverride)); |
| |
| ReturnErrorOnFailure(writer.EndContainer(dummyType)); |
| ReturnErrorOnFailure(writer.Finalize()); |
| ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams)); |
| |
| return mDevice->SendCommands(); |
| #else |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeColorControlClusterStepColorTemperatureCommand( |
| seqNum, mEndpoint, stepMode, stepSize, transitionTime, colorTemperatureMinimum, colorTemperatureMaximum, optionsMask, |
| optionsOverride); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| #endif |
| } |
| |
| 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) |
| { |
| #ifdef CHIP_APP_USE_INTERACTION_MODEL |
| VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE); |
| (void) onCompletion; |
| |
| app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kStepHueCommandId, |
| (chip::app::Command::kCommandPathFlag_EndpointIdValid) }; |
| app::Command * ZCLcommand = mDevice->GetCommandSender(); |
| |
| TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter(); |
| |
| TLV::TLVType dummyType = TLV::kTLVType_NotSpecified; |
| ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType)); |
| |
| uint8_t argSeqNumber = 0; |
| // stepMode: hueStepMode |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), stepMode)); |
| // stepSize: int8u |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), stepSize)); |
| // transitionTime: int8u |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), transitionTime)); |
| // optionsMask: bitmap8 |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), optionsMask)); |
| // optionsOverride: bitmap8 |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), optionsOverride)); |
| |
| ReturnErrorOnFailure(writer.EndContainer(dummyType)); |
| ReturnErrorOnFailure(writer.Finalize()); |
| ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams)); |
| |
| return mDevice->SendCommands(); |
| #else |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeColorControlClusterStepHueCommand(seqNum, mEndpoint, stepMode, stepSize, |
| transitionTime, optionsMask, optionsOverride); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| #endif |
| } |
| |
| 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) |
| { |
| #ifdef CHIP_APP_USE_INTERACTION_MODEL |
| VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE); |
| (void) onCompletion; |
| |
| app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kStepSaturationCommandId, |
| (chip::app::Command::kCommandPathFlag_EndpointIdValid) }; |
| app::Command * ZCLcommand = mDevice->GetCommandSender(); |
| |
| TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter(); |
| |
| TLV::TLVType dummyType = TLV::kTLVType_NotSpecified; |
| ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType)); |
| |
| uint8_t argSeqNumber = 0; |
| // stepMode: saturationStepMode |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), stepMode)); |
| // stepSize: int8u |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), stepSize)); |
| // transitionTime: int8u |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), transitionTime)); |
| // optionsMask: bitmap8 |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), optionsMask)); |
| // optionsOverride: bitmap8 |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), optionsOverride)); |
| |
| ReturnErrorOnFailure(writer.EndContainer(dummyType)); |
| ReturnErrorOnFailure(writer.Finalize()); |
| ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams)); |
| |
| return mDevice->SendCommands(); |
| #else |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeColorControlClusterStepSaturationCommand( |
| seqNum, mEndpoint, stepMode, stepSize, transitionTime, optionsMask, optionsOverride); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| #endif |
| } |
| |
| CHIP_ERROR ColorControlCluster::StopMoveStep(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, |
| uint8_t optionsMask, uint8_t optionsOverride) |
| { |
| #ifdef CHIP_APP_USE_INTERACTION_MODEL |
| VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE); |
| (void) onCompletion; |
| |
| app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kStopMoveStepCommandId, |
| (chip::app::Command::kCommandPathFlag_EndpointIdValid) }; |
| app::Command * ZCLcommand = mDevice->GetCommandSender(); |
| |
| TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter(); |
| |
| TLV::TLVType dummyType = TLV::kTLVType_NotSpecified; |
| ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType)); |
| |
| uint8_t argSeqNumber = 0; |
| // optionsMask: bitmap8 |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), optionsMask)); |
| // optionsOverride: bitmap8 |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), optionsOverride)); |
| |
| ReturnErrorOnFailure(writer.EndContainer(dummyType)); |
| ReturnErrorOnFailure(writer.Finalize()); |
| ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams)); |
| |
| return mDevice->SendCommands(); |
| #else |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = |
| encodeColorControlClusterStopMoveStepCommand(seqNum, mEndpoint, optionsMask, optionsOverride); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| #endif |
| } |
| |
| // ColorControl Cluster Attributes |
| CHIP_ERROR ColorControlCluster::DiscoverAttributes(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeColorControlClusterDiscoverAttributes(seqNum, mEndpoint); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| CHIP_ERROR ColorControlCluster::ReadAttributeCurrentHue(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeColorControlClusterReadCurrentHueAttribute(seqNum, mEndpoint); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| |
| CHIP_ERROR ColorControlCluster::ConfigureAttributeCurrentHue(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback, uint16_t minInterval, |
| uint16_t maxInterval, uint8_t change) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = |
| encodeColorControlClusterConfigureCurrentHueAttribute(seqNum, mEndpoint, minInterval, maxInterval, change); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| |
| CHIP_ERROR ColorControlCluster::ReportAttributeCurrentHue(Callback::Cancelable * onReportCallback) |
| { |
| return RequestAttributeReporting(0x0000, onReportCallback); |
| } |
| |
| CHIP_ERROR ColorControlCluster::ReadAttributeCurrentSaturation(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeColorControlClusterReadCurrentSaturationAttribute(seqNum, mEndpoint); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| |
| CHIP_ERROR ColorControlCluster::ConfigureAttributeCurrentSaturation(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback, uint16_t minInterval, |
| uint16_t maxInterval, uint8_t change) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = |
| encodeColorControlClusterConfigureCurrentSaturationAttribute(seqNum, mEndpoint, minInterval, maxInterval, change); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| |
| CHIP_ERROR ColorControlCluster::ReportAttributeCurrentSaturation(Callback::Cancelable * onReportCallback) |
| { |
| return RequestAttributeReporting(0x0001, onReportCallback); |
| } |
| |
| CHIP_ERROR ColorControlCluster::ReadAttributeRemainingTime(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeColorControlClusterReadRemainingTimeAttribute(seqNum, mEndpoint); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| |
| CHIP_ERROR ColorControlCluster::ReadAttributeCurrentX(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeColorControlClusterReadCurrentXAttribute(seqNum, mEndpoint); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| |
| CHIP_ERROR ColorControlCluster::ConfigureAttributeCurrentX(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback, uint16_t minInterval, |
| uint16_t maxInterval, uint16_t change) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = |
| encodeColorControlClusterConfigureCurrentXAttribute(seqNum, mEndpoint, minInterval, maxInterval, change); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| |
| CHIP_ERROR ColorControlCluster::ReportAttributeCurrentX(Callback::Cancelable * onReportCallback) |
| { |
| return RequestAttributeReporting(0x0003, onReportCallback); |
| } |
| |
| CHIP_ERROR ColorControlCluster::ReadAttributeCurrentY(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeColorControlClusterReadCurrentYAttribute(seqNum, mEndpoint); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| |
| CHIP_ERROR ColorControlCluster::ConfigureAttributeCurrentY(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback, uint16_t minInterval, |
| uint16_t maxInterval, uint16_t change) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = |
| encodeColorControlClusterConfigureCurrentYAttribute(seqNum, mEndpoint, minInterval, maxInterval, change); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| |
| CHIP_ERROR ColorControlCluster::ReportAttributeCurrentY(Callback::Cancelable * onReportCallback) |
| { |
| return RequestAttributeReporting(0x0004, onReportCallback); |
| } |
| |
| CHIP_ERROR ColorControlCluster::ReadAttributeDriftCompensation(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeColorControlClusterReadDriftCompensationAttribute(seqNum, mEndpoint); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| |
| CHIP_ERROR ColorControlCluster::ReadAttributeCompensationText(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeColorControlClusterReadCompensationTextAttribute(seqNum, mEndpoint); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| |
| CHIP_ERROR ColorControlCluster::ReadAttributeColorTemperature(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeColorControlClusterReadColorTemperatureAttribute(seqNum, mEndpoint); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| |
| CHIP_ERROR ColorControlCluster::ConfigureAttributeColorTemperature(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback, uint16_t minInterval, |
| uint16_t maxInterval, uint16_t change) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = |
| encodeColorControlClusterConfigureColorTemperatureAttribute(seqNum, mEndpoint, minInterval, maxInterval, change); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| |
| CHIP_ERROR ColorControlCluster::ReportAttributeColorTemperature(Callback::Cancelable * onReportCallback) |
| { |
| return RequestAttributeReporting(0x0007, onReportCallback); |
| } |
| |
| CHIP_ERROR ColorControlCluster::ReadAttributeColorMode(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeColorControlClusterReadColorModeAttribute(seqNum, mEndpoint); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| |
| CHIP_ERROR ColorControlCluster::ReadAttributeColorControlOptions(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeColorControlClusterReadColorControlOptionsAttribute(seqNum, mEndpoint); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| |
| CHIP_ERROR ColorControlCluster::WriteAttributeColorControlOptions(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback, uint8_t value) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeColorControlClusterWriteColorControlOptionsAttribute(seqNum, mEndpoint, value); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| |
| CHIP_ERROR ColorControlCluster::ReadAttributeNumberOfPrimaries(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeColorControlClusterReadNumberOfPrimariesAttribute(seqNum, mEndpoint); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| |
| CHIP_ERROR ColorControlCluster::ReadAttributePrimary1X(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeColorControlClusterReadPrimary1XAttribute(seqNum, mEndpoint); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| |
| CHIP_ERROR ColorControlCluster::ReadAttributePrimary1Y(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeColorControlClusterReadPrimary1YAttribute(seqNum, mEndpoint); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| |
| CHIP_ERROR ColorControlCluster::ReadAttributePrimary1Intensity(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeColorControlClusterReadPrimary1IntensityAttribute(seqNum, mEndpoint); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| |
| CHIP_ERROR ColorControlCluster::ReadAttributePrimary2X(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeColorControlClusterReadPrimary2XAttribute(seqNum, mEndpoint); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| |
| CHIP_ERROR ColorControlCluster::ReadAttributePrimary2Y(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeColorControlClusterReadPrimary2YAttribute(seqNum, mEndpoint); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| |
| CHIP_ERROR ColorControlCluster::ReadAttributePrimary2Intensity(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeColorControlClusterReadPrimary2IntensityAttribute(seqNum, mEndpoint); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| |
| CHIP_ERROR ColorControlCluster::ReadAttributePrimary3X(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeColorControlClusterReadPrimary3XAttribute(seqNum, mEndpoint); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| |
| CHIP_ERROR ColorControlCluster::ReadAttributePrimary3Y(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeColorControlClusterReadPrimary3YAttribute(seqNum, mEndpoint); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| |
| CHIP_ERROR ColorControlCluster::ReadAttributePrimary3Intensity(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeColorControlClusterReadPrimary3IntensityAttribute(seqNum, mEndpoint); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| |
| CHIP_ERROR ColorControlCluster::ReadAttributePrimary4X(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeColorControlClusterReadPrimary4XAttribute(seqNum, mEndpoint); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| |
| CHIP_ERROR ColorControlCluster::ReadAttributePrimary4Y(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeColorControlClusterReadPrimary4YAttribute(seqNum, mEndpoint); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| |
| CHIP_ERROR ColorControlCluster::ReadAttributePrimary4Intensity(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeColorControlClusterReadPrimary4IntensityAttribute(seqNum, mEndpoint); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| |
| CHIP_ERROR ColorControlCluster::ReadAttributePrimary5X(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeColorControlClusterReadPrimary5XAttribute(seqNum, mEndpoint); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| |
| CHIP_ERROR ColorControlCluster::ReadAttributePrimary5Y(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeColorControlClusterReadPrimary5YAttribute(seqNum, mEndpoint); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| |
| CHIP_ERROR ColorControlCluster::ReadAttributePrimary5Intensity(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeColorControlClusterReadPrimary5IntensityAttribute(seqNum, mEndpoint); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| |
| CHIP_ERROR ColorControlCluster::ReadAttributePrimary6X(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeColorControlClusterReadPrimary6XAttribute(seqNum, mEndpoint); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| |
| CHIP_ERROR ColorControlCluster::ReadAttributePrimary6Y(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeColorControlClusterReadPrimary6YAttribute(seqNum, mEndpoint); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| |
| CHIP_ERROR ColorControlCluster::ReadAttributePrimary6Intensity(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeColorControlClusterReadPrimary6IntensityAttribute(seqNum, mEndpoint); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| |
| CHIP_ERROR ColorControlCluster::ReadAttributeWhitePointX(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeColorControlClusterReadWhitePointXAttribute(seqNum, mEndpoint); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| |
| CHIP_ERROR ColorControlCluster::WriteAttributeWhitePointX(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback, uint16_t value) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeColorControlClusterWriteWhitePointXAttribute(seqNum, mEndpoint, value); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| |
| CHIP_ERROR ColorControlCluster::ReadAttributeWhitePointY(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeColorControlClusterReadWhitePointYAttribute(seqNum, mEndpoint); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| |
| CHIP_ERROR ColorControlCluster::WriteAttributeWhitePointY(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback, uint16_t value) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeColorControlClusterWriteWhitePointYAttribute(seqNum, mEndpoint, value); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| |
| CHIP_ERROR ColorControlCluster::ReadAttributeColorPointRX(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeColorControlClusterReadColorPointRXAttribute(seqNum, mEndpoint); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| |
| CHIP_ERROR ColorControlCluster::WriteAttributeColorPointRX(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback, uint16_t value) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeColorControlClusterWriteColorPointRXAttribute(seqNum, mEndpoint, value); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| |
| CHIP_ERROR ColorControlCluster::ReadAttributeColorPointRY(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeColorControlClusterReadColorPointRYAttribute(seqNum, mEndpoint); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| |
| CHIP_ERROR ColorControlCluster::WriteAttributeColorPointRY(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback, uint16_t value) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeColorControlClusterWriteColorPointRYAttribute(seqNum, mEndpoint, value); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| |
| CHIP_ERROR ColorControlCluster::ReadAttributeColorPointRIntensity(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeColorControlClusterReadColorPointRIntensityAttribute(seqNum, mEndpoint); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| |
| CHIP_ERROR ColorControlCluster::WriteAttributeColorPointRIntensity(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback, uint8_t value) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeColorControlClusterWriteColorPointRIntensityAttribute(seqNum, mEndpoint, value); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| |
| CHIP_ERROR ColorControlCluster::ReadAttributeColorPointGX(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeColorControlClusterReadColorPointGXAttribute(seqNum, mEndpoint); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| |
| CHIP_ERROR ColorControlCluster::WriteAttributeColorPointGX(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback, uint16_t value) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeColorControlClusterWriteColorPointGXAttribute(seqNum, mEndpoint, value); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| |
| CHIP_ERROR ColorControlCluster::ReadAttributeColorPointGY(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeColorControlClusterReadColorPointGYAttribute(seqNum, mEndpoint); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| |
| CHIP_ERROR ColorControlCluster::WriteAttributeColorPointGY(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback, uint16_t value) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeColorControlClusterWriteColorPointGYAttribute(seqNum, mEndpoint, value); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| |
| CHIP_ERROR ColorControlCluster::ReadAttributeColorPointGIntensity(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeColorControlClusterReadColorPointGIntensityAttribute(seqNum, mEndpoint); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| |
| CHIP_ERROR ColorControlCluster::WriteAttributeColorPointGIntensity(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback, uint8_t value) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeColorControlClusterWriteColorPointGIntensityAttribute(seqNum, mEndpoint, value); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| |
| CHIP_ERROR ColorControlCluster::ReadAttributeColorPointBX(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeColorControlClusterReadColorPointBXAttribute(seqNum, mEndpoint); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| |
| CHIP_ERROR ColorControlCluster::WriteAttributeColorPointBX(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback, uint16_t value) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeColorControlClusterWriteColorPointBXAttribute(seqNum, mEndpoint, value); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| |
| CHIP_ERROR ColorControlCluster::ReadAttributeColorPointBY(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeColorControlClusterReadColorPointBYAttribute(seqNum, mEndpoint); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| |
| CHIP_ERROR ColorControlCluster::WriteAttributeColorPointBY(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback, uint16_t value) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeColorControlClusterWriteColorPointBYAttribute(seqNum, mEndpoint, value); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| |
| CHIP_ERROR ColorControlCluster::ReadAttributeColorPointBIntensity(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeColorControlClusterReadColorPointBIntensityAttribute(seqNum, mEndpoint); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| |
| CHIP_ERROR ColorControlCluster::WriteAttributeColorPointBIntensity(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback, uint8_t value) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeColorControlClusterWriteColorPointBIntensityAttribute(seqNum, mEndpoint, value); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| |
| CHIP_ERROR ColorControlCluster::ReadAttributeEnhancedCurrentHue(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeColorControlClusterReadEnhancedCurrentHueAttribute(seqNum, mEndpoint); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| |
| CHIP_ERROR ColorControlCluster::ReadAttributeEnhancedColorMode(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeColorControlClusterReadEnhancedColorModeAttribute(seqNum, mEndpoint); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| |
| CHIP_ERROR ColorControlCluster::ReadAttributeColorLoopActive(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeColorControlClusterReadColorLoopActiveAttribute(seqNum, mEndpoint); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| |
| CHIP_ERROR ColorControlCluster::ReadAttributeColorLoopDirection(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeColorControlClusterReadColorLoopDirectionAttribute(seqNum, mEndpoint); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| |
| CHIP_ERROR ColorControlCluster::ReadAttributeColorLoopTime(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeColorControlClusterReadColorLoopTimeAttribute(seqNum, mEndpoint); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| |
| CHIP_ERROR ColorControlCluster::ReadAttributeColorCapabilities(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeColorControlClusterReadColorCapabilitiesAttribute(seqNum, mEndpoint); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| |
| CHIP_ERROR ColorControlCluster::ReadAttributeColorTempPhysicalMin(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeColorControlClusterReadColorTempPhysicalMinAttribute(seqNum, mEndpoint); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| |
| CHIP_ERROR ColorControlCluster::ReadAttributeColorTempPhysicalMax(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeColorControlClusterReadColorTempPhysicalMaxAttribute(seqNum, mEndpoint); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| |
| CHIP_ERROR ColorControlCluster::ReadAttributeCoupleColorTempToLevelMinMireds(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeColorControlClusterReadCoupleColorTempToLevelMinMiredsAttribute(seqNum, mEndpoint); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| |
| CHIP_ERROR ColorControlCluster::ReadAttributeStartUpColorTemperatureMireds(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeColorControlClusterReadStartUpColorTemperatureMiredsAttribute(seqNum, mEndpoint); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| |
| CHIP_ERROR ColorControlCluster::WriteAttributeStartUpColorTemperatureMireds(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback, |
| uint16_t value) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = |
| encodeColorControlClusterWriteStartUpColorTemperatureMiredsAttribute(seqNum, mEndpoint, value); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| |
| CHIP_ERROR ColorControlCluster::ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeColorControlClusterReadClusterRevisionAttribute(seqNum, mEndpoint); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| |
| // DoorLock Cluster Commands |
| CHIP_ERROR DoorLockCluster::ClearAllPins(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback) |
| { |
| #ifdef CHIP_APP_USE_INTERACTION_MODEL |
| VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE); |
| (void) onCompletion; |
| |
| app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kClearAllPinsCommandId, |
| (chip::app::Command::kCommandPathFlag_EndpointIdValid) }; |
| app::Command * ZCLcommand = mDevice->GetCommandSender(); |
| |
| TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter(); |
| |
| TLV::TLVType dummyType = TLV::kTLVType_NotSpecified; |
| ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType)); |
| |
| // Command takes no arguments. |
| |
| ReturnErrorOnFailure(writer.EndContainer(dummyType)); |
| ReturnErrorOnFailure(writer.Finalize()); |
| ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams)); |
| |
| return mDevice->SendCommands(); |
| #else |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeDoorLockClusterClearAllPinsCommand(seqNum, mEndpoint); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| #endif |
| } |
| |
| CHIP_ERROR DoorLockCluster::ClearAllRfids(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback) |
| { |
| #ifdef CHIP_APP_USE_INTERACTION_MODEL |
| VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE); |
| (void) onCompletion; |
| |
| app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kClearAllRfidsCommandId, |
| (chip::app::Command::kCommandPathFlag_EndpointIdValid) }; |
| app::Command * ZCLcommand = mDevice->GetCommandSender(); |
| |
| TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter(); |
| |
| TLV::TLVType dummyType = TLV::kTLVType_NotSpecified; |
| ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType)); |
| |
| // Command takes no arguments. |
| |
| ReturnErrorOnFailure(writer.EndContainer(dummyType)); |
| ReturnErrorOnFailure(writer.Finalize()); |
| ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams)); |
| |
| return mDevice->SendCommands(); |
| #else |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeDoorLockClusterClearAllRfidsCommand(seqNum, mEndpoint); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| #endif |
| } |
| |
| CHIP_ERROR DoorLockCluster::ClearHolidaySchedule(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, |
| uint8_t scheduleId) |
| { |
| #ifdef CHIP_APP_USE_INTERACTION_MODEL |
| VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE); |
| (void) onCompletion; |
| |
| app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kClearHolidayScheduleCommandId, |
| (chip::app::Command::kCommandPathFlag_EndpointIdValid) }; |
| app::Command * ZCLcommand = mDevice->GetCommandSender(); |
| |
| TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter(); |
| |
| TLV::TLVType dummyType = TLV::kTLVType_NotSpecified; |
| ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType)); |
| |
| uint8_t argSeqNumber = 0; |
| // scheduleId: int8u |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), scheduleId)); |
| |
| ReturnErrorOnFailure(writer.EndContainer(dummyType)); |
| ReturnErrorOnFailure(writer.Finalize()); |
| ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams)); |
| |
| return mDevice->SendCommands(); |
| #else |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeDoorLockClusterClearHolidayScheduleCommand(seqNum, mEndpoint, scheduleId); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| #endif |
| } |
| |
| CHIP_ERROR DoorLockCluster::ClearPin(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, |
| uint16_t userId) |
| { |
| #ifdef CHIP_APP_USE_INTERACTION_MODEL |
| VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE); |
| (void) onCompletion; |
| |
| app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kClearPinCommandId, |
| (chip::app::Command::kCommandPathFlag_EndpointIdValid) }; |
| app::Command * ZCLcommand = mDevice->GetCommandSender(); |
| |
| TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter(); |
| |
| TLV::TLVType dummyType = TLV::kTLVType_NotSpecified; |
| ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType)); |
| |
| uint8_t argSeqNumber = 0; |
| // userId: int16u |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), userId)); |
| |
| ReturnErrorOnFailure(writer.EndContainer(dummyType)); |
| ReturnErrorOnFailure(writer.Finalize()); |
| ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams)); |
| |
| return mDevice->SendCommands(); |
| #else |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeDoorLockClusterClearPinCommand(seqNum, mEndpoint, userId); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| #endif |
| } |
| |
| CHIP_ERROR DoorLockCluster::ClearRfid(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, |
| uint16_t userId) |
| { |
| #ifdef CHIP_APP_USE_INTERACTION_MODEL |
| VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE); |
| (void) onCompletion; |
| |
| app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kClearRfidCommandId, |
| (chip::app::Command::kCommandPathFlag_EndpointIdValid) }; |
| app::Command * ZCLcommand = mDevice->GetCommandSender(); |
| |
| TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter(); |
| |
| TLV::TLVType dummyType = TLV::kTLVType_NotSpecified; |
| ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType)); |
| |
| uint8_t argSeqNumber = 0; |
| // userId: int16u |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), userId)); |
| |
| ReturnErrorOnFailure(writer.EndContainer(dummyType)); |
| ReturnErrorOnFailure(writer.Finalize()); |
| ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams)); |
| |
| return mDevice->SendCommands(); |
| #else |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeDoorLockClusterClearRfidCommand(seqNum, mEndpoint, userId); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| #endif |
| } |
| |
| CHIP_ERROR DoorLockCluster::ClearWeekdaySchedule(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, |
| uint8_t scheduleId, uint16_t userId) |
| { |
| #ifdef CHIP_APP_USE_INTERACTION_MODEL |
| VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE); |
| (void) onCompletion; |
| |
| app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kClearWeekdayScheduleCommandId, |
| (chip::app::Command::kCommandPathFlag_EndpointIdValid) }; |
| app::Command * ZCLcommand = mDevice->GetCommandSender(); |
| |
| TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter(); |
| |
| TLV::TLVType dummyType = TLV::kTLVType_NotSpecified; |
| ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType)); |
| |
| uint8_t argSeqNumber = 0; |
| // scheduleId: int8u |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), scheduleId)); |
| // userId: int16u |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), userId)); |
| |
| ReturnErrorOnFailure(writer.EndContainer(dummyType)); |
| ReturnErrorOnFailure(writer.Finalize()); |
| ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams)); |
| |
| return mDevice->SendCommands(); |
| #else |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeDoorLockClusterClearWeekdayScheduleCommand(seqNum, mEndpoint, scheduleId, userId); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| #endif |
| } |
| |
| CHIP_ERROR DoorLockCluster::ClearYeardaySchedule(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, |
| uint8_t scheduleId, uint16_t userId) |
| { |
| #ifdef CHIP_APP_USE_INTERACTION_MODEL |
| VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE); |
| (void) onCompletion; |
| |
| app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kClearYeardayScheduleCommandId, |
| (chip::app::Command::kCommandPathFlag_EndpointIdValid) }; |
| app::Command * ZCLcommand = mDevice->GetCommandSender(); |
| |
| TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter(); |
| |
| TLV::TLVType dummyType = TLV::kTLVType_NotSpecified; |
| ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType)); |
| |
| uint8_t argSeqNumber = 0; |
| // scheduleId: int8u |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), scheduleId)); |
| // userId: int16u |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), userId)); |
| |
| ReturnErrorOnFailure(writer.EndContainer(dummyType)); |
| ReturnErrorOnFailure(writer.Finalize()); |
| ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams)); |
| |
| return mDevice->SendCommands(); |
| #else |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeDoorLockClusterClearYeardayScheduleCommand(seqNum, mEndpoint, scheduleId, userId); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| #endif |
| } |
| |
| CHIP_ERROR DoorLockCluster::GetHolidaySchedule(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, |
| uint8_t scheduleId) |
| { |
| #ifdef CHIP_APP_USE_INTERACTION_MODEL |
| VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE); |
| (void) onCompletion; |
| |
| app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kGetHolidayScheduleCommandId, |
| (chip::app::Command::kCommandPathFlag_EndpointIdValid) }; |
| app::Command * ZCLcommand = mDevice->GetCommandSender(); |
| |
| TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter(); |
| |
| TLV::TLVType dummyType = TLV::kTLVType_NotSpecified; |
| ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType)); |
| |
| uint8_t argSeqNumber = 0; |
| // scheduleId: int8u |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), scheduleId)); |
| |
| ReturnErrorOnFailure(writer.EndContainer(dummyType)); |
| ReturnErrorOnFailure(writer.Finalize()); |
| ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams)); |
| |
| return mDevice->SendCommands(); |
| #else |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeDoorLockClusterGetHolidayScheduleCommand(seqNum, mEndpoint, scheduleId); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| #endif |
| } |
| |
| CHIP_ERROR DoorLockCluster::GetLogRecord(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, |
| uint16_t logIndex) |
| { |
| #ifdef CHIP_APP_USE_INTERACTION_MODEL |
| VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE); |
| (void) onCompletion; |
| |
| app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kGetLogRecordCommandId, |
| (chip::app::Command::kCommandPathFlag_EndpointIdValid) }; |
| app::Command * ZCLcommand = mDevice->GetCommandSender(); |
| |
| TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter(); |
| |
| TLV::TLVType dummyType = TLV::kTLVType_NotSpecified; |
| ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType)); |
| |
| uint8_t argSeqNumber = 0; |
| // logIndex: int16u |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), logIndex)); |
| |
| ReturnErrorOnFailure(writer.EndContainer(dummyType)); |
| ReturnErrorOnFailure(writer.Finalize()); |
| ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams)); |
| |
| return mDevice->SendCommands(); |
| #else |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeDoorLockClusterGetLogRecordCommand(seqNum, mEndpoint, logIndex); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| #endif |
| } |
| |
| CHIP_ERROR DoorLockCluster::GetPin(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, |
| uint16_t userId) |
| { |
| #ifdef CHIP_APP_USE_INTERACTION_MODEL |
| VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE); |
| (void) onCompletion; |
| |
| app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kGetPinCommandId, |
| (chip::app::Command::kCommandPathFlag_EndpointIdValid) }; |
| app::Command * ZCLcommand = mDevice->GetCommandSender(); |
| |
| TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter(); |
| |
| TLV::TLVType dummyType = TLV::kTLVType_NotSpecified; |
| ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType)); |
| |
| uint8_t argSeqNumber = 0; |
| // userId: int16u |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), userId)); |
| |
| ReturnErrorOnFailure(writer.EndContainer(dummyType)); |
| ReturnErrorOnFailure(writer.Finalize()); |
| ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams)); |
| |
| return mDevice->SendCommands(); |
| #else |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeDoorLockClusterGetPinCommand(seqNum, mEndpoint, userId); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| #endif |
| } |
| |
| CHIP_ERROR DoorLockCluster::GetRfid(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, |
| uint16_t userId) |
| { |
| #ifdef CHIP_APP_USE_INTERACTION_MODEL |
| VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE); |
| (void) onCompletion; |
| |
| app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kGetRfidCommandId, |
| (chip::app::Command::kCommandPathFlag_EndpointIdValid) }; |
| app::Command * ZCLcommand = mDevice->GetCommandSender(); |
| |
| TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter(); |
| |
| TLV::TLVType dummyType = TLV::kTLVType_NotSpecified; |
| ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType)); |
| |
| uint8_t argSeqNumber = 0; |
| // userId: int16u |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), userId)); |
| |
| ReturnErrorOnFailure(writer.EndContainer(dummyType)); |
| ReturnErrorOnFailure(writer.Finalize()); |
| ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams)); |
| |
| return mDevice->SendCommands(); |
| #else |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeDoorLockClusterGetRfidCommand(seqNum, mEndpoint, userId); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| #endif |
| } |
| |
| CHIP_ERROR DoorLockCluster::GetUserType(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, |
| uint16_t userId) |
| { |
| #ifdef CHIP_APP_USE_INTERACTION_MODEL |
| VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE); |
| (void) onCompletion; |
| |
| app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kGetUserTypeCommandId, |
| (chip::app::Command::kCommandPathFlag_EndpointIdValid) }; |
| app::Command * ZCLcommand = mDevice->GetCommandSender(); |
| |
| TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter(); |
| |
| TLV::TLVType dummyType = TLV::kTLVType_NotSpecified; |
| ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType)); |
| |
| uint8_t argSeqNumber = 0; |
| // userId: int16u |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), userId)); |
| |
| ReturnErrorOnFailure(writer.EndContainer(dummyType)); |
| ReturnErrorOnFailure(writer.Finalize()); |
| ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams)); |
| |
| return mDevice->SendCommands(); |
| #else |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeDoorLockClusterGetUserTypeCommand(seqNum, mEndpoint, userId); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| #endif |
| } |
| |
| CHIP_ERROR DoorLockCluster::GetWeekdaySchedule(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, |
| uint8_t scheduleId, uint16_t userId) |
| { |
| #ifdef CHIP_APP_USE_INTERACTION_MODEL |
| VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE); |
| (void) onCompletion; |
| |
| app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kGetWeekdayScheduleCommandId, |
| (chip::app::Command::kCommandPathFlag_EndpointIdValid) }; |
| app::Command * ZCLcommand = mDevice->GetCommandSender(); |
| |
| TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter(); |
| |
| TLV::TLVType dummyType = TLV::kTLVType_NotSpecified; |
| ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType)); |
| |
| uint8_t argSeqNumber = 0; |
| // scheduleId: int8u |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), scheduleId)); |
| // userId: int16u |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), userId)); |
| |
| ReturnErrorOnFailure(writer.EndContainer(dummyType)); |
| ReturnErrorOnFailure(writer.Finalize()); |
| ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams)); |
| |
| return mDevice->SendCommands(); |
| #else |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeDoorLockClusterGetWeekdayScheduleCommand(seqNum, mEndpoint, scheduleId, userId); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| #endif |
| } |
| |
| CHIP_ERROR DoorLockCluster::GetYeardaySchedule(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, |
| uint8_t scheduleId, uint16_t userId) |
| { |
| #ifdef CHIP_APP_USE_INTERACTION_MODEL |
| VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE); |
| (void) onCompletion; |
| |
| app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kGetYeardayScheduleCommandId, |
| (chip::app::Command::kCommandPathFlag_EndpointIdValid) }; |
| app::Command * ZCLcommand = mDevice->GetCommandSender(); |
| |
| TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter(); |
| |
| TLV::TLVType dummyType = TLV::kTLVType_NotSpecified; |
| ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType)); |
| |
| uint8_t argSeqNumber = 0; |
| // scheduleId: int8u |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), scheduleId)); |
| // userId: int16u |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), userId)); |
| |
| ReturnErrorOnFailure(writer.EndContainer(dummyType)); |
| ReturnErrorOnFailure(writer.Finalize()); |
| ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams)); |
| |
| return mDevice->SendCommands(); |
| #else |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeDoorLockClusterGetYeardayScheduleCommand(seqNum, mEndpoint, scheduleId, userId); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| #endif |
| } |
| |
| CHIP_ERROR DoorLockCluster::LockDoor(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, char * pin) |
| { |
| #ifdef CHIP_APP_USE_INTERACTION_MODEL |
| VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE); |
| (void) onCompletion; |
| |
| app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kLockDoorCommandId, |
| (chip::app::Command::kCommandPathFlag_EndpointIdValid) }; |
| app::Command * ZCLcommand = mDevice->GetCommandSender(); |
| |
| TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter(); |
| |
| TLV::TLVType dummyType = TLV::kTLVType_NotSpecified; |
| ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType)); |
| |
| uint8_t argSeqNumber = 0; |
| // pin: charString |
| ReturnErrorOnFailure(writer.PutString(TLV::ContextTag(argSeqNumber++), pin)); |
| |
| ReturnErrorOnFailure(writer.EndContainer(dummyType)); |
| ReturnErrorOnFailure(writer.Finalize()); |
| ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams)); |
| |
| return mDevice->SendCommands(); |
| #else |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeDoorLockClusterLockDoorCommand(seqNum, mEndpoint, pin); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| #endif |
| } |
| |
| CHIP_ERROR DoorLockCluster::SetHolidaySchedule(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, |
| uint8_t scheduleId, uint32_t localStartTime, uint32_t localEndTime, |
| uint8_t operatingModeDuringHoliday) |
| { |
| #ifdef CHIP_APP_USE_INTERACTION_MODEL |
| VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE); |
| (void) onCompletion; |
| |
| app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kSetHolidayScheduleCommandId, |
| (chip::app::Command::kCommandPathFlag_EndpointIdValid) }; |
| app::Command * ZCLcommand = mDevice->GetCommandSender(); |
| |
| TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter(); |
| |
| TLV::TLVType dummyType = TLV::kTLVType_NotSpecified; |
| ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType)); |
| |
| uint8_t argSeqNumber = 0; |
| // scheduleId: int8u |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), scheduleId)); |
| // localStartTime: int32u |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), localStartTime)); |
| // localEndTime: int32u |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), localEndTime)); |
| // operatingModeDuringHoliday: enum8 |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), operatingModeDuringHoliday)); |
| |
| ReturnErrorOnFailure(writer.EndContainer(dummyType)); |
| ReturnErrorOnFailure(writer.Finalize()); |
| ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams)); |
| |
| return mDevice->SendCommands(); |
| #else |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeDoorLockClusterSetHolidayScheduleCommand( |
| seqNum, mEndpoint, scheduleId, localStartTime, localEndTime, operatingModeDuringHoliday); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| #endif |
| } |
| |
| CHIP_ERROR DoorLockCluster::SetPin(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, |
| uint16_t userId, uint8_t userStatus, uint8_t userType, char * pin) |
| { |
| #ifdef CHIP_APP_USE_INTERACTION_MODEL |
| VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE); |
| (void) onCompletion; |
| |
| app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kSetPinCommandId, |
| (chip::app::Command::kCommandPathFlag_EndpointIdValid) }; |
| app::Command * ZCLcommand = mDevice->GetCommandSender(); |
| |
| TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter(); |
| |
| TLV::TLVType dummyType = TLV::kTLVType_NotSpecified; |
| ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType)); |
| |
| uint8_t argSeqNumber = 0; |
| // userId: int16u |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), userId)); |
| // userStatus: doorLockUserStatus |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), userStatus)); |
| // userType: doorLockUserType |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), userType)); |
| // pin: charString |
| ReturnErrorOnFailure(writer.PutString(TLV::ContextTag(argSeqNumber++), pin)); |
| |
| ReturnErrorOnFailure(writer.EndContainer(dummyType)); |
| ReturnErrorOnFailure(writer.Finalize()); |
| ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams)); |
| |
| return mDevice->SendCommands(); |
| #else |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeDoorLockClusterSetPinCommand(seqNum, mEndpoint, userId, userStatus, userType, pin); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| #endif |
| } |
| |
| CHIP_ERROR DoorLockCluster::SetRfid(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, |
| uint16_t userId, uint8_t userStatus, uint8_t userType, char * id) |
| { |
| #ifdef CHIP_APP_USE_INTERACTION_MODEL |
| VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE); |
| (void) onCompletion; |
| |
| app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kSetRfidCommandId, |
| (chip::app::Command::kCommandPathFlag_EndpointIdValid) }; |
| app::Command * ZCLcommand = mDevice->GetCommandSender(); |
| |
| TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter(); |
| |
| TLV::TLVType dummyType = TLV::kTLVType_NotSpecified; |
| ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType)); |
| |
| uint8_t argSeqNumber = 0; |
| // userId: int16u |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), userId)); |
| // userStatus: doorLockUserStatus |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), userStatus)); |
| // userType: doorLockUserType |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), userType)); |
| // id: charString |
| ReturnErrorOnFailure(writer.PutString(TLV::ContextTag(argSeqNumber++), id)); |
| |
| ReturnErrorOnFailure(writer.EndContainer(dummyType)); |
| ReturnErrorOnFailure(writer.Finalize()); |
| ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams)); |
| |
| return mDevice->SendCommands(); |
| #else |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeDoorLockClusterSetRfidCommand(seqNum, mEndpoint, userId, userStatus, userType, id); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| #endif |
| } |
| |
| CHIP_ERROR DoorLockCluster::SetUserType(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, |
| uint16_t userId, uint8_t userType) |
| { |
| #ifdef CHIP_APP_USE_INTERACTION_MODEL |
| VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE); |
| (void) onCompletion; |
| |
| app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kSetUserTypeCommandId, |
| (chip::app::Command::kCommandPathFlag_EndpointIdValid) }; |
| app::Command * ZCLcommand = mDevice->GetCommandSender(); |
| |
| TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter(); |
| |
| TLV::TLVType dummyType = TLV::kTLVType_NotSpecified; |
| ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType)); |
| |
| uint8_t argSeqNumber = 0; |
| // userId: int16u |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), userId)); |
| // userType: doorLockUserType |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), userType)); |
| |
| ReturnErrorOnFailure(writer.EndContainer(dummyType)); |
| ReturnErrorOnFailure(writer.Finalize()); |
| ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams)); |
| |
| return mDevice->SendCommands(); |
| #else |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeDoorLockClusterSetUserTypeCommand(seqNum, mEndpoint, userId, userType); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| #endif |
| } |
| |
| CHIP_ERROR DoorLockCluster::SetWeekdaySchedule(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, |
| uint8_t scheduleId, uint16_t userId, uint8_t daysMask, uint8_t startHour, |
| uint8_t startMinute, uint8_t endHour, uint8_t endMinute) |
| { |
| #ifdef CHIP_APP_USE_INTERACTION_MODEL |
| VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE); |
| (void) onCompletion; |
| |
| app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kSetWeekdayScheduleCommandId, |
| (chip::app::Command::kCommandPathFlag_EndpointIdValid) }; |
| app::Command * ZCLcommand = mDevice->GetCommandSender(); |
| |
| TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter(); |
| |
| TLV::TLVType dummyType = TLV::kTLVType_NotSpecified; |
| ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType)); |
| |
| uint8_t argSeqNumber = 0; |
| // scheduleId: int8u |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), scheduleId)); |
| // userId: int16u |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), userId)); |
| // daysMask: doorLockDayOfWeek |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), daysMask)); |
| // startHour: int8u |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), startHour)); |
| // startMinute: int8u |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), startMinute)); |
| // endHour: int8u |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), endHour)); |
| // endMinute: int8u |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), endMinute)); |
| |
| ReturnErrorOnFailure(writer.EndContainer(dummyType)); |
| ReturnErrorOnFailure(writer.Finalize()); |
| ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams)); |
| |
| return mDevice->SendCommands(); |
| #else |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeDoorLockClusterSetWeekdayScheduleCommand( |
| seqNum, mEndpoint, scheduleId, userId, daysMask, startHour, startMinute, endHour, endMinute); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| #endif |
| } |
| |
| CHIP_ERROR DoorLockCluster::SetYeardaySchedule(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, |
| uint8_t scheduleId, uint16_t userId, uint32_t localStartTime, uint32_t localEndTime) |
| { |
| #ifdef CHIP_APP_USE_INTERACTION_MODEL |
| VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE); |
| (void) onCompletion; |
| |
| app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kSetYeardayScheduleCommandId, |
| (chip::app::Command::kCommandPathFlag_EndpointIdValid) }; |
| app::Command * ZCLcommand = mDevice->GetCommandSender(); |
| |
| TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter(); |
| |
| TLV::TLVType dummyType = TLV::kTLVType_NotSpecified; |
| ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType)); |
| |
| uint8_t argSeqNumber = 0; |
| // scheduleId: int8u |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), scheduleId)); |
| // userId: int16u |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), userId)); |
| // localStartTime: int32u |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), localStartTime)); |
| // localEndTime: int32u |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), localEndTime)); |
| |
| ReturnErrorOnFailure(writer.EndContainer(dummyType)); |
| ReturnErrorOnFailure(writer.Finalize()); |
| ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams)); |
| |
| return mDevice->SendCommands(); |
| #else |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = |
| encodeDoorLockClusterSetYeardayScheduleCommand(seqNum, mEndpoint, scheduleId, userId, localStartTime, localEndTime); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| #endif |
| } |
| |
| CHIP_ERROR DoorLockCluster::UnlockDoor(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, |
| char * pin) |
| { |
| #ifdef CHIP_APP_USE_INTERACTION_MODEL |
| VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE); |
| (void) onCompletion; |
| |
| app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kUnlockDoorCommandId, |
| (chip::app::Command::kCommandPathFlag_EndpointIdValid) }; |
| app::Command * ZCLcommand = mDevice->GetCommandSender(); |
| |
| TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter(); |
| |
| TLV::TLVType dummyType = TLV::kTLVType_NotSpecified; |
| ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType)); |
| |
| uint8_t argSeqNumber = 0; |
| // pin: charString |
| ReturnErrorOnFailure(writer.PutString(TLV::ContextTag(argSeqNumber++), pin)); |
| |
| ReturnErrorOnFailure(writer.EndContainer(dummyType)); |
| ReturnErrorOnFailure(writer.Finalize()); |
| ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams)); |
| |
| return mDevice->SendCommands(); |
| #else |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeDoorLockClusterUnlockDoorCommand(seqNum, mEndpoint, pin); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| #endif |
| } |
| |
| CHIP_ERROR DoorLockCluster::UnlockWithTimeout(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, |
| uint16_t timeoutInSeconds, char * pin) |
| { |
| #ifdef CHIP_APP_USE_INTERACTION_MODEL |
| VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE); |
| (void) onCompletion; |
| |
| app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kUnlockWithTimeoutCommandId, |
| (chip::app::Command::kCommandPathFlag_EndpointIdValid) }; |
| app::Command * ZCLcommand = mDevice->GetCommandSender(); |
| |
| TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter(); |
| |
| TLV::TLVType dummyType = TLV::kTLVType_NotSpecified; |
| ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType)); |
| |
| uint8_t argSeqNumber = 0; |
| // timeoutInSeconds: int16u |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), timeoutInSeconds)); |
| // pin: charString |
| ReturnErrorOnFailure(writer.PutString(TLV::ContextTag(argSeqNumber++), pin)); |
| |
| ReturnErrorOnFailure(writer.EndContainer(dummyType)); |
| ReturnErrorOnFailure(writer.Finalize()); |
| ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams)); |
| |
| return mDevice->SendCommands(); |
| #else |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeDoorLockClusterUnlockWithTimeoutCommand(seqNum, mEndpoint, timeoutInSeconds, pin); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| #endif |
| } |
| |
| // DoorLock Cluster Attributes |
| CHIP_ERROR DoorLockCluster::DiscoverAttributes(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeDoorLockClusterDiscoverAttributes(seqNum, mEndpoint); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| CHIP_ERROR DoorLockCluster::ReadAttributeLockState(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeDoorLockClusterReadLockStateAttribute(seqNum, mEndpoint); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| |
| CHIP_ERROR DoorLockCluster::ConfigureAttributeLockState(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback, uint16_t minInterval, |
| uint16_t maxInterval) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = |
| encodeDoorLockClusterConfigureLockStateAttribute(seqNum, mEndpoint, minInterval, maxInterval); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| |
| CHIP_ERROR DoorLockCluster::ReportAttributeLockState(Callback::Cancelable * onReportCallback) |
| { |
| return RequestAttributeReporting(0x0000, onReportCallback); |
| } |
| |
| CHIP_ERROR DoorLockCluster::ReadAttributeLockType(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeDoorLockClusterReadLockTypeAttribute(seqNum, mEndpoint); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| |
| CHIP_ERROR DoorLockCluster::ReadAttributeActuatorEnabled(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeDoorLockClusterReadActuatorEnabledAttribute(seqNum, mEndpoint); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| |
| CHIP_ERROR DoorLockCluster::ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeDoorLockClusterReadClusterRevisionAttribute(seqNum, mEndpoint); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| |
| // Groups Cluster Commands |
| CHIP_ERROR GroupsCluster::AddGroup(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, |
| uint16_t groupId, char * groupName) |
| { |
| #ifdef CHIP_APP_USE_INTERACTION_MODEL |
| VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE); |
| (void) onCompletion; |
| |
| app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kAddGroupCommandId, |
| (chip::app::Command::kCommandPathFlag_EndpointIdValid) }; |
| app::Command * ZCLcommand = mDevice->GetCommandSender(); |
| |
| TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter(); |
| |
| TLV::TLVType dummyType = TLV::kTLVType_NotSpecified; |
| ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType)); |
| |
| uint8_t argSeqNumber = 0; |
| // groupId: int16u |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), groupId)); |
| // groupName: charString |
| ReturnErrorOnFailure(writer.PutString(TLV::ContextTag(argSeqNumber++), groupName)); |
| |
| ReturnErrorOnFailure(writer.EndContainer(dummyType)); |
| ReturnErrorOnFailure(writer.Finalize()); |
| ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams)); |
| |
| return mDevice->SendCommands(); |
| #else |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeGroupsClusterAddGroupCommand(seqNum, mEndpoint, groupId, groupName); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| #endif |
| } |
| |
| CHIP_ERROR GroupsCluster::AddGroupIfIdentifying(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, |
| uint16_t groupId, char * groupName) |
| { |
| #ifdef CHIP_APP_USE_INTERACTION_MODEL |
| VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE); |
| (void) onCompletion; |
| |
| app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kAddGroupIfIdentifyingCommandId, |
| (chip::app::Command::kCommandPathFlag_EndpointIdValid) }; |
| app::Command * ZCLcommand = mDevice->GetCommandSender(); |
| |
| TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter(); |
| |
| TLV::TLVType dummyType = TLV::kTLVType_NotSpecified; |
| ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType)); |
| |
| uint8_t argSeqNumber = 0; |
| // groupId: int16u |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), groupId)); |
| // groupName: charString |
| ReturnErrorOnFailure(writer.PutString(TLV::ContextTag(argSeqNumber++), groupName)); |
| |
| ReturnErrorOnFailure(writer.EndContainer(dummyType)); |
| ReturnErrorOnFailure(writer.Finalize()); |
| ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams)); |
| |
| return mDevice->SendCommands(); |
| #else |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeGroupsClusterAddGroupIfIdentifyingCommand(seqNum, mEndpoint, groupId, groupName); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| #endif |
| } |
| |
| CHIP_ERROR GroupsCluster::GetGroupMembership(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, |
| uint8_t groupCount, uint16_t groupList) |
| { |
| #ifdef CHIP_APP_USE_INTERACTION_MODEL |
| VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE); |
| (void) onCompletion; |
| |
| app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kGetGroupMembershipCommandId, |
| (chip::app::Command::kCommandPathFlag_EndpointIdValid) }; |
| app::Command * ZCLcommand = mDevice->GetCommandSender(); |
| |
| TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter(); |
| |
| TLV::TLVType dummyType = TLV::kTLVType_NotSpecified; |
| ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType)); |
| |
| uint8_t argSeqNumber = 0; |
| // groupCount: int8u |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), groupCount)); |
| // groupList: int16u |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), groupList)); |
| |
| ReturnErrorOnFailure(writer.EndContainer(dummyType)); |
| ReturnErrorOnFailure(writer.Finalize()); |
| ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams)); |
| |
| return mDevice->SendCommands(); |
| #else |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeGroupsClusterGetGroupMembershipCommand(seqNum, mEndpoint, groupCount, groupList); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| #endif |
| } |
| |
| CHIP_ERROR GroupsCluster::RemoveAllGroups(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback) |
| { |
| #ifdef CHIP_APP_USE_INTERACTION_MODEL |
| VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE); |
| (void) onCompletion; |
| |
| app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kRemoveAllGroupsCommandId, |
| (chip::app::Command::kCommandPathFlag_EndpointIdValid) }; |
| app::Command * ZCLcommand = mDevice->GetCommandSender(); |
| |
| TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter(); |
| |
| TLV::TLVType dummyType = TLV::kTLVType_NotSpecified; |
| ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType)); |
| |
| // Command takes no arguments. |
| |
| ReturnErrorOnFailure(writer.EndContainer(dummyType)); |
| ReturnErrorOnFailure(writer.Finalize()); |
| ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams)); |
| |
| return mDevice->SendCommands(); |
| #else |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeGroupsClusterRemoveAllGroupsCommand(seqNum, mEndpoint); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| #endif |
| } |
| |
| CHIP_ERROR GroupsCluster::RemoveGroup(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, |
| uint16_t groupId) |
| { |
| #ifdef CHIP_APP_USE_INTERACTION_MODEL |
| VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE); |
| (void) onCompletion; |
| |
| app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kRemoveGroupCommandId, |
| (chip::app::Command::kCommandPathFlag_EndpointIdValid) }; |
| app::Command * ZCLcommand = mDevice->GetCommandSender(); |
| |
| TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter(); |
| |
| TLV::TLVType dummyType = TLV::kTLVType_NotSpecified; |
| ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType)); |
| |
| uint8_t argSeqNumber = 0; |
| // groupId: int16u |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), groupId)); |
| |
| ReturnErrorOnFailure(writer.EndContainer(dummyType)); |
| ReturnErrorOnFailure(writer.Finalize()); |
| ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams)); |
| |
| return mDevice->SendCommands(); |
| #else |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeGroupsClusterRemoveGroupCommand(seqNum, mEndpoint, groupId); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| #endif |
| } |
| |
| CHIP_ERROR GroupsCluster::ViewGroup(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, |
| uint16_t groupId) |
| { |
| #ifdef CHIP_APP_USE_INTERACTION_MODEL |
| VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE); |
| (void) onCompletion; |
| |
| app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kViewGroupCommandId, |
| (chip::app::Command::kCommandPathFlag_EndpointIdValid) }; |
| app::Command * ZCLcommand = mDevice->GetCommandSender(); |
| |
| TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter(); |
| |
| TLV::TLVType dummyType = TLV::kTLVType_NotSpecified; |
| ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType)); |
| |
| uint8_t argSeqNumber = 0; |
| // groupId: int16u |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), groupId)); |
| |
| ReturnErrorOnFailure(writer.EndContainer(dummyType)); |
| ReturnErrorOnFailure(writer.Finalize()); |
| ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams)); |
| |
| return mDevice->SendCommands(); |
| #else |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeGroupsClusterViewGroupCommand(seqNum, mEndpoint, groupId); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| #endif |
| } |
| |
| // Groups Cluster Attributes |
| CHIP_ERROR GroupsCluster::DiscoverAttributes(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeGroupsClusterDiscoverAttributes(seqNum, mEndpoint); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| CHIP_ERROR GroupsCluster::ReadAttributeNameSupport(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeGroupsClusterReadNameSupportAttribute(seqNum, mEndpoint); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| |
| CHIP_ERROR GroupsCluster::ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeGroupsClusterReadClusterRevisionAttribute(seqNum, mEndpoint); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| |
| // IasZone Cluster Commands |
| // IasZone Cluster Attributes |
| CHIP_ERROR IasZoneCluster::DiscoverAttributes(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeIasZoneClusterDiscoverAttributes(seqNum, mEndpoint); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| CHIP_ERROR IasZoneCluster::ReadAttributeZoneState(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeIasZoneClusterReadZoneStateAttribute(seqNum, mEndpoint); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| |
| CHIP_ERROR IasZoneCluster::ReadAttributeZoneType(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeIasZoneClusterReadZoneTypeAttribute(seqNum, mEndpoint); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| |
| CHIP_ERROR IasZoneCluster::ReadAttributeZoneStatus(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeIasZoneClusterReadZoneStatusAttribute(seqNum, mEndpoint); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| |
| CHIP_ERROR IasZoneCluster::ReadAttributeIasCieAddress(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeIasZoneClusterReadIasCieAddressAttribute(seqNum, mEndpoint); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| |
| CHIP_ERROR IasZoneCluster::WriteAttributeIasCieAddress(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback, uint64_t value) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeIasZoneClusterWriteIasCieAddressAttribute(seqNum, mEndpoint, value); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| |
| CHIP_ERROR IasZoneCluster::ReadAttributeZoneId(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeIasZoneClusterReadZoneIdAttribute(seqNum, mEndpoint); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| |
| CHIP_ERROR IasZoneCluster::ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeIasZoneClusterReadClusterRevisionAttribute(seqNum, mEndpoint); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| |
| // Identify Cluster Commands |
| CHIP_ERROR IdentifyCluster::Identify(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, |
| uint16_t identifyTime) |
| { |
| #ifdef CHIP_APP_USE_INTERACTION_MODEL |
| VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE); |
| (void) onCompletion; |
| |
| app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kIdentifyCommandId, |
| (chip::app::Command::kCommandPathFlag_EndpointIdValid) }; |
| app::Command * ZCLcommand = mDevice->GetCommandSender(); |
| |
| TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter(); |
| |
| TLV::TLVType dummyType = TLV::kTLVType_NotSpecified; |
| ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType)); |
| |
| uint8_t argSeqNumber = 0; |
| // identifyTime: int16u |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), identifyTime)); |
| |
| ReturnErrorOnFailure(writer.EndContainer(dummyType)); |
| ReturnErrorOnFailure(writer.Finalize()); |
| ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams)); |
| |
| return mDevice->SendCommands(); |
| #else |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeIdentifyClusterIdentifyCommand(seqNum, mEndpoint, identifyTime); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| #endif |
| } |
| |
| CHIP_ERROR IdentifyCluster::IdentifyQuery(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback) |
| { |
| #ifdef CHIP_APP_USE_INTERACTION_MODEL |
| VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE); |
| (void) onCompletion; |
| |
| app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kIdentifyQueryCommandId, |
| (chip::app::Command::kCommandPathFlag_EndpointIdValid) }; |
| app::Command * ZCLcommand = mDevice->GetCommandSender(); |
| |
| TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter(); |
| |
| TLV::TLVType dummyType = TLV::kTLVType_NotSpecified; |
| ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType)); |
| |
| // Command takes no arguments. |
| |
| ReturnErrorOnFailure(writer.EndContainer(dummyType)); |
| ReturnErrorOnFailure(writer.Finalize()); |
| ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams)); |
| |
| return mDevice->SendCommands(); |
| #else |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeIdentifyClusterIdentifyQueryCommand(seqNum, mEndpoint); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| #endif |
| } |
| |
| // Identify Cluster Attributes |
| CHIP_ERROR IdentifyCluster::DiscoverAttributes(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeIdentifyClusterDiscoverAttributes(seqNum, mEndpoint); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| CHIP_ERROR IdentifyCluster::ReadAttributeIdentifyTime(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeIdentifyClusterReadIdentifyTimeAttribute(seqNum, mEndpoint); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| |
| CHIP_ERROR IdentifyCluster::WriteAttributeIdentifyTime(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback, uint16_t value) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeIdentifyClusterWriteIdentifyTimeAttribute(seqNum, mEndpoint, value); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| |
| CHIP_ERROR IdentifyCluster::ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeIdentifyClusterReadClusterRevisionAttribute(seqNum, mEndpoint); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| |
| // 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) |
| { |
| #ifdef CHIP_APP_USE_INTERACTION_MODEL |
| VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE); |
| (void) onCompletion; |
| |
| app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kMoveCommandId, |
| (chip::app::Command::kCommandPathFlag_EndpointIdValid) }; |
| app::Command * ZCLcommand = mDevice->GetCommandSender(); |
| |
| TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter(); |
| |
| TLV::TLVType dummyType = TLV::kTLVType_NotSpecified; |
| ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType)); |
| |
| uint8_t argSeqNumber = 0; |
| // moveMode: moveMode |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), moveMode)); |
| // rate: int8u |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), rate)); |
| // optionMask: bitmap8 |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), optionMask)); |
| // optionOverride: bitmap8 |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), optionOverride)); |
| |
| ReturnErrorOnFailure(writer.EndContainer(dummyType)); |
| ReturnErrorOnFailure(writer.Finalize()); |
| ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams)); |
| |
| return mDevice->SendCommands(); |
| #else |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = |
| encodeLevelControlClusterMoveCommand(seqNum, mEndpoint, moveMode, rate, optionMask, optionOverride); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| #endif |
| } |
| |
| CHIP_ERROR LevelControlCluster::MoveToLevel(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, |
| uint8_t level, uint16_t transitionTime, uint8_t optionMask, uint8_t optionOverride) |
| { |
| #ifdef CHIP_APP_USE_INTERACTION_MODEL |
| VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE); |
| (void) onCompletion; |
| |
| app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kMoveToLevelCommandId, |
| (chip::app::Command::kCommandPathFlag_EndpointIdValid) }; |
| app::Command * ZCLcommand = mDevice->GetCommandSender(); |
| |
| TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter(); |
| |
| TLV::TLVType dummyType = TLV::kTLVType_NotSpecified; |
| ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType)); |
| |
| uint8_t argSeqNumber = 0; |
| // level: int8u |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), level)); |
| // transitionTime: int16u |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), transitionTime)); |
| // optionMask: bitmap8 |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), optionMask)); |
| // optionOverride: bitmap8 |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), optionOverride)); |
| |
| ReturnErrorOnFailure(writer.EndContainer(dummyType)); |
| ReturnErrorOnFailure(writer.Finalize()); |
| ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams)); |
| |
| return mDevice->SendCommands(); |
| #else |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = |
| encodeLevelControlClusterMoveToLevelCommand(seqNum, mEndpoint, level, transitionTime, optionMask, optionOverride); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| #endif |
| } |
| |
| CHIP_ERROR LevelControlCluster::MoveToLevelWithOnOff(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback, uint8_t level, |
| uint16_t transitionTime) |
| { |
| #ifdef CHIP_APP_USE_INTERACTION_MODEL |
| VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE); |
| (void) onCompletion; |
| |
| app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kMoveToLevelWithOnOffCommandId, |
| (chip::app::Command::kCommandPathFlag_EndpointIdValid) }; |
| app::Command * ZCLcommand = mDevice->GetCommandSender(); |
| |
| TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter(); |
| |
| TLV::TLVType dummyType = TLV::kTLVType_NotSpecified; |
| ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType)); |
| |
| uint8_t argSeqNumber = 0; |
| // level: int8u |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), level)); |
| // transitionTime: int16u |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), transitionTime)); |
| |
| ReturnErrorOnFailure(writer.EndContainer(dummyType)); |
| ReturnErrorOnFailure(writer.Finalize()); |
| ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams)); |
| |
| return mDevice->SendCommands(); |
| #else |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = |
| encodeLevelControlClusterMoveToLevelWithOnOffCommand(seqNum, mEndpoint, level, transitionTime); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| #endif |
| } |
| |
| CHIP_ERROR LevelControlCluster::MoveWithOnOff(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, |
| uint8_t moveMode, uint8_t rate) |
| { |
| #ifdef CHIP_APP_USE_INTERACTION_MODEL |
| VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE); |
| (void) onCompletion; |
| |
| app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kMoveWithOnOffCommandId, |
| (chip::app::Command::kCommandPathFlag_EndpointIdValid) }; |
| app::Command * ZCLcommand = mDevice->GetCommandSender(); |
| |
| TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter(); |
| |
| TLV::TLVType dummyType = TLV::kTLVType_NotSpecified; |
| ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType)); |
| |
| uint8_t argSeqNumber = 0; |
| // moveMode: moveMode |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), moveMode)); |
| // rate: int8u |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), rate)); |
| |
| ReturnErrorOnFailure(writer.EndContainer(dummyType)); |
| ReturnErrorOnFailure(writer.Finalize()); |
| ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams)); |
| |
| return mDevice->SendCommands(); |
| #else |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeLevelControlClusterMoveWithOnOffCommand(seqNum, mEndpoint, moveMode, rate); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| #endif |
| } |
| |
| 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) |
| { |
| #ifdef CHIP_APP_USE_INTERACTION_MODEL |
| VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE); |
| (void) onCompletion; |
| |
| app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kStepCommandId, |
| (chip::app::Command::kCommandPathFlag_EndpointIdValid) }; |
| app::Command * ZCLcommand = mDevice->GetCommandSender(); |
| |
| TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter(); |
| |
| TLV::TLVType dummyType = TLV::kTLVType_NotSpecified; |
| ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType)); |
| |
| uint8_t argSeqNumber = 0; |
| // stepMode: stepMode |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), stepMode)); |
| // stepSize: int8u |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), stepSize)); |
| // transitionTime: int16u |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), transitionTime)); |
| // optionMask: bitmap8 |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), optionMask)); |
| // optionOverride: bitmap8 |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), optionOverride)); |
| |
| ReturnErrorOnFailure(writer.EndContainer(dummyType)); |
| ReturnErrorOnFailure(writer.Finalize()); |
| ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams)); |
| |
| return mDevice->SendCommands(); |
| #else |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = |
| encodeLevelControlClusterStepCommand(seqNum, mEndpoint, stepMode, stepSize, transitionTime, optionMask, optionOverride); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| #endif |
| } |
| |
| CHIP_ERROR LevelControlCluster::StepWithOnOff(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, |
| uint8_t stepMode, uint8_t stepSize, uint16_t transitionTime) |
| { |
| #ifdef CHIP_APP_USE_INTERACTION_MODEL |
| VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE); |
| (void) onCompletion; |
| |
| app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kStepWithOnOffCommandId, |
| (chip::app::Command::kCommandPathFlag_EndpointIdValid) }; |
| app::Command * ZCLcommand = mDevice->GetCommandSender(); |
| |
| TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter(); |
| |
| TLV::TLVType dummyType = TLV::kTLVType_NotSpecified; |
| ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType)); |
| |
| uint8_t argSeqNumber = 0; |
| // stepMode: stepMode |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), stepMode)); |
| // stepSize: int8u |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), stepSize)); |
| // transitionTime: int16u |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), transitionTime)); |
| |
| ReturnErrorOnFailure(writer.EndContainer(dummyType)); |
| ReturnErrorOnFailure(writer.Finalize()); |
| ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams)); |
| |
| return mDevice->SendCommands(); |
| #else |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = |
| encodeLevelControlClusterStepWithOnOffCommand(seqNum, mEndpoint, stepMode, stepSize, transitionTime); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| #endif |
| } |
| |
| CHIP_ERROR LevelControlCluster::Stop(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, |
| uint8_t optionMask, uint8_t optionOverride) |
| { |
| #ifdef CHIP_APP_USE_INTERACTION_MODEL |
| VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE); |
| (void) onCompletion; |
| |
| app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kStopCommandId, |
| (chip::app::Command::kCommandPathFlag_EndpointIdValid) }; |
| app::Command * ZCLcommand = mDevice->GetCommandSender(); |
| |
| TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter(); |
| |
| TLV::TLVType dummyType = TLV::kTLVType_NotSpecified; |
| ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType)); |
| |
| uint8_t argSeqNumber = 0; |
| // optionMask: bitmap8 |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), optionMask)); |
| // optionOverride: bitmap8 |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), optionOverride)); |
| |
| ReturnErrorOnFailure(writer.EndContainer(dummyType)); |
| ReturnErrorOnFailure(writer.Finalize()); |
| ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams)); |
| |
| return mDevice->SendCommands(); |
| #else |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeLevelControlClusterStopCommand(seqNum, mEndpoint, optionMask, optionOverride); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| #endif |
| } |
| |
| CHIP_ERROR LevelControlCluster::StopWithOnOff(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback) |
| { |
| #ifdef CHIP_APP_USE_INTERACTION_MODEL |
| VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE); |
| (void) onCompletion; |
| |
| app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kStopWithOnOffCommandId, |
| (chip::app::Command::kCommandPathFlag_EndpointIdValid) }; |
| app::Command * ZCLcommand = mDevice->GetCommandSender(); |
| |
| TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter(); |
| |
| TLV::TLVType dummyType = TLV::kTLVType_NotSpecified; |
| ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType)); |
| |
| // Command takes no arguments. |
| |
| ReturnErrorOnFailure(writer.EndContainer(dummyType)); |
| ReturnErrorOnFailure(writer.Finalize()); |
| ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams)); |
| |
| return mDevice->SendCommands(); |
| #else |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeLevelControlClusterStopWithOnOffCommand(seqNum, mEndpoint); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| #endif |
| } |
| |
| // LevelControl Cluster Attributes |
| CHIP_ERROR LevelControlCluster::DiscoverAttributes(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeLevelControlClusterDiscoverAttributes(seqNum, mEndpoint); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| CHIP_ERROR LevelControlCluster::ReadAttributeCurrentLevel(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeLevelControlClusterReadCurrentLevelAttribute(seqNum, mEndpoint); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| |
| CHIP_ERROR LevelControlCluster::ConfigureAttributeCurrentLevel(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback, uint16_t minInterval, |
| uint16_t maxInterval, uint8_t change) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = |
| encodeLevelControlClusterConfigureCurrentLevelAttribute(seqNum, mEndpoint, minInterval, maxInterval, change); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| |
| CHIP_ERROR LevelControlCluster::ReportAttributeCurrentLevel(Callback::Cancelable * onReportCallback) |
| { |
| return RequestAttributeReporting(0x0000, onReportCallback); |
| } |
| |
| CHIP_ERROR LevelControlCluster::ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeLevelControlClusterReadClusterRevisionAttribute(seqNum, mEndpoint); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| |
| // OnOff Cluster Commands |
| CHIP_ERROR OnOffCluster::Off(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback) |
| { |
| #ifdef CHIP_APP_USE_INTERACTION_MODEL |
| VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE); |
| (void) onCompletion; |
| |
| app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kOffCommandId, |
| (chip::app::Command::kCommandPathFlag_EndpointIdValid) }; |
| app::Command * ZCLcommand = mDevice->GetCommandSender(); |
| |
| TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter(); |
| |
| TLV::TLVType dummyType = TLV::kTLVType_NotSpecified; |
| ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType)); |
| |
| // Command takes no arguments. |
| |
| ReturnErrorOnFailure(writer.EndContainer(dummyType)); |
| ReturnErrorOnFailure(writer.Finalize()); |
| ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams)); |
| |
| return mDevice->SendCommands(); |
| #else |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeOnOffClusterOffCommand(seqNum, mEndpoint); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| #endif |
| } |
| |
| CHIP_ERROR OnOffCluster::On(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback) |
| { |
| #ifdef CHIP_APP_USE_INTERACTION_MODEL |
| VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE); |
| (void) onCompletion; |
| |
| app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kOnCommandId, |
| (chip::app::Command::kCommandPathFlag_EndpointIdValid) }; |
| app::Command * ZCLcommand = mDevice->GetCommandSender(); |
| |
| TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter(); |
| |
| TLV::TLVType dummyType = TLV::kTLVType_NotSpecified; |
| ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType)); |
| |
| // Command takes no arguments. |
| |
| ReturnErrorOnFailure(writer.EndContainer(dummyType)); |
| ReturnErrorOnFailure(writer.Finalize()); |
| ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams)); |
| |
| return mDevice->SendCommands(); |
| #else |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeOnOffClusterOnCommand(seqNum, mEndpoint); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| #endif |
| } |
| |
| CHIP_ERROR OnOffCluster::Toggle(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback) |
| { |
| #ifdef CHIP_APP_USE_INTERACTION_MODEL |
| VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE); |
| (void) onCompletion; |
| |
| app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kToggleCommandId, |
| (chip::app::Command::kCommandPathFlag_EndpointIdValid) }; |
| app::Command * ZCLcommand = mDevice->GetCommandSender(); |
| |
| TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter(); |
| |
| TLV::TLVType dummyType = TLV::kTLVType_NotSpecified; |
| ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType)); |
| |
| // Command takes no arguments. |
| |
| ReturnErrorOnFailure(writer.EndContainer(dummyType)); |
| ReturnErrorOnFailure(writer.Finalize()); |
| ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams)); |
| |
| return mDevice->SendCommands(); |
| #else |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeOnOffClusterToggleCommand(seqNum, mEndpoint); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| #endif |
| } |
| |
| // OnOff Cluster Attributes |
| CHIP_ERROR OnOffCluster::DiscoverAttributes(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeOnOffClusterDiscoverAttributes(seqNum, mEndpoint); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| CHIP_ERROR OnOffCluster::ReadAttributeOnOff(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeOnOffClusterReadOnOffAttribute(seqNum, mEndpoint); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| |
| CHIP_ERROR OnOffCluster::ConfigureAttributeOnOff(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, |
| uint16_t minInterval, uint16_t maxInterval) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeOnOffClusterConfigureOnOffAttribute(seqNum, mEndpoint, minInterval, maxInterval); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| |
| CHIP_ERROR OnOffCluster::ReportAttributeOnOff(Callback::Cancelable * onReportCallback) |
| { |
| return RequestAttributeReporting(0x0000, onReportCallback); |
| } |
| |
| CHIP_ERROR OnOffCluster::ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeOnOffClusterReadClusterRevisionAttribute(seqNum, mEndpoint); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| |
| // Scenes Cluster Commands |
| CHIP_ERROR ScenesCluster::AddScene(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, |
| uint16_t groupId, uint8_t sceneId, uint16_t transitionTime, char * sceneName, |
| chip::ClusterId clusterId, uint8_t length, uint8_t value) |
| { |
| #ifdef CHIP_APP_USE_INTERACTION_MODEL |
| VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE); |
| (void) onCompletion; |
| |
| app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kAddSceneCommandId, |
| (chip::app::Command::kCommandPathFlag_EndpointIdValid) }; |
| app::Command * ZCLcommand = mDevice->GetCommandSender(); |
| |
| TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter(); |
| |
| TLV::TLVType dummyType = TLV::kTLVType_NotSpecified; |
| ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType)); |
| |
| uint8_t argSeqNumber = 0; |
| // groupId: int16u |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), groupId)); |
| // sceneId: int8u |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), sceneId)); |
| // transitionTime: int16u |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), transitionTime)); |
| // sceneName: charString |
| ReturnErrorOnFailure(writer.PutString(TLV::ContextTag(argSeqNumber++), sceneName)); |
| // clusterId: clusterId |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), clusterId)); |
| // length: int8u |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), length)); |
| // value: int8u |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), value)); |
| |
| ReturnErrorOnFailure(writer.EndContainer(dummyType)); |
| ReturnErrorOnFailure(writer.Finalize()); |
| ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams)); |
| |
| return mDevice->SendCommands(); |
| #else |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeScenesClusterAddSceneCommand(seqNum, mEndpoint, groupId, sceneId, transitionTime, |
| sceneName, clusterId, length, value); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| #endif |
| } |
| |
| CHIP_ERROR ScenesCluster::GetSceneMembership(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, |
| uint16_t groupId) |
| { |
| #ifdef CHIP_APP_USE_INTERACTION_MODEL |
| VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE); |
| (void) onCompletion; |
| |
| app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kGetSceneMembershipCommandId, |
| (chip::app::Command::kCommandPathFlag_EndpointIdValid) }; |
| app::Command * ZCLcommand = mDevice->GetCommandSender(); |
| |
| TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter(); |
| |
| TLV::TLVType dummyType = TLV::kTLVType_NotSpecified; |
| ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType)); |
| |
| uint8_t argSeqNumber = 0; |
| // groupId: int16u |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), groupId)); |
| |
| ReturnErrorOnFailure(writer.EndContainer(dummyType)); |
| ReturnErrorOnFailure(writer.Finalize()); |
| ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams)); |
| |
| return mDevice->SendCommands(); |
| #else |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeScenesClusterGetSceneMembershipCommand(seqNum, mEndpoint, groupId); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| #endif |
| } |
| |
| CHIP_ERROR ScenesCluster::RecallScene(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, |
| uint16_t groupId, uint8_t sceneId, uint16_t transitionTime) |
| { |
| #ifdef CHIP_APP_USE_INTERACTION_MODEL |
| VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE); |
| (void) onCompletion; |
| |
| app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kRecallSceneCommandId, |
| (chip::app::Command::kCommandPathFlag_EndpointIdValid) }; |
| app::Command * ZCLcommand = mDevice->GetCommandSender(); |
| |
| TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter(); |
| |
| TLV::TLVType dummyType = TLV::kTLVType_NotSpecified; |
| ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType)); |
| |
| uint8_t argSeqNumber = 0; |
| // groupId: int16u |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), groupId)); |
| // sceneId: int8u |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), sceneId)); |
| // transitionTime: int16u |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), transitionTime)); |
| |
| ReturnErrorOnFailure(writer.EndContainer(dummyType)); |
| ReturnErrorOnFailure(writer.Finalize()); |
| ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams)); |
| |
| return mDevice->SendCommands(); |
| #else |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeScenesClusterRecallSceneCommand(seqNum, mEndpoint, groupId, sceneId, transitionTime); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| #endif |
| } |
| |
| CHIP_ERROR ScenesCluster::RemoveAllScenes(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, |
| uint16_t groupId) |
| { |
| #ifdef CHIP_APP_USE_INTERACTION_MODEL |
| VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE); |
| (void) onCompletion; |
| |
| app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kRemoveAllScenesCommandId, |
| (chip::app::Command::kCommandPathFlag_EndpointIdValid) }; |
| app::Command * ZCLcommand = mDevice->GetCommandSender(); |
| |
| TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter(); |
| |
| TLV::TLVType dummyType = TLV::kTLVType_NotSpecified; |
| ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType)); |
| |
| uint8_t argSeqNumber = 0; |
| // groupId: int16u |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), groupId)); |
| |
| ReturnErrorOnFailure(writer.EndContainer(dummyType)); |
| ReturnErrorOnFailure(writer.Finalize()); |
| ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams)); |
| |
| return mDevice->SendCommands(); |
| #else |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeScenesClusterRemoveAllScenesCommand(seqNum, mEndpoint, groupId); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| #endif |
| } |
| |
| CHIP_ERROR ScenesCluster::RemoveScene(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, |
| uint16_t groupId, uint8_t sceneId) |
| { |
| #ifdef CHIP_APP_USE_INTERACTION_MODEL |
| VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE); |
| (void) onCompletion; |
| |
| app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kRemoveSceneCommandId, |
| (chip::app::Command::kCommandPathFlag_EndpointIdValid) }; |
| app::Command * ZCLcommand = mDevice->GetCommandSender(); |
| |
| TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter(); |
| |
| TLV::TLVType dummyType = TLV::kTLVType_NotSpecified; |
| ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType)); |
| |
| uint8_t argSeqNumber = 0; |
| // groupId: int16u |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), groupId)); |
| // sceneId: int8u |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), sceneId)); |
| |
| ReturnErrorOnFailure(writer.EndContainer(dummyType)); |
| ReturnErrorOnFailure(writer.Finalize()); |
| ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams)); |
| |
| return mDevice->SendCommands(); |
| #else |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeScenesClusterRemoveSceneCommand(seqNum, mEndpoint, groupId, sceneId); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| #endif |
| } |
| |
| CHIP_ERROR ScenesCluster::StoreScene(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, |
| uint16_t groupId, uint8_t sceneId) |
| { |
| #ifdef CHIP_APP_USE_INTERACTION_MODEL |
| VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE); |
| (void) onCompletion; |
| |
| app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kStoreSceneCommandId, |
| (chip::app::Command::kCommandPathFlag_EndpointIdValid) }; |
| app::Command * ZCLcommand = mDevice->GetCommandSender(); |
| |
| TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter(); |
| |
| TLV::TLVType dummyType = TLV::kTLVType_NotSpecified; |
| ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType)); |
| |
| uint8_t argSeqNumber = 0; |
| // groupId: int16u |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), groupId)); |
| // sceneId: int8u |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), sceneId)); |
| |
| ReturnErrorOnFailure(writer.EndContainer(dummyType)); |
| ReturnErrorOnFailure(writer.Finalize()); |
| ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams)); |
| |
| return mDevice->SendCommands(); |
| #else |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeScenesClusterStoreSceneCommand(seqNum, mEndpoint, groupId, sceneId); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| #endif |
| } |
| |
| CHIP_ERROR ScenesCluster::ViewScene(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, |
| uint16_t groupId, uint8_t sceneId) |
| { |
| #ifdef CHIP_APP_USE_INTERACTION_MODEL |
| VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE); |
| (void) onCompletion; |
| |
| app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kViewSceneCommandId, |
| (chip::app::Command::kCommandPathFlag_EndpointIdValid) }; |
| app::Command * ZCLcommand = mDevice->GetCommandSender(); |
| |
| TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter(); |
| |
| TLV::TLVType dummyType = TLV::kTLVType_NotSpecified; |
| ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType)); |
| |
| uint8_t argSeqNumber = 0; |
| // groupId: int16u |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), groupId)); |
| // sceneId: int8u |
| ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), sceneId)); |
| |
| ReturnErrorOnFailure(writer.EndContainer(dummyType)); |
| ReturnErrorOnFailure(writer.Finalize()); |
| ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams)); |
| |
| return mDevice->SendCommands(); |
| #else |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeScenesClusterViewSceneCommand(seqNum, mEndpoint, groupId, sceneId); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| #endif |
| } |
| |
| // Scenes Cluster Attributes |
| CHIP_ERROR ScenesCluster::DiscoverAttributes(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeScenesClusterDiscoverAttributes(seqNum, mEndpoint); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| CHIP_ERROR ScenesCluster::ReadAttributeSceneCount(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeScenesClusterReadSceneCountAttribute(seqNum, mEndpoint); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| |
| CHIP_ERROR ScenesCluster::ReadAttributeCurrentScene(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeScenesClusterReadCurrentSceneAttribute(seqNum, mEndpoint); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| |
| CHIP_ERROR ScenesCluster::ReadAttributeCurrentGroup(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeScenesClusterReadCurrentGroupAttribute(seqNum, mEndpoint); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| |
| CHIP_ERROR ScenesCluster::ReadAttributeSceneValid(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeScenesClusterReadSceneValidAttribute(seqNum, mEndpoint); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| |
| CHIP_ERROR ScenesCluster::ReadAttributeNameSupport(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeScenesClusterReadNameSupportAttribute(seqNum, mEndpoint); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| |
| CHIP_ERROR ScenesCluster::ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeScenesClusterReadClusterRevisionAttribute(seqNum, mEndpoint); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| |
| // TemperatureMeasurement Cluster Commands |
| // TemperatureMeasurement Cluster Attributes |
| CHIP_ERROR TemperatureMeasurementCluster::DiscoverAttributes(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeTemperatureMeasurementClusterDiscoverAttributes(seqNum, mEndpoint); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| CHIP_ERROR TemperatureMeasurementCluster::ReadAttributeMeasuredValue(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeTemperatureMeasurementClusterReadMeasuredValueAttribute(seqNum, mEndpoint); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| |
| CHIP_ERROR TemperatureMeasurementCluster::ConfigureAttributeMeasuredValue(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback, |
| uint16_t minInterval, uint16_t maxInterval, |
| int16_t change) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = |
| encodeTemperatureMeasurementClusterConfigureMeasuredValueAttribute(seqNum, mEndpoint, minInterval, maxInterval, change); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| |
| CHIP_ERROR TemperatureMeasurementCluster::ReportAttributeMeasuredValue(Callback::Cancelable * onReportCallback) |
| { |
| return RequestAttributeReporting(0x0000, onReportCallback); |
| } |
| |
| CHIP_ERROR TemperatureMeasurementCluster::ReadAttributeMinMeasuredValue(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeTemperatureMeasurementClusterReadMinMeasuredValueAttribute(seqNum, mEndpoint); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| |
| CHIP_ERROR TemperatureMeasurementCluster::ReadAttributeMaxMeasuredValue(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeTemperatureMeasurementClusterReadMaxMeasuredValueAttribute(seqNum, mEndpoint); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| |
| CHIP_ERROR TemperatureMeasurementCluster::ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, |
| Callback::Cancelable * onFailureCallback) |
| { |
| uint8_t seqNum = mDevice->GetNextSequenceNumber(); |
| System::PacketBufferHandle payload = encodeTemperatureMeasurementClusterReadClusterRevisionAttribute(seqNum, mEndpoint); |
| return SendCommand(seqNum, std::move(payload), onSuccessCallback, onFailureCallback); |
| } |
| |
| } // namespace Controller |
| } // namespace chip |
