src/controller/CHIPClusters.cpp

   1 /*
   2  *
   3  *    Copyright (c) 2021 Project CHIP Authors
   4  *
   5  *    Licensed under the Apache License, Version 2.0 (the "License");
   6  *    you may not use this file except in compliance with the License.
   7  *    You may obtain a copy of the License at
   8  *
   9  *        http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  *    Unless required by applicable law or agreed to in writing, software
  12  *    distributed under the License is distributed on an "AS IS" BASIS,
  13  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  *    See the License for the specific language governing permissions and
  15  *    limitations under the License.
  16  */
  17
  18 // THIS FILE IS GENERATED BY ZAP
  19 #include "CHIPClusters.h"
  20
  21 #include <cstdint>
  22
  23 #include <app/chip-zcl-zpro-codec-api.h>
  24 #include <lib/support/Span.h>
  25
  26 namespace chip {
  27 namespace Controller {
  28
  29 // TODO(#4502): onCompletion is not used by IM for now.
  30 // TODO(#4503): length should be passed to commands when byte string is in argument list.
  31 // TODO(#4503): Commands should take group id as an argument.
  32
  33 // ApplicationBasic Cluster Commands
  34 // ApplicationBasic Cluster Attributes
  35 CHIP_ERROR ApplicationBasicCluster::DiscoverAttributes(Callback::Cancelable * onSuccessCallback,
  36                                                        Callback::Cancelable * onFailureCallback)
  37 {
  38     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
  39     System::PacketBufferHandle encodedCommand = encodeApplicationBasicClusterDiscoverAttributes(seqNum, mEndpoint);
  40     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
  41 }
  42 CHIP_ERROR ApplicationBasicCluster::ReadAttributeVendorName(Callback::Cancelable * onSuccessCallback,
  43                                                             Callback::Cancelable * onFailureCallback)
  44 {
  45     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
  46     System::PacketBufferHandle encodedCommand = encodeApplicationBasicClusterReadVendorNameAttribute(seqNum, mEndpoint);
  47     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
  48 }
  49
  50 CHIP_ERROR ApplicationBasicCluster::ReadAttributeVendorId(Callback::Cancelable * onSuccessCallback,
  51                                                           Callback::Cancelable * onFailureCallback)
  52 {
  53     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
  54     System::PacketBufferHandle encodedCommand = encodeApplicationBasicClusterReadVendorIdAttribute(seqNum, mEndpoint);
  55     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
  56 }
  57
  58 CHIP_ERROR ApplicationBasicCluster::ReadAttributeApplicationName(Callback::Cancelable * onSuccessCallback,
  59                                                                  Callback::Cancelable * onFailureCallback)
  60 {
  61     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
  62     System::PacketBufferHandle encodedCommand = encodeApplicationBasicClusterReadApplicationNameAttribute(seqNum, mEndpoint);
  63     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
  64 }
  65
  66 CHIP_ERROR ApplicationBasicCluster::ReadAttributeProductId(Callback::Cancelable * onSuccessCallback,
  67                                                            Callback::Cancelable * onFailureCallback)
  68 {
  69     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
  70     System::PacketBufferHandle encodedCommand = encodeApplicationBasicClusterReadProductIdAttribute(seqNum, mEndpoint);
  71     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
  72 }
  73
  74 CHIP_ERROR ApplicationBasicCluster::ReadAttributeApplicationId(Callback::Cancelable * onSuccessCallback,
  75                                                                Callback::Cancelable * onFailureCallback)
  76 {
  77     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
  78     System::PacketBufferHandle encodedCommand = encodeApplicationBasicClusterReadApplicationIdAttribute(seqNum, mEndpoint);
  79     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
  80 }
  81
  82 CHIP_ERROR ApplicationBasicCluster::ReadAttributeCatalogVendorId(Callback::Cancelable * onSuccessCallback,
  83                                                                  Callback::Cancelable * onFailureCallback)
  84 {
  85     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
  86     System::PacketBufferHandle encodedCommand = encodeApplicationBasicClusterReadCatalogVendorIdAttribute(seqNum, mEndpoint);
  87     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
  88 }
  89
  90 CHIP_ERROR ApplicationBasicCluster::ReadAttributeApplicationSatus(Callback::Cancelable * onSuccessCallback,
  91                                                                   Callback::Cancelable * onFailureCallback)
  92 {
  93     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
  94     System::PacketBufferHandle encodedCommand = encodeApplicationBasicClusterReadApplicationSatusAttribute(seqNum, mEndpoint);
  95     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
  96 }
  97
  98 CHIP_ERROR ApplicationBasicCluster::ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback,
  99                                                                  Callback::Cancelable * onFailureCallback)
 100 {
 101     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
 102     System::PacketBufferHandle encodedCommand = encodeApplicationBasicClusterReadClusterRevisionAttribute(seqNum, mEndpoint);
 103     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
 104 }
 105
 106 // BarrierControl Cluster Commands
 107 CHIP_ERROR BarrierControlCluster::BarrierControlGoToPercent(Callback::Cancelable * onSuccessCallback,
 108                                                             Callback::Cancelable * onFailureCallback, uint8_t percentOpen)
 109 {
 110 #if CHIP_ENABLE_INTERACTION_MODEL
 111     VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE);
 112     (void) onSuccessCallback;
 113     (void) onFailureCallback;
 114
 115     app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kBarrierControlGoToPercentCommandId,
 116                                               (chip::app::Command::CommandPathFlags::kEndpointIdValid) };
 117     app::Command * ZCLcommand             = mDevice->GetCommandSender();
 118
 119     TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter();
 120
 121     TLV::TLVType dummyType = TLV::kTLVType_NotSpecified;
 122     ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType));
 123
 124     uint8_t argSeqNumber = 0;
 125     // percentOpen: int8u
 126     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), percentOpen));
 127
 128     ReturnErrorOnFailure(writer.EndContainer(dummyType));
 129     ReturnErrorOnFailure(writer.Finalize());
 130     ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams));
 131
 132     return mDevice->SendCommands();
 133 #else
 134     uint8_t seqNum = mDevice->GetNextSequenceNumber();
 135     System::PacketBufferHandle encodedCommand =
 136         encodeBarrierControlClusterBarrierControlGoToPercentCommand(seqNum, mEndpoint, percentOpen);
 137     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
 138 #endif
 139 }
 140
 141 CHIP_ERROR BarrierControlCluster::BarrierControlStop(Callback::Cancelable * onSuccessCallback,
 142                                                      Callback::Cancelable * onFailureCallback)
 143 {
 144 #if CHIP_ENABLE_INTERACTION_MODEL
 145     VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE);
 146     (void) onSuccessCallback;
 147     (void) onFailureCallback;
 148
 149     app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kBarrierControlStopCommandId,
 150                                               (chip::app::Command::CommandPathFlags::kEndpointIdValid) };
 151     app::Command * ZCLcommand             = mDevice->GetCommandSender();
 152
 153     TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter();
 154
 155     TLV::TLVType dummyType = TLV::kTLVType_NotSpecified;
 156     ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType));
 157
 158     // Command takes no arguments.
 159
 160     ReturnErrorOnFailure(writer.EndContainer(dummyType));
 161     ReturnErrorOnFailure(writer.Finalize());
 162     ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams));
 163
 164     return mDevice->SendCommands();
 165 #else
 166     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
 167     System::PacketBufferHandle encodedCommand = encodeBarrierControlClusterBarrierControlStopCommand(seqNum, mEndpoint);
 168     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
 169 #endif
 170 }
 171
 172 // BarrierControl Cluster Attributes
 173 CHIP_ERROR BarrierControlCluster::DiscoverAttributes(Callback::Cancelable * onSuccessCallback,
 174                                                      Callback::Cancelable * onFailureCallback)
 175 {
 176     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
 177     System::PacketBufferHandle encodedCommand = encodeBarrierControlClusterDiscoverAttributes(seqNum, mEndpoint);
 178     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
 179 }
 180 CHIP_ERROR BarrierControlCluster::ReadAttributeBarrierMovingState(Callback::Cancelable * onSuccessCallback,
 181                                                                   Callback::Cancelable * onFailureCallback)
 182 {
 183     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
 184     System::PacketBufferHandle encodedCommand = encodeBarrierControlClusterReadBarrierMovingStateAttribute(seqNum, mEndpoint);
 185     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
 186 }
 187
 188 CHIP_ERROR BarrierControlCluster::ReadAttributeBarrierSafetyStatus(Callback::Cancelable * onSuccessCallback,
 189                                                                    Callback::Cancelable * onFailureCallback)
 190 {
 191     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
 192     System::PacketBufferHandle encodedCommand = encodeBarrierControlClusterReadBarrierSafetyStatusAttribute(seqNum, mEndpoint);
 193     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
 194 }
 195
 196 CHIP_ERROR BarrierControlCluster::ReadAttributeBarrierCapabilities(Callback::Cancelable * onSuccessCallback,
 197                                                                    Callback::Cancelable * onFailureCallback)
 198 {
 199     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
 200     System::PacketBufferHandle encodedCommand = encodeBarrierControlClusterReadBarrierCapabilitiesAttribute(seqNum, mEndpoint);
 201     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
 202 }
 203
 204 CHIP_ERROR BarrierControlCluster::ReadAttributeBarrierPosition(Callback::Cancelable * onSuccessCallback,
 205                                                                Callback::Cancelable * onFailureCallback)
 206 {
 207     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
 208     System::PacketBufferHandle encodedCommand = encodeBarrierControlClusterReadBarrierPositionAttribute(seqNum, mEndpoint);
 209     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
 210 }
 211
 212 CHIP_ERROR BarrierControlCluster::ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback,
 213                                                                Callback::Cancelable * onFailureCallback)
 214 {
 215     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
 216     System::PacketBufferHandle encodedCommand = encodeBarrierControlClusterReadClusterRevisionAttribute(seqNum, mEndpoint);
 217     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
 218 }
 219
 220 // Basic Cluster Commands
 221 CHIP_ERROR BasicCluster::MfgSpecificPing(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback)
 222 {
 223 #if CHIP_ENABLE_INTERACTION_MODEL
 224     VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE);
 225     (void) onSuccessCallback;
 226     (void) onFailureCallback;
 227
 228     app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kMfgSpecificPingCommandId,
 229                                               (chip::app::Command::CommandPathFlags::kEndpointIdValid) };
 230     app::Command * ZCLcommand             = mDevice->GetCommandSender();
 231
 232     TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter();
 233
 234     TLV::TLVType dummyType = TLV::kTLVType_NotSpecified;
 235     ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType));
 236
 237     // Command takes no arguments.
 238
 239     ReturnErrorOnFailure(writer.EndContainer(dummyType));
 240     ReturnErrorOnFailure(writer.Finalize());
 241     ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams));
 242
 243     return mDevice->SendCommands();
 244 #else
 245     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
 246     System::PacketBufferHandle encodedCommand = encodeBasicClusterMfgSpecificPingCommand(seqNum, mEndpoint);
 247     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
 248 #endif
 249 }
 250
 251 // Basic Cluster Attributes
 252 CHIP_ERROR BasicCluster::DiscoverAttributes(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback)
 253 {
 254     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
 255     System::PacketBufferHandle encodedCommand = encodeBasicClusterDiscoverAttributes(seqNum, mEndpoint);
 256     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
 257 }
 258 CHIP_ERROR BasicCluster::ReadAttributeInteractionModelVersion(Callback::Cancelable * onSuccessCallback,
 259                                                               Callback::Cancelable * onFailureCallback)
 260 {
 261     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
 262     System::PacketBufferHandle encodedCommand = encodeBasicClusterReadInteractionModelVersionAttribute(seqNum, mEndpoint);
 263     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
 264 }
 265
 266 CHIP_ERROR BasicCluster::ReadAttributeVendorName(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback)
 267 {
 268     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
 269     System::PacketBufferHandle encodedCommand = encodeBasicClusterReadVendorNameAttribute(seqNum, mEndpoint);
 270     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
 271 }
 272
 273 CHIP_ERROR BasicCluster::ReadAttributeVendorID(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback)
 274 {
 275     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
 276     System::PacketBufferHandle encodedCommand = encodeBasicClusterReadVendorIDAttribute(seqNum, mEndpoint);
 277     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
 278 }
 279
 280 CHIP_ERROR BasicCluster::ReadAttributeProductName(Callback::Cancelable * onSuccessCallback,
 281                                                   Callback::Cancelable * onFailureCallback)
 282 {
 283     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
 284     System::PacketBufferHandle encodedCommand = encodeBasicClusterReadProductNameAttribute(seqNum, mEndpoint);
 285     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
 286 }
 287
 288 CHIP_ERROR BasicCluster::ReadAttributeProductID(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback)
 289 {
 290     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
 291     System::PacketBufferHandle encodedCommand = encodeBasicClusterReadProductIDAttribute(seqNum, mEndpoint);
 292     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
 293 }
 294
 295 CHIP_ERROR BasicCluster::ReadAttributeUserLabel(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback)
 296 {
 297     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
 298     System::PacketBufferHandle encodedCommand = encodeBasicClusterReadUserLabelAttribute(seqNum, mEndpoint);
 299     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
 300 }
 301
 302 CHIP_ERROR BasicCluster::WriteAttributeUserLabel(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback,
 303                                                  chip::ByteSpan value)
 304 {
 305     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
 306     System::PacketBufferHandle encodedCommand = encodeBasicClusterWriteUserLabelAttribute(seqNum, mEndpoint, value);
 307     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
 308 }
 309
 310 CHIP_ERROR BasicCluster::ReadAttributeLocation(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback)
 311 {
 312     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
 313     System::PacketBufferHandle encodedCommand = encodeBasicClusterReadLocationAttribute(seqNum, mEndpoint);
 314     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
 315 }
 316
 317 CHIP_ERROR BasicCluster::WriteAttributeLocation(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback,
 318                                                 chip::ByteSpan value)
 319 {
 320     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
 321     System::PacketBufferHandle encodedCommand = encodeBasicClusterWriteLocationAttribute(seqNum, mEndpoint, value);
 322     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
 323 }
 324
 325 CHIP_ERROR BasicCluster::ReadAttributeHardwareVersion(Callback::Cancelable * onSuccessCallback,
 326                                                       Callback::Cancelable * onFailureCallback)
 327 {
 328     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
 329     System::PacketBufferHandle encodedCommand = encodeBasicClusterReadHardwareVersionAttribute(seqNum, mEndpoint);
 330     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
 331 }
 332
 333 CHIP_ERROR BasicCluster::ReadAttributeHardwareVersionString(Callback::Cancelable * onSuccessCallback,
 334                                                             Callback::Cancelable * onFailureCallback)
 335 {
 336     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
 337     System::PacketBufferHandle encodedCommand = encodeBasicClusterReadHardwareVersionStringAttribute(seqNum, mEndpoint);
 338     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
 339 }
 340
 341 CHIP_ERROR BasicCluster::ReadAttributeSoftwareVersion(Callback::Cancelable * onSuccessCallback,
 342                                                       Callback::Cancelable * onFailureCallback)
 343 {
 344     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
 345     System::PacketBufferHandle encodedCommand = encodeBasicClusterReadSoftwareVersionAttribute(seqNum, mEndpoint);
 346     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
 347 }
 348
 349 CHIP_ERROR BasicCluster::ReadAttributeSoftwareVersionString(Callback::Cancelable * onSuccessCallback,
 350                                                             Callback::Cancelable * onFailureCallback)
 351 {
 352     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
 353     System::PacketBufferHandle encodedCommand = encodeBasicClusterReadSoftwareVersionStringAttribute(seqNum, mEndpoint);
 354     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
 355 }
 356
 357 CHIP_ERROR BasicCluster::ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback,
 358                                                       Callback::Cancelable * onFailureCallback)
 359 {
 360     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
 361     System::PacketBufferHandle encodedCommand = encodeBasicClusterReadClusterRevisionAttribute(seqNum, mEndpoint);
 362     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
 363 }
 364
 365 // Binding Cluster Commands
 366 CHIP_ERROR BindingCluster::Bind(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback,
 367                                 chip::NodeId nodeId, chip::GroupId groupId, chip::EndpointId endpointId, chip::ClusterId clusterId)
 368 {
 369 #if CHIP_ENABLE_INTERACTION_MODEL
 370     VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE);
 371     (void) onSuccessCallback;
 372     (void) onFailureCallback;
 373
 374     app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kBindCommandId,
 375                                               (chip::app::Command::CommandPathFlags::kEndpointIdValid) };
 376     app::Command * ZCLcommand             = mDevice->GetCommandSender();
 377
 378     TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter();
 379
 380     TLV::TLVType dummyType = TLV::kTLVType_NotSpecified;
 381     ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType));
 382
 383     uint8_t argSeqNumber = 0;
 384     // nodeId: nodeId
 385     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), nodeId));
 386     // groupId: groupId
 387     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), groupId));
 388     // endpointId: endpointId
 389     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), endpointId));
 390     // clusterId: clusterId
 391     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), clusterId));
 392
 393     ReturnErrorOnFailure(writer.EndContainer(dummyType));
 394     ReturnErrorOnFailure(writer.Finalize());
 395     ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams));
 396
 397     return mDevice->SendCommands();
 398 #else
 399     uint8_t seqNum = mDevice->GetNextSequenceNumber();
 400     System::PacketBufferHandle encodedCommand =
 401         encodeBindingClusterBindCommand(seqNum, mEndpoint, nodeId, groupId, endpointId, clusterId);
 402     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
 403 #endif
 404 }
 405
 406 CHIP_ERROR BindingCluster::Unbind(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback,
 407                                   chip::NodeId nodeId, chip::GroupId groupId, chip::EndpointId endpointId,
 408                                   chip::ClusterId clusterId)
 409 {
 410 #if CHIP_ENABLE_INTERACTION_MODEL
 411     VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE);
 412     (void) onSuccessCallback;
 413     (void) onFailureCallback;
 414
 415     app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kUnbindCommandId,
 416                                               (chip::app::Command::CommandPathFlags::kEndpointIdValid) };
 417     app::Command * ZCLcommand             = mDevice->GetCommandSender();
 418
 419     TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter();
 420
 421     TLV::TLVType dummyType = TLV::kTLVType_NotSpecified;
 422     ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType));
 423
 424     uint8_t argSeqNumber = 0;
 425     // nodeId: nodeId
 426     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), nodeId));
 427     // groupId: groupId
 428     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), groupId));
 429     // endpointId: endpointId
 430     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), endpointId));
 431     // clusterId: clusterId
 432     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), clusterId));
 433
 434     ReturnErrorOnFailure(writer.EndContainer(dummyType));
 435     ReturnErrorOnFailure(writer.Finalize());
 436     ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams));
 437
 438     return mDevice->SendCommands();
 439 #else
 440     uint8_t seqNum = mDevice->GetNextSequenceNumber();
 441     System::PacketBufferHandle encodedCommand =
 442         encodeBindingClusterUnbindCommand(seqNum, mEndpoint, nodeId, groupId, endpointId, clusterId);
 443     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
 444 #endif
 445 }
 446
 447 // Binding Cluster Attributes
 448 CHIP_ERROR BindingCluster::DiscoverAttributes(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback)
 449 {
 450     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
 451     System::PacketBufferHandle encodedCommand = encodeBindingClusterDiscoverAttributes(seqNum, mEndpoint);
 452     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
 453 }
 454 CHIP_ERROR BindingCluster::ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback,
 455                                                         Callback::Cancelable * onFailureCallback)
 456 {
 457     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
 458     System::PacketBufferHandle encodedCommand = encodeBindingClusterReadClusterRevisionAttribute(seqNum, mEndpoint);
 459     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
 460 }
 461
 462 // ColorControl Cluster Commands
 463 CHIP_ERROR ColorControlCluster::MoveColor(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback,
 464                                           int16_t rateX, int16_t rateY, uint8_t optionsMask, uint8_t optionsOverride)
 465 {
 466 #if CHIP_ENABLE_INTERACTION_MODEL
 467     VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE);
 468     (void) onSuccessCallback;
 469     (void) onFailureCallback;
 470
 471     app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kMoveColorCommandId,
 472                                               (chip::app::Command::CommandPathFlags::kEndpointIdValid) };
 473     app::Command * ZCLcommand             = mDevice->GetCommandSender();
 474
 475     TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter();
 476
 477     TLV::TLVType dummyType = TLV::kTLVType_NotSpecified;
 478     ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType));
 479
 480     uint8_t argSeqNumber = 0;
 481     // rateX: int16s
 482     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), rateX));
 483     // rateY: int16s
 484     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), rateY));
 485     // optionsMask: bitmap8
 486     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), optionsMask));
 487     // optionsOverride: bitmap8
 488     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), optionsOverride));
 489
 490     ReturnErrorOnFailure(writer.EndContainer(dummyType));
 491     ReturnErrorOnFailure(writer.Finalize());
 492     ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams));
 493
 494     return mDevice->SendCommands();
 495 #else
 496     uint8_t seqNum = mDevice->GetNextSequenceNumber();
 497     System::PacketBufferHandle encodedCommand =
 498         encodeColorControlClusterMoveColorCommand(seqNum, mEndpoint, rateX, rateY, optionsMask, optionsOverride);
 499     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
 500 #endif
 501 }
 502
 503 CHIP_ERROR ColorControlCluster::MoveColorTemperature(Callback::Cancelable * onSuccessCallback,
 504                                                      Callback::Cancelable * onFailureCallback, uint8_t moveMode, uint16_t rate,
 505                                                      uint16_t colorTemperatureMinimum, uint16_t colorTemperatureMaximum,
 506                                                      uint8_t optionsMask, uint8_t optionsOverride)
 507 {
 508 #if CHIP_ENABLE_INTERACTION_MODEL
 509     VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE);
 510     (void) onSuccessCallback;
 511     (void) onFailureCallback;
 512
 513     app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kMoveColorTemperatureCommandId,
 514                                               (chip::app::Command::CommandPathFlags::kEndpointIdValid) };
 515     app::Command * ZCLcommand             = mDevice->GetCommandSender();
 516
 517     TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter();
 518
 519     TLV::TLVType dummyType = TLV::kTLVType_NotSpecified;
 520     ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType));
 521
 522     uint8_t argSeqNumber = 0;
 523     // moveMode: hueMoveMode
 524     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), moveMode));
 525     // rate: int16u
 526     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), rate));
 527     // colorTemperatureMinimum: int16u
 528     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), colorTemperatureMinimum));
 529     // colorTemperatureMaximum: int16u
 530     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), colorTemperatureMaximum));
 531     // optionsMask: bitmap8
 532     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), optionsMask));
 533     // optionsOverride: bitmap8
 534     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), optionsOverride));
 535
 536     ReturnErrorOnFailure(writer.EndContainer(dummyType));
 537     ReturnErrorOnFailure(writer.Finalize());
 538     ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams));
 539
 540     return mDevice->SendCommands();
 541 #else
 542     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
 543     System::PacketBufferHandle encodedCommand = encodeColorControlClusterMoveColorTemperatureCommand(
 544         seqNum, mEndpoint, moveMode, rate, colorTemperatureMinimum, colorTemperatureMaximum, optionsMask, optionsOverride);
 545     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
 546 #endif
 547 }
 548
 549 CHIP_ERROR ColorControlCluster::MoveHue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback,
 550                                         uint8_t moveMode, uint8_t rate, uint8_t optionsMask, uint8_t optionsOverride)
 551 {
 552 #if CHIP_ENABLE_INTERACTION_MODEL
 553     VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE);
 554     (void) onSuccessCallback;
 555     (void) onFailureCallback;
 556
 557     app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kMoveHueCommandId,
 558                                               (chip::app::Command::CommandPathFlags::kEndpointIdValid) };
 559     app::Command * ZCLcommand             = mDevice->GetCommandSender();
 560
 561     TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter();
 562
 563     TLV::TLVType dummyType = TLV::kTLVType_NotSpecified;
 564     ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType));
 565
 566     uint8_t argSeqNumber = 0;
 567     // moveMode: hueMoveMode
 568     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), moveMode));
 569     // rate: int8u
 570     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), rate));
 571     // optionsMask: bitmap8
 572     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), optionsMask));
 573     // optionsOverride: bitmap8
 574     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), optionsOverride));
 575
 576     ReturnErrorOnFailure(writer.EndContainer(dummyType));
 577     ReturnErrorOnFailure(writer.Finalize());
 578     ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams));
 579
 580     return mDevice->SendCommands();
 581 #else
 582     uint8_t seqNum = mDevice->GetNextSequenceNumber();
 583     System::PacketBufferHandle encodedCommand =
 584         encodeColorControlClusterMoveHueCommand(seqNum, mEndpoint, moveMode, rate, optionsMask, optionsOverride);
 585     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
 586 #endif
 587 }
 588
 589 CHIP_ERROR ColorControlCluster::MoveSaturation(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback,
 590                                                uint8_t moveMode, uint8_t rate, uint8_t optionsMask, uint8_t optionsOverride)
 591 {
 592 #if CHIP_ENABLE_INTERACTION_MODEL
 593     VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE);
 594     (void) onSuccessCallback;
 595     (void) onFailureCallback;
 596
 597     app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kMoveSaturationCommandId,
 598                                               (chip::app::Command::CommandPathFlags::kEndpointIdValid) };
 599     app::Command * ZCLcommand             = mDevice->GetCommandSender();
 600
 601     TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter();
 602
 603     TLV::TLVType dummyType = TLV::kTLVType_NotSpecified;
 604     ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType));
 605
 606     uint8_t argSeqNumber = 0;
 607     // moveMode: saturationMoveMode
 608     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), moveMode));
 609     // rate: int8u
 610     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), rate));
 611     // optionsMask: bitmap8
 612     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), optionsMask));
 613     // optionsOverride: bitmap8
 614     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), optionsOverride));
 615
 616     ReturnErrorOnFailure(writer.EndContainer(dummyType));
 617     ReturnErrorOnFailure(writer.Finalize());
 618     ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams));
 619
 620     return mDevice->SendCommands();
 621 #else
 622     uint8_t seqNum = mDevice->GetNextSequenceNumber();
 623     System::PacketBufferHandle encodedCommand =
 624         encodeColorControlClusterMoveSaturationCommand(seqNum, mEndpoint, moveMode, rate, optionsMask, optionsOverride);
 625     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
 626 #endif
 627 }
 628
 629 CHIP_ERROR ColorControlCluster::MoveToColor(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback,
 630                                             uint16_t colorX, uint16_t colorY, uint16_t transitionTime, uint8_t optionsMask,
 631                                             uint8_t optionsOverride)
 632 {
 633 #if CHIP_ENABLE_INTERACTION_MODEL
 634     VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE);
 635     (void) onSuccessCallback;
 636     (void) onFailureCallback;
 637
 638     app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kMoveToColorCommandId,
 639                                               (chip::app::Command::CommandPathFlags::kEndpointIdValid) };
 640     app::Command * ZCLcommand             = mDevice->GetCommandSender();
 641
 642     TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter();
 643
 644     TLV::TLVType dummyType = TLV::kTLVType_NotSpecified;
 645     ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType));
 646
 647     uint8_t argSeqNumber = 0;
 648     // colorX: int16u
 649     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), colorX));
 650     // colorY: int16u
 651     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), colorY));
 652     // transitionTime: int16u
 653     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), transitionTime));
 654     // optionsMask: bitmap8
 655     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), optionsMask));
 656     // optionsOverride: bitmap8
 657     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), optionsOverride));
 658
 659     ReturnErrorOnFailure(writer.EndContainer(dummyType));
 660     ReturnErrorOnFailure(writer.Finalize());
 661     ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams));
 662
 663     return mDevice->SendCommands();
 664 #else
 665     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
 666     System::PacketBufferHandle encodedCommand = encodeColorControlClusterMoveToColorCommand(
 667         seqNum, mEndpoint, colorX, colorY, transitionTime, optionsMask, optionsOverride);
 668     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
 669 #endif
 670 }
 671
 672 CHIP_ERROR ColorControlCluster::MoveToColorTemperature(Callback::Cancelable * onSuccessCallback,
 673                                                        Callback::Cancelable * onFailureCallback, uint16_t colorTemperature,
 674                                                        uint16_t transitionTime, uint8_t optionsMask, uint8_t optionsOverride)
 675 {
 676 #if CHIP_ENABLE_INTERACTION_MODEL
 677     VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE);
 678     (void) onSuccessCallback;
 679     (void) onFailureCallback;
 680
 681     app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kMoveToColorTemperatureCommandId,
 682                                               (chip::app::Command::CommandPathFlags::kEndpointIdValid) };
 683     app::Command * ZCLcommand             = mDevice->GetCommandSender();
 684
 685     TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter();
 686
 687     TLV::TLVType dummyType = TLV::kTLVType_NotSpecified;
 688     ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType));
 689
 690     uint8_t argSeqNumber = 0;
 691     // colorTemperature: int16u
 692     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), colorTemperature));
 693     // transitionTime: int16u
 694     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), transitionTime));
 695     // optionsMask: bitmap8
 696     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), optionsMask));
 697     // optionsOverride: bitmap8
 698     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), optionsOverride));
 699
 700     ReturnErrorOnFailure(writer.EndContainer(dummyType));
 701     ReturnErrorOnFailure(writer.Finalize());
 702     ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams));
 703
 704     return mDevice->SendCommands();
 705 #else
 706     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
 707     System::PacketBufferHandle encodedCommand = encodeColorControlClusterMoveToColorTemperatureCommand(
 708         seqNum, mEndpoint, colorTemperature, transitionTime, optionsMask, optionsOverride);
 709     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
 710 #endif
 711 }
 712
 713 CHIP_ERROR ColorControlCluster::MoveToHue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback,
 714                                           uint8_t hue, uint8_t direction, uint16_t transitionTime, uint8_t optionsMask,
 715                                           uint8_t optionsOverride)
 716 {
 717 #if CHIP_ENABLE_INTERACTION_MODEL
 718     VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE);
 719     (void) onSuccessCallback;
 720     (void) onFailureCallback;
 721
 722     app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kMoveToHueCommandId,
 723                                               (chip::app::Command::CommandPathFlags::kEndpointIdValid) };
 724     app::Command * ZCLcommand             = mDevice->GetCommandSender();
 725
 726     TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter();
 727
 728     TLV::TLVType dummyType = TLV::kTLVType_NotSpecified;
 729     ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType));
 730
 731     uint8_t argSeqNumber = 0;
 732     // hue: int8u
 733     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), hue));
 734     // direction: hueDirection
 735     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), direction));
 736     // transitionTime: int16u
 737     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), transitionTime));
 738     // optionsMask: bitmap8
 739     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), optionsMask));
 740     // optionsOverride: bitmap8
 741     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), optionsOverride));
 742
 743     ReturnErrorOnFailure(writer.EndContainer(dummyType));
 744     ReturnErrorOnFailure(writer.Finalize());
 745     ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams));
 746
 747     return mDevice->SendCommands();
 748 #else
 749     uint8_t seqNum = mDevice->GetNextSequenceNumber();
 750     System::PacketBufferHandle encodedCommand =
 751         encodeColorControlClusterMoveToHueCommand(seqNum, mEndpoint, hue, direction, transitionTime, optionsMask, optionsOverride);
 752     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
 753 #endif
 754 }
 755
 756 CHIP_ERROR ColorControlCluster::MoveToHueAndSaturation(Callback::Cancelable * onSuccessCallback,
 757                                                        Callback::Cancelable * onFailureCallback, uint8_t hue, uint8_t saturation,
 758                                                        uint16_t transitionTime, uint8_t optionsMask, uint8_t optionsOverride)
 759 {
 760 #if CHIP_ENABLE_INTERACTION_MODEL
 761     VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE);
 762     (void) onSuccessCallback;
 763     (void) onFailureCallback;
 764
 765     app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kMoveToHueAndSaturationCommandId,
 766                                               (chip::app::Command::CommandPathFlags::kEndpointIdValid) };
 767     app::Command * ZCLcommand             = mDevice->GetCommandSender();
 768
 769     TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter();
 770
 771     TLV::TLVType dummyType = TLV::kTLVType_NotSpecified;
 772     ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType));
 773
 774     uint8_t argSeqNumber = 0;
 775     // hue: int8u
 776     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), hue));
 777     // saturation: int8u
 778     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), saturation));
 779     // transitionTime: int16u
 780     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), transitionTime));
 781     // optionsMask: bitmap8
 782     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), optionsMask));
 783     // optionsOverride: bitmap8
 784     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), optionsOverride));
 785
 786     ReturnErrorOnFailure(writer.EndContainer(dummyType));
 787     ReturnErrorOnFailure(writer.Finalize());
 788     ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams));
 789
 790     return mDevice->SendCommands();
 791 #else
 792     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
 793     System::PacketBufferHandle encodedCommand = encodeColorControlClusterMoveToHueAndSaturationCommand(
 794         seqNum, mEndpoint, hue, saturation, transitionTime, optionsMask, optionsOverride);
 795     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
 796 #endif
 797 }
 798
 799 CHIP_ERROR ColorControlCluster::MoveToSaturation(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback,
 800                                                  uint8_t saturation, uint16_t transitionTime, uint8_t optionsMask,
 801                                                  uint8_t optionsOverride)
 802 {
 803 #if CHIP_ENABLE_INTERACTION_MODEL
 804     VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE);
 805     (void) onSuccessCallback;
 806     (void) onFailureCallback;
 807
 808     app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kMoveToSaturationCommandId,
 809                                               (chip::app::Command::CommandPathFlags::kEndpointIdValid) };
 810     app::Command * ZCLcommand             = mDevice->GetCommandSender();
 811
 812     TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter();
 813
 814     TLV::TLVType dummyType = TLV::kTLVType_NotSpecified;
 815     ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType));
 816
 817     uint8_t argSeqNumber = 0;
 818     // saturation: int8u
 819     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), saturation));
 820     // transitionTime: int16u
 821     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), transitionTime));
 822     // optionsMask: bitmap8
 823     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), optionsMask));
 824     // optionsOverride: bitmap8
 825     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), optionsOverride));
 826
 827     ReturnErrorOnFailure(writer.EndContainer(dummyType));
 828     ReturnErrorOnFailure(writer.Finalize());
 829     ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams));
 830
 831     return mDevice->SendCommands();
 832 #else
 833     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
 834     System::PacketBufferHandle encodedCommand = encodeColorControlClusterMoveToSaturationCommand(
 835         seqNum, mEndpoint, saturation, transitionTime, optionsMask, optionsOverride);
 836     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
 837 #endif
 838 }
 839
 840 CHIP_ERROR ColorControlCluster::StepColor(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback,
 841                                           int16_t stepX, int16_t stepY, uint16_t transitionTime, uint8_t optionsMask,
 842                                           uint8_t optionsOverride)
 843 {
 844 #if CHIP_ENABLE_INTERACTION_MODEL
 845     VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE);
 846     (void) onSuccessCallback;
 847     (void) onFailureCallback;
 848
 849     app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kStepColorCommandId,
 850                                               (chip::app::Command::CommandPathFlags::kEndpointIdValid) };
 851     app::Command * ZCLcommand             = mDevice->GetCommandSender();
 852
 853     TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter();
 854
 855     TLV::TLVType dummyType = TLV::kTLVType_NotSpecified;
 856     ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType));
 857
 858     uint8_t argSeqNumber = 0;
 859     // stepX: int16s
 860     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), stepX));
 861     // stepY: int16s
 862     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), stepY));
 863     // transitionTime: int16u
 864     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), transitionTime));
 865     // optionsMask: bitmap8
 866     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), optionsMask));
 867     // optionsOverride: bitmap8
 868     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), optionsOverride));
 869
 870     ReturnErrorOnFailure(writer.EndContainer(dummyType));
 871     ReturnErrorOnFailure(writer.Finalize());
 872     ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams));
 873
 874     return mDevice->SendCommands();
 875 #else
 876     uint8_t seqNum = mDevice->GetNextSequenceNumber();
 877     System::PacketBufferHandle encodedCommand =
 878         encodeColorControlClusterStepColorCommand(seqNum, mEndpoint, stepX, stepY, transitionTime, optionsMask, optionsOverride);
 879     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
 880 #endif
 881 }
 882
 883 CHIP_ERROR ColorControlCluster::StepColorTemperature(Callback::Cancelable * onSuccessCallback,
 884                                                      Callback::Cancelable * onFailureCallback, uint8_t stepMode, uint16_t stepSize,
 885                                                      uint16_t transitionTime, uint16_t colorTemperatureMinimum,
 886                                                      uint16_t colorTemperatureMaximum, uint8_t optionsMask, uint8_t optionsOverride)
 887 {
 888 #if CHIP_ENABLE_INTERACTION_MODEL
 889     VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE);
 890     (void) onSuccessCallback;
 891     (void) onFailureCallback;
 892
 893     app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kStepColorTemperatureCommandId,
 894                                               (chip::app::Command::CommandPathFlags::kEndpointIdValid) };
 895     app::Command * ZCLcommand             = mDevice->GetCommandSender();
 896
 897     TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter();
 898
 899     TLV::TLVType dummyType = TLV::kTLVType_NotSpecified;
 900     ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType));
 901
 902     uint8_t argSeqNumber = 0;
 903     // stepMode: hueStepMode
 904     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), stepMode));
 905     // stepSize: int16u
 906     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), stepSize));
 907     // transitionTime: int16u
 908     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), transitionTime));
 909     // colorTemperatureMinimum: int16u
 910     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), colorTemperatureMinimum));
 911     // colorTemperatureMaximum: int16u
 912     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), colorTemperatureMaximum));
 913     // optionsMask: bitmap8
 914     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), optionsMask));
 915     // optionsOverride: bitmap8
 916     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), optionsOverride));
 917
 918     ReturnErrorOnFailure(writer.EndContainer(dummyType));
 919     ReturnErrorOnFailure(writer.Finalize());
 920     ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams));
 921
 922     return mDevice->SendCommands();
 923 #else
 924     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
 925     System::PacketBufferHandle encodedCommand = encodeColorControlClusterStepColorTemperatureCommand(
 926         seqNum, mEndpoint, stepMode, stepSize, transitionTime, colorTemperatureMinimum, colorTemperatureMaximum, optionsMask,
 927         optionsOverride);
 928     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
 929 #endif
 930 }
 931
 932 CHIP_ERROR ColorControlCluster::StepHue(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback,
 933                                         uint8_t stepMode, uint8_t stepSize, uint8_t transitionTime, uint8_t optionsMask,
 934                                         uint8_t optionsOverride)
 935 {
 936 #if CHIP_ENABLE_INTERACTION_MODEL
 937     VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE);
 938     (void) onSuccessCallback;
 939     (void) onFailureCallback;
 940
 941     app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kStepHueCommandId,
 942                                               (chip::app::Command::CommandPathFlags::kEndpointIdValid) };
 943     app::Command * ZCLcommand             = mDevice->GetCommandSender();
 944
 945     TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter();
 946
 947     TLV::TLVType dummyType = TLV::kTLVType_NotSpecified;
 948     ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType));
 949
 950     uint8_t argSeqNumber = 0;
 951     // stepMode: hueStepMode
 952     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), stepMode));
 953     // stepSize: int8u
 954     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), stepSize));
 955     // transitionTime: int8u
 956     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), transitionTime));
 957     // optionsMask: bitmap8
 958     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), optionsMask));
 959     // optionsOverride: bitmap8
 960     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), optionsOverride));
 961
 962     ReturnErrorOnFailure(writer.EndContainer(dummyType));
 963     ReturnErrorOnFailure(writer.Finalize());
 964     ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams));
 965
 966     return mDevice->SendCommands();
 967 #else
 968     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
 969     System::PacketBufferHandle encodedCommand = encodeColorControlClusterStepHueCommand(
 970         seqNum, mEndpoint, stepMode, stepSize, transitionTime, optionsMask, optionsOverride);
 971     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
 972 #endif
 973 }
 974
 975 CHIP_ERROR ColorControlCluster::StepSaturation(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback,
 976                                                uint8_t stepMode, uint8_t stepSize, uint8_t transitionTime, uint8_t optionsMask,
 977                                                uint8_t optionsOverride)
 978 {
 979 #if CHIP_ENABLE_INTERACTION_MODEL
 980     VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE);
 981     (void) onSuccessCallback;
 982     (void) onFailureCallback;
 983
 984     app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kStepSaturationCommandId,
 985                                               (chip::app::Command::CommandPathFlags::kEndpointIdValid) };
 986     app::Command * ZCLcommand             = mDevice->GetCommandSender();
 987
 988     TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter();
 989
 990     TLV::TLVType dummyType = TLV::kTLVType_NotSpecified;
 991     ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType));
 992
 993     uint8_t argSeqNumber = 0;
 994     // stepMode: saturationStepMode
 995     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), stepMode));
 996     // stepSize: int8u
 997     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), stepSize));
 998     // transitionTime: int8u
 999     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), transitionTime));
1000     // optionsMask: bitmap8
1001     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), optionsMask));
1002     // optionsOverride: bitmap8
1003     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), optionsOverride));
1004
1005     ReturnErrorOnFailure(writer.EndContainer(dummyType));
1006     ReturnErrorOnFailure(writer.Finalize());
1007     ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams));
1008
1009     return mDevice->SendCommands();
1010 #else
1011     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
1012     System::PacketBufferHandle encodedCommand = encodeColorControlClusterStepSaturationCommand(
1013         seqNum, mEndpoint, stepMode, stepSize, transitionTime, optionsMask, optionsOverride);
1014     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
1015 #endif
1016 }
1017
1018 CHIP_ERROR ColorControlCluster::StopMoveStep(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback,
1019                                              uint8_t optionsMask, uint8_t optionsOverride)
1020 {
1021 #if CHIP_ENABLE_INTERACTION_MODEL
1022     VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE);
1023     (void) onSuccessCallback;
1024     (void) onFailureCallback;
1025
1026     app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kStopMoveStepCommandId,
1027                                               (chip::app::Command::CommandPathFlags::kEndpointIdValid) };
1028     app::Command * ZCLcommand             = mDevice->GetCommandSender();
1029
1030     TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter();
1031
1032     TLV::TLVType dummyType = TLV::kTLVType_NotSpecified;
1033     ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType));
1034
1035     uint8_t argSeqNumber = 0;
1036     // optionsMask: bitmap8
1037     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), optionsMask));
1038     // optionsOverride: bitmap8
1039     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), optionsOverride));
1040
1041     ReturnErrorOnFailure(writer.EndContainer(dummyType));
1042     ReturnErrorOnFailure(writer.Finalize());
1043     ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams));
1044
1045     return mDevice->SendCommands();
1046 #else
1047     uint8_t seqNum = mDevice->GetNextSequenceNumber();
1048     System::PacketBufferHandle encodedCommand =
1049         encodeColorControlClusterStopMoveStepCommand(seqNum, mEndpoint, optionsMask, optionsOverride);
1050     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
1051 #endif
1052 }
1053
1054 // ColorControl Cluster Attributes
1055 CHIP_ERROR ColorControlCluster::DiscoverAttributes(Callback::Cancelable * onSuccessCallback,
1056                                                    Callback::Cancelable * onFailureCallback)
1057 {
1058     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
1059     System::PacketBufferHandle encodedCommand = encodeColorControlClusterDiscoverAttributes(seqNum, mEndpoint);
1060     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
1061 }
1062 CHIP_ERROR ColorControlCluster::ReadAttributeCurrentHue(Callback::Cancelable * onSuccessCallback,
1063                                                         Callback::Cancelable * onFailureCallback)
1064 {
1065     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
1066     System::PacketBufferHandle encodedCommand = encodeColorControlClusterReadCurrentHueAttribute(seqNum, mEndpoint);
1067     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
1068 }
1069
1070 CHIP_ERROR ColorControlCluster::ConfigureAttributeCurrentHue(Callback::Cancelable * onSuccessCallback,
1071                                                              Callback::Cancelable * onFailureCallback, uint16_t minInterval,
1072                                                              uint16_t maxInterval, uint8_t change)
1073 {
1074     uint8_t seqNum = mDevice->GetNextSequenceNumber();
1075     System::PacketBufferHandle encodedCommand =
1076         encodeColorControlClusterConfigureCurrentHueAttribute(seqNum, mEndpoint, minInterval, maxInterval, change);
1077     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
1078 }
1079
1080 CHIP_ERROR ColorControlCluster::ReportAttributeCurrentHue(Callback::Cancelable * onReportCallback)
1081 {
1082     return RequestAttributeReporting(0x0000, onReportCallback);
1083 }
1084
1085 CHIP_ERROR ColorControlCluster::ReadAttributeCurrentSaturation(Callback::Cancelable * onSuccessCallback,
1086                                                                Callback::Cancelable * onFailureCallback)
1087 {
1088     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
1089     System::PacketBufferHandle encodedCommand = encodeColorControlClusterReadCurrentSaturationAttribute(seqNum, mEndpoint);
1090     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
1091 }
1092
1093 CHIP_ERROR ColorControlCluster::ConfigureAttributeCurrentSaturation(Callback::Cancelable * onSuccessCallback,
1094                                                                     Callback::Cancelable * onFailureCallback, uint16_t minInterval,
1095                                                                     uint16_t maxInterval, uint8_t change)
1096 {
1097     uint8_t seqNum = mDevice->GetNextSequenceNumber();
1098     System::PacketBufferHandle encodedCommand =
1099         encodeColorControlClusterConfigureCurrentSaturationAttribute(seqNum, mEndpoint, minInterval, maxInterval, change);
1100     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
1101 }
1102
1103 CHIP_ERROR ColorControlCluster::ReportAttributeCurrentSaturation(Callback::Cancelable * onReportCallback)
1104 {
1105     return RequestAttributeReporting(0x0001, onReportCallback);
1106 }
1107
1108 CHIP_ERROR ColorControlCluster::ReadAttributeRemainingTime(Callback::Cancelable * onSuccessCallback,
1109                                                            Callback::Cancelable * onFailureCallback)
1110 {
1111     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
1112     System::PacketBufferHandle encodedCommand = encodeColorControlClusterReadRemainingTimeAttribute(seqNum, mEndpoint);
1113     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
1114 }
1115
1116 CHIP_ERROR ColorControlCluster::ReadAttributeCurrentX(Callback::Cancelable * onSuccessCallback,
1117                                                       Callback::Cancelable * onFailureCallback)
1118 {
1119     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
1120     System::PacketBufferHandle encodedCommand = encodeColorControlClusterReadCurrentXAttribute(seqNum, mEndpoint);
1121     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
1122 }
1123
1124 CHIP_ERROR ColorControlCluster::ConfigureAttributeCurrentX(Callback::Cancelable * onSuccessCallback,
1125                                                            Callback::Cancelable * onFailureCallback, uint16_t minInterval,
1126                                                            uint16_t maxInterval, uint16_t change)
1127 {
1128     uint8_t seqNum = mDevice->GetNextSequenceNumber();
1129     System::PacketBufferHandle encodedCommand =
1130         encodeColorControlClusterConfigureCurrentXAttribute(seqNum, mEndpoint, minInterval, maxInterval, change);
1131     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
1132 }
1133
1134 CHIP_ERROR ColorControlCluster::ReportAttributeCurrentX(Callback::Cancelable * onReportCallback)
1135 {
1136     return RequestAttributeReporting(0x0003, onReportCallback);
1137 }
1138
1139 CHIP_ERROR ColorControlCluster::ReadAttributeCurrentY(Callback::Cancelable * onSuccessCallback,
1140                                                       Callback::Cancelable * onFailureCallback)
1141 {
1142     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
1143     System::PacketBufferHandle encodedCommand = encodeColorControlClusterReadCurrentYAttribute(seqNum, mEndpoint);
1144     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
1145 }
1146
1147 CHIP_ERROR ColorControlCluster::ConfigureAttributeCurrentY(Callback::Cancelable * onSuccessCallback,
1148                                                            Callback::Cancelable * onFailureCallback, uint16_t minInterval,
1149                                                            uint16_t maxInterval, uint16_t change)
1150 {
1151     uint8_t seqNum = mDevice->GetNextSequenceNumber();
1152     System::PacketBufferHandle encodedCommand =
1153         encodeColorControlClusterConfigureCurrentYAttribute(seqNum, mEndpoint, minInterval, maxInterval, change);
1154     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
1155 }
1156
1157 CHIP_ERROR ColorControlCluster::ReportAttributeCurrentY(Callback::Cancelable * onReportCallback)
1158 {
1159     return RequestAttributeReporting(0x0004, onReportCallback);
1160 }
1161
1162 CHIP_ERROR ColorControlCluster::ReadAttributeDriftCompensation(Callback::Cancelable * onSuccessCallback,
1163                                                                Callback::Cancelable * onFailureCallback)
1164 {
1165     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
1166     System::PacketBufferHandle encodedCommand = encodeColorControlClusterReadDriftCompensationAttribute(seqNum, mEndpoint);
1167     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
1168 }
1169
1170 CHIP_ERROR ColorControlCluster::ReadAttributeCompensationText(Callback::Cancelable * onSuccessCallback,
1171                                                               Callback::Cancelable * onFailureCallback)
1172 {
1173     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
1174     System::PacketBufferHandle encodedCommand = encodeColorControlClusterReadCompensationTextAttribute(seqNum, mEndpoint);
1175     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
1176 }
1177
1178 CHIP_ERROR ColorControlCluster::ReadAttributeColorTemperature(Callback::Cancelable * onSuccessCallback,
1179                                                               Callback::Cancelable * onFailureCallback)
1180 {
1181     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
1182     System::PacketBufferHandle encodedCommand = encodeColorControlClusterReadColorTemperatureAttribute(seqNum, mEndpoint);
1183     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
1184 }
1185
1186 CHIP_ERROR ColorControlCluster::ConfigureAttributeColorTemperature(Callback::Cancelable * onSuccessCallback,
1187                                                                    Callback::Cancelable * onFailureCallback, uint16_t minInterval,
1188                                                                    uint16_t maxInterval, uint16_t change)
1189 {
1190     uint8_t seqNum = mDevice->GetNextSequenceNumber();
1191     System::PacketBufferHandle encodedCommand =
1192         encodeColorControlClusterConfigureColorTemperatureAttribute(seqNum, mEndpoint, minInterval, maxInterval, change);
1193     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
1194 }
1195
1196 CHIP_ERROR ColorControlCluster::ReportAttributeColorTemperature(Callback::Cancelable * onReportCallback)
1197 {
1198     return RequestAttributeReporting(0x0007, onReportCallback);
1199 }
1200
1201 CHIP_ERROR ColorControlCluster::ReadAttributeColorMode(Callback::Cancelable * onSuccessCallback,
1202                                                        Callback::Cancelable * onFailureCallback)
1203 {
1204     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
1205     System::PacketBufferHandle encodedCommand = encodeColorControlClusterReadColorModeAttribute(seqNum, mEndpoint);
1206     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
1207 }
1208
1209 CHIP_ERROR ColorControlCluster::ReadAttributeColorControlOptions(Callback::Cancelable * onSuccessCallback,
1210                                                                  Callback::Cancelable * onFailureCallback)
1211 {
1212     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
1213     System::PacketBufferHandle encodedCommand = encodeColorControlClusterReadColorControlOptionsAttribute(seqNum, mEndpoint);
1214     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
1215 }
1216
1217 CHIP_ERROR ColorControlCluster::WriteAttributeColorControlOptions(Callback::Cancelable * onSuccessCallback,
1218                                                                   Callback::Cancelable * onFailureCallback, uint8_t value)
1219 {
1220     uint8_t seqNum = mDevice->GetNextSequenceNumber();
1221     System::PacketBufferHandle encodedCommand =
1222         encodeColorControlClusterWriteColorControlOptionsAttribute(seqNum, mEndpoint, value);
1223     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
1224 }
1225
1226 CHIP_ERROR ColorControlCluster::ReadAttributeNumberOfPrimaries(Callback::Cancelable * onSuccessCallback,
1227                                                                Callback::Cancelable * onFailureCallback)
1228 {
1229     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
1230     System::PacketBufferHandle encodedCommand = encodeColorControlClusterReadNumberOfPrimariesAttribute(seqNum, mEndpoint);
1231     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
1232 }
1233
1234 CHIP_ERROR ColorControlCluster::ReadAttributePrimary1X(Callback::Cancelable * onSuccessCallback,
1235                                                        Callback::Cancelable * onFailureCallback)
1236 {
1237     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
1238     System::PacketBufferHandle encodedCommand = encodeColorControlClusterReadPrimary1XAttribute(seqNum, mEndpoint);
1239     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
1240 }
1241
1242 CHIP_ERROR ColorControlCluster::ReadAttributePrimary1Y(Callback::Cancelable * onSuccessCallback,
1243                                                        Callback::Cancelable * onFailureCallback)
1244 {
1245     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
1246     System::PacketBufferHandle encodedCommand = encodeColorControlClusterReadPrimary1YAttribute(seqNum, mEndpoint);
1247     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
1248 }
1249
1250 CHIP_ERROR ColorControlCluster::ReadAttributePrimary1Intensity(Callback::Cancelable * onSuccessCallback,
1251                                                                Callback::Cancelable * onFailureCallback)
1252 {
1253     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
1254     System::PacketBufferHandle encodedCommand = encodeColorControlClusterReadPrimary1IntensityAttribute(seqNum, mEndpoint);
1255     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
1256 }
1257
1258 CHIP_ERROR ColorControlCluster::ReadAttributePrimary2X(Callback::Cancelable * onSuccessCallback,
1259                                                        Callback::Cancelable * onFailureCallback)
1260 {
1261     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
1262     System::PacketBufferHandle encodedCommand = encodeColorControlClusterReadPrimary2XAttribute(seqNum, mEndpoint);
1263     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
1264 }
1265
1266 CHIP_ERROR ColorControlCluster::ReadAttributePrimary2Y(Callback::Cancelable * onSuccessCallback,
1267                                                        Callback::Cancelable * onFailureCallback)
1268 {
1269     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
1270     System::PacketBufferHandle encodedCommand = encodeColorControlClusterReadPrimary2YAttribute(seqNum, mEndpoint);
1271     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
1272 }
1273
1274 CHIP_ERROR ColorControlCluster::ReadAttributePrimary2Intensity(Callback::Cancelable * onSuccessCallback,
1275                                                                Callback::Cancelable * onFailureCallback)
1276 {
1277     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
1278     System::PacketBufferHandle encodedCommand = encodeColorControlClusterReadPrimary2IntensityAttribute(seqNum, mEndpoint);
1279     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
1280 }
1281
1282 CHIP_ERROR ColorControlCluster::ReadAttributePrimary3X(Callback::Cancelable * onSuccessCallback,
1283                                                        Callback::Cancelable * onFailureCallback)
1284 {
1285     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
1286     System::PacketBufferHandle encodedCommand = encodeColorControlClusterReadPrimary3XAttribute(seqNum, mEndpoint);
1287     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
1288 }
1289
1290 CHIP_ERROR ColorControlCluster::ReadAttributePrimary3Y(Callback::Cancelable * onSuccessCallback,
1291                                                        Callback::Cancelable * onFailureCallback)
1292 {
1293     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
1294     System::PacketBufferHandle encodedCommand = encodeColorControlClusterReadPrimary3YAttribute(seqNum, mEndpoint);
1295     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
1296 }
1297
1298 CHIP_ERROR ColorControlCluster::ReadAttributePrimary3Intensity(Callback::Cancelable * onSuccessCallback,
1299                                                                Callback::Cancelable * onFailureCallback)
1300 {
1301     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
1302     System::PacketBufferHandle encodedCommand = encodeColorControlClusterReadPrimary3IntensityAttribute(seqNum, mEndpoint);
1303     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
1304 }
1305
1306 CHIP_ERROR ColorControlCluster::ReadAttributePrimary4X(Callback::Cancelable * onSuccessCallback,
1307                                                        Callback::Cancelable * onFailureCallback)
1308 {
1309     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
1310     System::PacketBufferHandle encodedCommand = encodeColorControlClusterReadPrimary4XAttribute(seqNum, mEndpoint);
1311     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
1312 }
1313
1314 CHIP_ERROR ColorControlCluster::ReadAttributePrimary4Y(Callback::Cancelable * onSuccessCallback,
1315                                                        Callback::Cancelable * onFailureCallback)
1316 {
1317     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
1318     System::PacketBufferHandle encodedCommand = encodeColorControlClusterReadPrimary4YAttribute(seqNum, mEndpoint);
1319     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
1320 }
1321
1322 CHIP_ERROR ColorControlCluster::ReadAttributePrimary4Intensity(Callback::Cancelable * onSuccessCallback,
1323                                                                Callback::Cancelable * onFailureCallback)
1324 {
1325     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
1326     System::PacketBufferHandle encodedCommand = encodeColorControlClusterReadPrimary4IntensityAttribute(seqNum, mEndpoint);
1327     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
1328 }
1329
1330 CHIP_ERROR ColorControlCluster::ReadAttributePrimary5X(Callback::Cancelable * onSuccessCallback,
1331                                                        Callback::Cancelable * onFailureCallback)
1332 {
1333     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
1334     System::PacketBufferHandle encodedCommand = encodeColorControlClusterReadPrimary5XAttribute(seqNum, mEndpoint);
1335     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
1336 }
1337
1338 CHIP_ERROR ColorControlCluster::ReadAttributePrimary5Y(Callback::Cancelable * onSuccessCallback,
1339                                                        Callback::Cancelable * onFailureCallback)
1340 {
1341     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
1342     System::PacketBufferHandle encodedCommand = encodeColorControlClusterReadPrimary5YAttribute(seqNum, mEndpoint);
1343     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
1344 }
1345
1346 CHIP_ERROR ColorControlCluster::ReadAttributePrimary5Intensity(Callback::Cancelable * onSuccessCallback,
1347                                                                Callback::Cancelable * onFailureCallback)
1348 {
1349     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
1350     System::PacketBufferHandle encodedCommand = encodeColorControlClusterReadPrimary5IntensityAttribute(seqNum, mEndpoint);
1351     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
1352 }
1353
1354 CHIP_ERROR ColorControlCluster::ReadAttributePrimary6X(Callback::Cancelable * onSuccessCallback,
1355                                                        Callback::Cancelable * onFailureCallback)
1356 {
1357     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
1358     System::PacketBufferHandle encodedCommand = encodeColorControlClusterReadPrimary6XAttribute(seqNum, mEndpoint);
1359     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
1360 }
1361
1362 CHIP_ERROR ColorControlCluster::ReadAttributePrimary6Y(Callback::Cancelable * onSuccessCallback,
1363                                                        Callback::Cancelable * onFailureCallback)
1364 {
1365     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
1366     System::PacketBufferHandle encodedCommand = encodeColorControlClusterReadPrimary6YAttribute(seqNum, mEndpoint);
1367     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
1368 }
1369
1370 CHIP_ERROR ColorControlCluster::ReadAttributePrimary6Intensity(Callback::Cancelable * onSuccessCallback,
1371                                                                Callback::Cancelable * onFailureCallback)
1372 {
1373     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
1374     System::PacketBufferHandle encodedCommand = encodeColorControlClusterReadPrimary6IntensityAttribute(seqNum, mEndpoint);
1375     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
1376 }
1377
1378 CHIP_ERROR ColorControlCluster::ReadAttributeWhitePointX(Callback::Cancelable * onSuccessCallback,
1379                                                          Callback::Cancelable * onFailureCallback)
1380 {
1381     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
1382     System::PacketBufferHandle encodedCommand = encodeColorControlClusterReadWhitePointXAttribute(seqNum, mEndpoint);
1383     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
1384 }
1385
1386 CHIP_ERROR ColorControlCluster::WriteAttributeWhitePointX(Callback::Cancelable * onSuccessCallback,
1387                                                           Callback::Cancelable * onFailureCallback, uint16_t value)
1388 {
1389     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
1390     System::PacketBufferHandle encodedCommand = encodeColorControlClusterWriteWhitePointXAttribute(seqNum, mEndpoint, value);
1391     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
1392 }
1393
1394 CHIP_ERROR ColorControlCluster::ReadAttributeWhitePointY(Callback::Cancelable * onSuccessCallback,
1395                                                          Callback::Cancelable * onFailureCallback)
1396 {
1397     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
1398     System::PacketBufferHandle encodedCommand = encodeColorControlClusterReadWhitePointYAttribute(seqNum, mEndpoint);
1399     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
1400 }
1401
1402 CHIP_ERROR ColorControlCluster::WriteAttributeWhitePointY(Callback::Cancelable * onSuccessCallback,
1403                                                           Callback::Cancelable * onFailureCallback, uint16_t value)
1404 {
1405     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
1406     System::PacketBufferHandle encodedCommand = encodeColorControlClusterWriteWhitePointYAttribute(seqNum, mEndpoint, value);
1407     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
1408 }
1409
1410 CHIP_ERROR ColorControlCluster::ReadAttributeColorPointRX(Callback::Cancelable * onSuccessCallback,
1411                                                           Callback::Cancelable * onFailureCallback)
1412 {
1413     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
1414     System::PacketBufferHandle encodedCommand = encodeColorControlClusterReadColorPointRXAttribute(seqNum, mEndpoint);
1415     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
1416 }
1417
1418 CHIP_ERROR ColorControlCluster::WriteAttributeColorPointRX(Callback::Cancelable * onSuccessCallback,
1419                                                            Callback::Cancelable * onFailureCallback, uint16_t value)
1420 {
1421     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
1422     System::PacketBufferHandle encodedCommand = encodeColorControlClusterWriteColorPointRXAttribute(seqNum, mEndpoint, value);
1423     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
1424 }
1425
1426 CHIP_ERROR ColorControlCluster::ReadAttributeColorPointRY(Callback::Cancelable * onSuccessCallback,
1427                                                           Callback::Cancelable * onFailureCallback)
1428 {
1429     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
1430     System::PacketBufferHandle encodedCommand = encodeColorControlClusterReadColorPointRYAttribute(seqNum, mEndpoint);
1431     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
1432 }
1433
1434 CHIP_ERROR ColorControlCluster::WriteAttributeColorPointRY(Callback::Cancelable * onSuccessCallback,
1435                                                            Callback::Cancelable * onFailureCallback, uint16_t value)
1436 {
1437     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
1438     System::PacketBufferHandle encodedCommand = encodeColorControlClusterWriteColorPointRYAttribute(seqNum, mEndpoint, value);
1439     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
1440 }
1441
1442 CHIP_ERROR ColorControlCluster::ReadAttributeColorPointRIntensity(Callback::Cancelable * onSuccessCallback,
1443                                                                   Callback::Cancelable * onFailureCallback)
1444 {
1445     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
1446     System::PacketBufferHandle encodedCommand = encodeColorControlClusterReadColorPointRIntensityAttribute(seqNum, mEndpoint);
1447     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
1448 }
1449
1450 CHIP_ERROR ColorControlCluster::WriteAttributeColorPointRIntensity(Callback::Cancelable * onSuccessCallback,
1451                                                                    Callback::Cancelable * onFailureCallback, uint8_t value)
1452 {
1453     uint8_t seqNum = mDevice->GetNextSequenceNumber();
1454     System::PacketBufferHandle encodedCommand =
1455         encodeColorControlClusterWriteColorPointRIntensityAttribute(seqNum, mEndpoint, value);
1456     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
1457 }
1458
1459 CHIP_ERROR ColorControlCluster::ReadAttributeColorPointGX(Callback::Cancelable * onSuccessCallback,
1460                                                           Callback::Cancelable * onFailureCallback)
1461 {
1462     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
1463     System::PacketBufferHandle encodedCommand = encodeColorControlClusterReadColorPointGXAttribute(seqNum, mEndpoint);
1464     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
1465 }
1466
1467 CHIP_ERROR ColorControlCluster::WriteAttributeColorPointGX(Callback::Cancelable * onSuccessCallback,
1468                                                            Callback::Cancelable * onFailureCallback, uint16_t value)
1469 {
1470     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
1471     System::PacketBufferHandle encodedCommand = encodeColorControlClusterWriteColorPointGXAttribute(seqNum, mEndpoint, value);
1472     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
1473 }
1474
1475 CHIP_ERROR ColorControlCluster::ReadAttributeColorPointGY(Callback::Cancelable * onSuccessCallback,
1476                                                           Callback::Cancelable * onFailureCallback)
1477 {
1478     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
1479     System::PacketBufferHandle encodedCommand = encodeColorControlClusterReadColorPointGYAttribute(seqNum, mEndpoint);
1480     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
1481 }
1482
1483 CHIP_ERROR ColorControlCluster::WriteAttributeColorPointGY(Callback::Cancelable * onSuccessCallback,
1484                                                            Callback::Cancelable * onFailureCallback, uint16_t value)
1485 {
1486     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
1487     System::PacketBufferHandle encodedCommand = encodeColorControlClusterWriteColorPointGYAttribute(seqNum, mEndpoint, value);
1488     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
1489 }
1490
1491 CHIP_ERROR ColorControlCluster::ReadAttributeColorPointGIntensity(Callback::Cancelable * onSuccessCallback,
1492                                                                   Callback::Cancelable * onFailureCallback)
1493 {
1494     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
1495     System::PacketBufferHandle encodedCommand = encodeColorControlClusterReadColorPointGIntensityAttribute(seqNum, mEndpoint);
1496     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
1497 }
1498
1499 CHIP_ERROR ColorControlCluster::WriteAttributeColorPointGIntensity(Callback::Cancelable * onSuccessCallback,
1500                                                                    Callback::Cancelable * onFailureCallback, uint8_t value)
1501 {
1502     uint8_t seqNum = mDevice->GetNextSequenceNumber();
1503     System::PacketBufferHandle encodedCommand =
1504         encodeColorControlClusterWriteColorPointGIntensityAttribute(seqNum, mEndpoint, value);
1505     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
1506 }
1507
1508 CHIP_ERROR ColorControlCluster::ReadAttributeColorPointBX(Callback::Cancelable * onSuccessCallback,
1509                                                           Callback::Cancelable * onFailureCallback)
1510 {
1511     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
1512     System::PacketBufferHandle encodedCommand = encodeColorControlClusterReadColorPointBXAttribute(seqNum, mEndpoint);
1513     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
1514 }
1515
1516 CHIP_ERROR ColorControlCluster::WriteAttributeColorPointBX(Callback::Cancelable * onSuccessCallback,
1517                                                            Callback::Cancelable * onFailureCallback, uint16_t value)
1518 {
1519     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
1520     System::PacketBufferHandle encodedCommand = encodeColorControlClusterWriteColorPointBXAttribute(seqNum, mEndpoint, value);
1521     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
1522 }
1523
1524 CHIP_ERROR ColorControlCluster::ReadAttributeColorPointBY(Callback::Cancelable * onSuccessCallback,
1525                                                           Callback::Cancelable * onFailureCallback)
1526 {
1527     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
1528     System::PacketBufferHandle encodedCommand = encodeColorControlClusterReadColorPointBYAttribute(seqNum, mEndpoint);
1529     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
1530 }
1531
1532 CHIP_ERROR ColorControlCluster::WriteAttributeColorPointBY(Callback::Cancelable * onSuccessCallback,
1533                                                            Callback::Cancelable * onFailureCallback, uint16_t value)
1534 {
1535     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
1536     System::PacketBufferHandle encodedCommand = encodeColorControlClusterWriteColorPointBYAttribute(seqNum, mEndpoint, value);
1537     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
1538 }
1539
1540 CHIP_ERROR ColorControlCluster::ReadAttributeColorPointBIntensity(Callback::Cancelable * onSuccessCallback,
1541                                                                   Callback::Cancelable * onFailureCallback)
1542 {
1543     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
1544     System::PacketBufferHandle encodedCommand = encodeColorControlClusterReadColorPointBIntensityAttribute(seqNum, mEndpoint);
1545     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
1546 }
1547
1548 CHIP_ERROR ColorControlCluster::WriteAttributeColorPointBIntensity(Callback::Cancelable * onSuccessCallback,
1549                                                                    Callback::Cancelable * onFailureCallback, uint8_t value)
1550 {
1551     uint8_t seqNum = mDevice->GetNextSequenceNumber();
1552     System::PacketBufferHandle encodedCommand =
1553         encodeColorControlClusterWriteColorPointBIntensityAttribute(seqNum, mEndpoint, value);
1554     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
1555 }
1556
1557 CHIP_ERROR ColorControlCluster::ReadAttributeEnhancedCurrentHue(Callback::Cancelable * onSuccessCallback,
1558                                                                 Callback::Cancelable * onFailureCallback)
1559 {
1560     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
1561     System::PacketBufferHandle encodedCommand = encodeColorControlClusterReadEnhancedCurrentHueAttribute(seqNum, mEndpoint);
1562     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
1563 }
1564
1565 CHIP_ERROR ColorControlCluster::ReadAttributeEnhancedColorMode(Callback::Cancelable * onSuccessCallback,
1566                                                                Callback::Cancelable * onFailureCallback)
1567 {
1568     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
1569     System::PacketBufferHandle encodedCommand = encodeColorControlClusterReadEnhancedColorModeAttribute(seqNum, mEndpoint);
1570     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
1571 }
1572
1573 CHIP_ERROR ColorControlCluster::ReadAttributeColorLoopActive(Callback::Cancelable * onSuccessCallback,
1574                                                              Callback::Cancelable * onFailureCallback)
1575 {
1576     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
1577     System::PacketBufferHandle encodedCommand = encodeColorControlClusterReadColorLoopActiveAttribute(seqNum, mEndpoint);
1578     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
1579 }
1580
1581 CHIP_ERROR ColorControlCluster::ReadAttributeColorLoopDirection(Callback::Cancelable * onSuccessCallback,
1582                                                                 Callback::Cancelable * onFailureCallback)
1583 {
1584     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
1585     System::PacketBufferHandle encodedCommand = encodeColorControlClusterReadColorLoopDirectionAttribute(seqNum, mEndpoint);
1586     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
1587 }
1588
1589 CHIP_ERROR ColorControlCluster::ReadAttributeColorLoopTime(Callback::Cancelable * onSuccessCallback,
1590                                                            Callback::Cancelable * onFailureCallback)
1591 {
1592     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
1593     System::PacketBufferHandle encodedCommand = encodeColorControlClusterReadColorLoopTimeAttribute(seqNum, mEndpoint);
1594     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
1595 }
1596
1597 CHIP_ERROR ColorControlCluster::ReadAttributeColorCapabilities(Callback::Cancelable * onSuccessCallback,
1598                                                                Callback::Cancelable * onFailureCallback)
1599 {
1600     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
1601     System::PacketBufferHandle encodedCommand = encodeColorControlClusterReadColorCapabilitiesAttribute(seqNum, mEndpoint);
1602     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
1603 }
1604
1605 CHIP_ERROR ColorControlCluster::ReadAttributeColorTempPhysicalMin(Callback::Cancelable * onSuccessCallback,
1606                                                                   Callback::Cancelable * onFailureCallback)
1607 {
1608     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
1609     System::PacketBufferHandle encodedCommand = encodeColorControlClusterReadColorTempPhysicalMinAttribute(seqNum, mEndpoint);
1610     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
1611 }
1612
1613 CHIP_ERROR ColorControlCluster::ReadAttributeColorTempPhysicalMax(Callback::Cancelable * onSuccessCallback,
1614                                                                   Callback::Cancelable * onFailureCallback)
1615 {
1616     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
1617     System::PacketBufferHandle encodedCommand = encodeColorControlClusterReadColorTempPhysicalMaxAttribute(seqNum, mEndpoint);
1618     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
1619 }
1620
1621 CHIP_ERROR ColorControlCluster::ReadAttributeCoupleColorTempToLevelMinMireds(Callback::Cancelable * onSuccessCallback,
1622                                                                              Callback::Cancelable * onFailureCallback)
1623 {
1624     uint8_t seqNum = mDevice->GetNextSequenceNumber();
1625     System::PacketBufferHandle encodedCommand =
1626         encodeColorControlClusterReadCoupleColorTempToLevelMinMiredsAttribute(seqNum, mEndpoint);
1627     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
1628 }
1629
1630 CHIP_ERROR ColorControlCluster::ReadAttributeStartUpColorTemperatureMireds(Callback::Cancelable * onSuccessCallback,
1631                                                                            Callback::Cancelable * onFailureCallback)
1632 {
1633     uint8_t seqNum = mDevice->GetNextSequenceNumber();
1634     System::PacketBufferHandle encodedCommand =
1635         encodeColorControlClusterReadStartUpColorTemperatureMiredsAttribute(seqNum, mEndpoint);
1636     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
1637 }
1638
1639 CHIP_ERROR ColorControlCluster::WriteAttributeStartUpColorTemperatureMireds(Callback::Cancelable * onSuccessCallback,
1640                                                                             Callback::Cancelable * onFailureCallback,
1641                                                                             uint16_t value)
1642 {
1643     uint8_t seqNum = mDevice->GetNextSequenceNumber();
1644     System::PacketBufferHandle encodedCommand =
1645         encodeColorControlClusterWriteStartUpColorTemperatureMiredsAttribute(seqNum, mEndpoint, value);
1646     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
1647 }
1648
1649 CHIP_ERROR ColorControlCluster::ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback,
1650                                                              Callback::Cancelable * onFailureCallback)
1651 {
1652     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
1653     System::PacketBufferHandle encodedCommand = encodeColorControlClusterReadClusterRevisionAttribute(seqNum, mEndpoint);
1654     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
1655 }
1656
1657 // DoorLock Cluster Commands
1658 CHIP_ERROR DoorLockCluster::ClearAllPins(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback)
1659 {
1660 #if CHIP_ENABLE_INTERACTION_MODEL
1661     VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE);
1662     (void) onSuccessCallback;
1663     (void) onFailureCallback;
1664
1665     app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kClearAllPinsCommandId,
1666                                               (chip::app::Command::CommandPathFlags::kEndpointIdValid) };
1667     app::Command * ZCLcommand             = mDevice->GetCommandSender();
1668
1669     TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter();
1670
1671     TLV::TLVType dummyType = TLV::kTLVType_NotSpecified;
1672     ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType));
1673
1674     // Command takes no arguments.
1675
1676     ReturnErrorOnFailure(writer.EndContainer(dummyType));
1677     ReturnErrorOnFailure(writer.Finalize());
1678     ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams));
1679
1680     return mDevice->SendCommands();
1681 #else
1682     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
1683     System::PacketBufferHandle encodedCommand = encodeDoorLockClusterClearAllPinsCommand(seqNum, mEndpoint);
1684     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
1685 #endif
1686 }
1687
1688 CHIP_ERROR DoorLockCluster::ClearAllRfids(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback)
1689 {
1690 #if CHIP_ENABLE_INTERACTION_MODEL
1691     VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE);
1692     (void) onSuccessCallback;
1693     (void) onFailureCallback;
1694
1695     app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kClearAllRfidsCommandId,
1696                                               (chip::app::Command::CommandPathFlags::kEndpointIdValid) };
1697     app::Command * ZCLcommand             = mDevice->GetCommandSender();
1698
1699     TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter();
1700
1701     TLV::TLVType dummyType = TLV::kTLVType_NotSpecified;
1702     ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType));
1703
1704     // Command takes no arguments.
1705
1706     ReturnErrorOnFailure(writer.EndContainer(dummyType));
1707     ReturnErrorOnFailure(writer.Finalize());
1708     ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams));
1709
1710     return mDevice->SendCommands();
1711 #else
1712     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
1713     System::PacketBufferHandle encodedCommand = encodeDoorLockClusterClearAllRfidsCommand(seqNum, mEndpoint);
1714     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
1715 #endif
1716 }
1717
1718 CHIP_ERROR DoorLockCluster::ClearHolidaySchedule(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback,
1719                                                  uint8_t scheduleId)
1720 {
1721 #if CHIP_ENABLE_INTERACTION_MODEL
1722     VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE);
1723     (void) onSuccessCallback;
1724     (void) onFailureCallback;
1725
1726     app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kClearHolidayScheduleCommandId,
1727                                               (chip::app::Command::CommandPathFlags::kEndpointIdValid) };
1728     app::Command * ZCLcommand             = mDevice->GetCommandSender();
1729
1730     TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter();
1731
1732     TLV::TLVType dummyType = TLV::kTLVType_NotSpecified;
1733     ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType));
1734
1735     uint8_t argSeqNumber = 0;
1736     // scheduleId: int8u
1737     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), scheduleId));
1738
1739     ReturnErrorOnFailure(writer.EndContainer(dummyType));
1740     ReturnErrorOnFailure(writer.Finalize());
1741     ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams));
1742
1743     return mDevice->SendCommands();
1744 #else
1745     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
1746     System::PacketBufferHandle encodedCommand = encodeDoorLockClusterClearHolidayScheduleCommand(seqNum, mEndpoint, scheduleId);
1747     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
1748 #endif
1749 }
1750
1751 CHIP_ERROR DoorLockCluster::ClearPin(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback,
1752                                      uint16_t userId)
1753 {
1754 #if CHIP_ENABLE_INTERACTION_MODEL
1755     VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE);
1756     (void) onSuccessCallback;
1757     (void) onFailureCallback;
1758
1759     app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kClearPinCommandId,
1760                                               (chip::app::Command::CommandPathFlags::kEndpointIdValid) };
1761     app::Command * ZCLcommand             = mDevice->GetCommandSender();
1762
1763     TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter();
1764
1765     TLV::TLVType dummyType = TLV::kTLVType_NotSpecified;
1766     ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType));
1767
1768     uint8_t argSeqNumber = 0;
1769     // userId: int16u
1770     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), userId));
1771
1772     ReturnErrorOnFailure(writer.EndContainer(dummyType));
1773     ReturnErrorOnFailure(writer.Finalize());
1774     ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams));
1775
1776     return mDevice->SendCommands();
1777 #else
1778     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
1779     System::PacketBufferHandle encodedCommand = encodeDoorLockClusterClearPinCommand(seqNum, mEndpoint, userId);
1780     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
1781 #endif
1782 }
1783
1784 CHIP_ERROR DoorLockCluster::ClearRfid(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback,
1785                                       uint16_t userId)
1786 {
1787 #if CHIP_ENABLE_INTERACTION_MODEL
1788     VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE);
1789     (void) onSuccessCallback;
1790     (void) onFailureCallback;
1791
1792     app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kClearRfidCommandId,
1793                                               (chip::app::Command::CommandPathFlags::kEndpointIdValid) };
1794     app::Command * ZCLcommand             = mDevice->GetCommandSender();
1795
1796     TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter();
1797
1798     TLV::TLVType dummyType = TLV::kTLVType_NotSpecified;
1799     ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType));
1800
1801     uint8_t argSeqNumber = 0;
1802     // userId: int16u
1803     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), userId));
1804
1805     ReturnErrorOnFailure(writer.EndContainer(dummyType));
1806     ReturnErrorOnFailure(writer.Finalize());
1807     ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams));
1808
1809     return mDevice->SendCommands();
1810 #else
1811     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
1812     System::PacketBufferHandle encodedCommand = encodeDoorLockClusterClearRfidCommand(seqNum, mEndpoint, userId);
1813     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
1814 #endif
1815 }
1816
1817 CHIP_ERROR DoorLockCluster::ClearWeekdaySchedule(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback,
1818                                                  uint8_t scheduleId, uint16_t userId)
1819 {
1820 #if CHIP_ENABLE_INTERACTION_MODEL
1821     VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE);
1822     (void) onSuccessCallback;
1823     (void) onFailureCallback;
1824
1825     app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kClearWeekdayScheduleCommandId,
1826                                               (chip::app::Command::CommandPathFlags::kEndpointIdValid) };
1827     app::Command * ZCLcommand             = mDevice->GetCommandSender();
1828
1829     TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter();
1830
1831     TLV::TLVType dummyType = TLV::kTLVType_NotSpecified;
1832     ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType));
1833
1834     uint8_t argSeqNumber = 0;
1835     // scheduleId: int8u
1836     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), scheduleId));
1837     // userId: int16u
1838     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), userId));
1839
1840     ReturnErrorOnFailure(writer.EndContainer(dummyType));
1841     ReturnErrorOnFailure(writer.Finalize());
1842     ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams));
1843
1844     return mDevice->SendCommands();
1845 #else
1846     uint8_t seqNum = mDevice->GetNextSequenceNumber();
1847     System::PacketBufferHandle encodedCommand =
1848         encodeDoorLockClusterClearWeekdayScheduleCommand(seqNum, mEndpoint, scheduleId, userId);
1849     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
1850 #endif
1851 }
1852
1853 CHIP_ERROR DoorLockCluster::ClearYeardaySchedule(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback,
1854                                                  uint8_t scheduleId, uint16_t userId)
1855 {
1856 #if CHIP_ENABLE_INTERACTION_MODEL
1857     VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE);
1858     (void) onSuccessCallback;
1859     (void) onFailureCallback;
1860
1861     app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kClearYeardayScheduleCommandId,
1862                                               (chip::app::Command::CommandPathFlags::kEndpointIdValid) };
1863     app::Command * ZCLcommand             = mDevice->GetCommandSender();
1864
1865     TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter();
1866
1867     TLV::TLVType dummyType = TLV::kTLVType_NotSpecified;
1868     ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType));
1869
1870     uint8_t argSeqNumber = 0;
1871     // scheduleId: int8u
1872     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), scheduleId));
1873     // userId: int16u
1874     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), userId));
1875
1876     ReturnErrorOnFailure(writer.EndContainer(dummyType));
1877     ReturnErrorOnFailure(writer.Finalize());
1878     ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams));
1879
1880     return mDevice->SendCommands();
1881 #else
1882     uint8_t seqNum = mDevice->GetNextSequenceNumber();
1883     System::PacketBufferHandle encodedCommand =
1884         encodeDoorLockClusterClearYeardayScheduleCommand(seqNum, mEndpoint, scheduleId, userId);
1885     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
1886 #endif
1887 }
1888
1889 CHIP_ERROR DoorLockCluster::GetHolidaySchedule(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback,
1890                                                uint8_t scheduleId)
1891 {
1892 #if CHIP_ENABLE_INTERACTION_MODEL
1893     VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE);
1894     (void) onSuccessCallback;
1895     (void) onFailureCallback;
1896
1897     app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kGetHolidayScheduleCommandId,
1898                                               (chip::app::Command::CommandPathFlags::kEndpointIdValid) };
1899     app::Command * ZCLcommand             = mDevice->GetCommandSender();
1900
1901     TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter();
1902
1903     TLV::TLVType dummyType = TLV::kTLVType_NotSpecified;
1904     ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType));
1905
1906     uint8_t argSeqNumber = 0;
1907     // scheduleId: int8u
1908     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), scheduleId));
1909
1910     ReturnErrorOnFailure(writer.EndContainer(dummyType));
1911     ReturnErrorOnFailure(writer.Finalize());
1912     ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams));
1913
1914     return mDevice->SendCommands();
1915 #else
1916     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
1917     System::PacketBufferHandle encodedCommand = encodeDoorLockClusterGetHolidayScheduleCommand(seqNum, mEndpoint, scheduleId);
1918     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
1919 #endif
1920 }
1921
1922 CHIP_ERROR DoorLockCluster::GetLogRecord(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback,
1923                                          uint16_t logIndex)
1924 {
1925 #if CHIP_ENABLE_INTERACTION_MODEL
1926     VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE);
1927     (void) onSuccessCallback;
1928     (void) onFailureCallback;
1929
1930     app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kGetLogRecordCommandId,
1931                                               (chip::app::Command::CommandPathFlags::kEndpointIdValid) };
1932     app::Command * ZCLcommand             = mDevice->GetCommandSender();
1933
1934     TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter();
1935
1936     TLV::TLVType dummyType = TLV::kTLVType_NotSpecified;
1937     ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType));
1938
1939     uint8_t argSeqNumber = 0;
1940     // logIndex: int16u
1941     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), logIndex));
1942
1943     ReturnErrorOnFailure(writer.EndContainer(dummyType));
1944     ReturnErrorOnFailure(writer.Finalize());
1945     ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams));
1946
1947     return mDevice->SendCommands();
1948 #else
1949     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
1950     System::PacketBufferHandle encodedCommand = encodeDoorLockClusterGetLogRecordCommand(seqNum, mEndpoint, logIndex);
1951     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
1952 #endif
1953 }
1954
1955 CHIP_ERROR DoorLockCluster::GetPin(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback,
1956                                    uint16_t userId)
1957 {
1958 #if CHIP_ENABLE_INTERACTION_MODEL
1959     VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE);
1960     (void) onSuccessCallback;
1961     (void) onFailureCallback;
1962
1963     app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kGetPinCommandId,
1964                                               (chip::app::Command::CommandPathFlags::kEndpointIdValid) };
1965     app::Command * ZCLcommand             = mDevice->GetCommandSender();
1966
1967     TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter();
1968
1969     TLV::TLVType dummyType = TLV::kTLVType_NotSpecified;
1970     ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType));
1971
1972     uint8_t argSeqNumber = 0;
1973     // userId: int16u
1974     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), userId));
1975
1976     ReturnErrorOnFailure(writer.EndContainer(dummyType));
1977     ReturnErrorOnFailure(writer.Finalize());
1978     ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams));
1979
1980     return mDevice->SendCommands();
1981 #else
1982     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
1983     System::PacketBufferHandle encodedCommand = encodeDoorLockClusterGetPinCommand(seqNum, mEndpoint, userId);
1984     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
1985 #endif
1986 }
1987
1988 CHIP_ERROR DoorLockCluster::GetRfid(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback,
1989                                     uint16_t userId)
1990 {
1991 #if CHIP_ENABLE_INTERACTION_MODEL
1992     VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE);
1993     (void) onSuccessCallback;
1994     (void) onFailureCallback;
1995
1996     app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kGetRfidCommandId,
1997                                               (chip::app::Command::CommandPathFlags::kEndpointIdValid) };
1998     app::Command * ZCLcommand             = mDevice->GetCommandSender();
1999
2000     TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter();
2001
2002     TLV::TLVType dummyType = TLV::kTLVType_NotSpecified;
2003     ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType));
2004
2005     uint8_t argSeqNumber = 0;
2006     // userId: int16u
2007     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), userId));
2008
2009     ReturnErrorOnFailure(writer.EndContainer(dummyType));
2010     ReturnErrorOnFailure(writer.Finalize());
2011     ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams));
2012
2013     return mDevice->SendCommands();
2014 #else
2015     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
2016     System::PacketBufferHandle encodedCommand = encodeDoorLockClusterGetRfidCommand(seqNum, mEndpoint, userId);
2017     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
2018 #endif
2019 }
2020
2021 CHIP_ERROR DoorLockCluster::GetUserType(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback,
2022                                         uint16_t userId)
2023 {
2024 #if CHIP_ENABLE_INTERACTION_MODEL
2025     VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE);
2026     (void) onSuccessCallback;
2027     (void) onFailureCallback;
2028
2029     app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kGetUserTypeCommandId,
2030                                               (chip::app::Command::CommandPathFlags::kEndpointIdValid) };
2031     app::Command * ZCLcommand             = mDevice->GetCommandSender();
2032
2033     TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter();
2034
2035     TLV::TLVType dummyType = TLV::kTLVType_NotSpecified;
2036     ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType));
2037
2038     uint8_t argSeqNumber = 0;
2039     // userId: int16u
2040     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), userId));
2041
2042     ReturnErrorOnFailure(writer.EndContainer(dummyType));
2043     ReturnErrorOnFailure(writer.Finalize());
2044     ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams));
2045
2046     return mDevice->SendCommands();
2047 #else
2048     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
2049     System::PacketBufferHandle encodedCommand = encodeDoorLockClusterGetUserTypeCommand(seqNum, mEndpoint, userId);
2050     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
2051 #endif
2052 }
2053
2054 CHIP_ERROR DoorLockCluster::GetWeekdaySchedule(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback,
2055                                                uint8_t scheduleId, uint16_t userId)
2056 {
2057 #if CHIP_ENABLE_INTERACTION_MODEL
2058     VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE);
2059     (void) onSuccessCallback;
2060     (void) onFailureCallback;
2061
2062     app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kGetWeekdayScheduleCommandId,
2063                                               (chip::app::Command::CommandPathFlags::kEndpointIdValid) };
2064     app::Command * ZCLcommand             = mDevice->GetCommandSender();
2065
2066     TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter();
2067
2068     TLV::TLVType dummyType = TLV::kTLVType_NotSpecified;
2069     ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType));
2070
2071     uint8_t argSeqNumber = 0;
2072     // scheduleId: int8u
2073     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), scheduleId));
2074     // userId: int16u
2075     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), userId));
2076
2077     ReturnErrorOnFailure(writer.EndContainer(dummyType));
2078     ReturnErrorOnFailure(writer.Finalize());
2079     ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams));
2080
2081     return mDevice->SendCommands();
2082 #else
2083     uint8_t seqNum = mDevice->GetNextSequenceNumber();
2084     System::PacketBufferHandle encodedCommand =
2085         encodeDoorLockClusterGetWeekdayScheduleCommand(seqNum, mEndpoint, scheduleId, userId);
2086     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
2087 #endif
2088 }
2089
2090 CHIP_ERROR DoorLockCluster::GetYeardaySchedule(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback,
2091                                                uint8_t scheduleId, uint16_t userId)
2092 {
2093 #if CHIP_ENABLE_INTERACTION_MODEL
2094     VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE);
2095     (void) onSuccessCallback;
2096     (void) onFailureCallback;
2097
2098     app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kGetYeardayScheduleCommandId,
2099                                               (chip::app::Command::CommandPathFlags::kEndpointIdValid) };
2100     app::Command * ZCLcommand             = mDevice->GetCommandSender();
2101
2102     TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter();
2103
2104     TLV::TLVType dummyType = TLV::kTLVType_NotSpecified;
2105     ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType));
2106
2107     uint8_t argSeqNumber = 0;
2108     // scheduleId: int8u
2109     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), scheduleId));
2110     // userId: int16u
2111     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), userId));
2112
2113     ReturnErrorOnFailure(writer.EndContainer(dummyType));
2114     ReturnErrorOnFailure(writer.Finalize());
2115     ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams));
2116
2117     return mDevice->SendCommands();
2118 #else
2119     uint8_t seqNum = mDevice->GetNextSequenceNumber();
2120     System::PacketBufferHandle encodedCommand =
2121         encodeDoorLockClusterGetYeardayScheduleCommand(seqNum, mEndpoint, scheduleId, userId);
2122     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
2123 #endif
2124 }
2125
2126 CHIP_ERROR DoorLockCluster::LockDoor(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback,
2127                                      chip::ByteSpan pin)
2128 {
2129 #if CHIP_ENABLE_INTERACTION_MODEL
2130     VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE);
2131     (void) onSuccessCallback;
2132     (void) onFailureCallback;
2133
2134     app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kLockDoorCommandId,
2135                                               (chip::app::Command::CommandPathFlags::kEndpointIdValid) };
2136     app::Command * ZCLcommand             = mDevice->GetCommandSender();
2137
2138     TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter();
2139
2140     TLV::TLVType dummyType = TLV::kTLVType_NotSpecified;
2141     ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType));
2142
2143     uint8_t argSeqNumber = 0;
2144     // pin: charString
2145     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), pin));
2146
2147     ReturnErrorOnFailure(writer.EndContainer(dummyType));
2148     ReturnErrorOnFailure(writer.Finalize());
2149     ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams));
2150
2151     return mDevice->SendCommands();
2152 #else
2153     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
2154     System::PacketBufferHandle encodedCommand = encodeDoorLockClusterLockDoorCommand(seqNum, mEndpoint, pin);
2155     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
2156 #endif
2157 }
2158
2159 CHIP_ERROR DoorLockCluster::SetHolidaySchedule(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback,
2160                                                uint8_t scheduleId, uint32_t localStartTime, uint32_t localEndTime,
2161                                                uint8_t operatingModeDuringHoliday)
2162 {
2163 #if CHIP_ENABLE_INTERACTION_MODEL
2164     VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE);
2165     (void) onSuccessCallback;
2166     (void) onFailureCallback;
2167
2168     app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kSetHolidayScheduleCommandId,
2169                                               (chip::app::Command::CommandPathFlags::kEndpointIdValid) };
2170     app::Command * ZCLcommand             = mDevice->GetCommandSender();
2171
2172     TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter();
2173
2174     TLV::TLVType dummyType = TLV::kTLVType_NotSpecified;
2175     ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType));
2176
2177     uint8_t argSeqNumber = 0;
2178     // scheduleId: int8u
2179     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), scheduleId));
2180     // localStartTime: int32u
2181     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), localStartTime));
2182     // localEndTime: int32u
2183     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), localEndTime));
2184     // operatingModeDuringHoliday: enum8
2185     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), operatingModeDuringHoliday));
2186
2187     ReturnErrorOnFailure(writer.EndContainer(dummyType));
2188     ReturnErrorOnFailure(writer.Finalize());
2189     ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams));
2190
2191     return mDevice->SendCommands();
2192 #else
2193     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
2194     System::PacketBufferHandle encodedCommand = encodeDoorLockClusterSetHolidayScheduleCommand(
2195         seqNum, mEndpoint, scheduleId, localStartTime, localEndTime, operatingModeDuringHoliday);
2196     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
2197 #endif
2198 }
2199
2200 CHIP_ERROR DoorLockCluster::SetPin(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback,
2201                                    uint16_t userId, uint8_t userStatus, uint8_t userType, chip::ByteSpan pin)
2202 {
2203 #if CHIP_ENABLE_INTERACTION_MODEL
2204     VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE);
2205     (void) onSuccessCallback;
2206     (void) onFailureCallback;
2207
2208     app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kSetPinCommandId,
2209                                               (chip::app::Command::CommandPathFlags::kEndpointIdValid) };
2210     app::Command * ZCLcommand             = mDevice->GetCommandSender();
2211
2212     TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter();
2213
2214     TLV::TLVType dummyType = TLV::kTLVType_NotSpecified;
2215     ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType));
2216
2217     uint8_t argSeqNumber = 0;
2218     // userId: int16u
2219     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), userId));
2220     // userStatus: doorLockUserStatus
2221     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), userStatus));
2222     // userType: doorLockUserType
2223     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), userType));
2224     // pin: charString
2225     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), pin));
2226
2227     ReturnErrorOnFailure(writer.EndContainer(dummyType));
2228     ReturnErrorOnFailure(writer.Finalize());
2229     ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams));
2230
2231     return mDevice->SendCommands();
2232 #else
2233     uint8_t seqNum = mDevice->GetNextSequenceNumber();
2234     System::PacketBufferHandle encodedCommand =
2235         encodeDoorLockClusterSetPinCommand(seqNum, mEndpoint, userId, userStatus, userType, pin);
2236     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
2237 #endif
2238 }
2239
2240 CHIP_ERROR DoorLockCluster::SetRfid(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback,
2241                                     uint16_t userId, uint8_t userStatus, uint8_t userType, chip::ByteSpan id)
2242 {
2243 #if CHIP_ENABLE_INTERACTION_MODEL
2244     VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE);
2245     (void) onSuccessCallback;
2246     (void) onFailureCallback;
2247
2248     app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kSetRfidCommandId,
2249                                               (chip::app::Command::CommandPathFlags::kEndpointIdValid) };
2250     app::Command * ZCLcommand             = mDevice->GetCommandSender();
2251
2252     TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter();
2253
2254     TLV::TLVType dummyType = TLV::kTLVType_NotSpecified;
2255     ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType));
2256
2257     uint8_t argSeqNumber = 0;
2258     // userId: int16u
2259     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), userId));
2260     // userStatus: doorLockUserStatus
2261     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), userStatus));
2262     // userType: doorLockUserType
2263     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), userType));
2264     // id: charString
2265     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), id));
2266
2267     ReturnErrorOnFailure(writer.EndContainer(dummyType));
2268     ReturnErrorOnFailure(writer.Finalize());
2269     ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams));
2270
2271     return mDevice->SendCommands();
2272 #else
2273     uint8_t seqNum = mDevice->GetNextSequenceNumber();
2274     System::PacketBufferHandle encodedCommand =
2275         encodeDoorLockClusterSetRfidCommand(seqNum, mEndpoint, userId, userStatus, userType, id);
2276     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
2277 #endif
2278 }
2279
2280 CHIP_ERROR DoorLockCluster::SetUserType(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback,
2281                                         uint16_t userId, uint8_t userType)
2282 {
2283 #if CHIP_ENABLE_INTERACTION_MODEL
2284     VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE);
2285     (void) onSuccessCallback;
2286     (void) onFailureCallback;
2287
2288     app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kSetUserTypeCommandId,
2289                                               (chip::app::Command::CommandPathFlags::kEndpointIdValid) };
2290     app::Command * ZCLcommand             = mDevice->GetCommandSender();
2291
2292     TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter();
2293
2294     TLV::TLVType dummyType = TLV::kTLVType_NotSpecified;
2295     ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType));
2296
2297     uint8_t argSeqNumber = 0;
2298     // userId: int16u
2299     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), userId));
2300     // userType: doorLockUserType
2301     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), userType));
2302
2303     ReturnErrorOnFailure(writer.EndContainer(dummyType));
2304     ReturnErrorOnFailure(writer.Finalize());
2305     ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams));
2306
2307     return mDevice->SendCommands();
2308 #else
2309     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
2310     System::PacketBufferHandle encodedCommand = encodeDoorLockClusterSetUserTypeCommand(seqNum, mEndpoint, userId, userType);
2311     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
2312 #endif
2313 }
2314
2315 CHIP_ERROR DoorLockCluster::SetWeekdaySchedule(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback,
2316                                                uint8_t scheduleId, uint16_t userId, uint8_t daysMask, uint8_t startHour,
2317                                                uint8_t startMinute, uint8_t endHour, uint8_t endMinute)
2318 {
2319 #if CHIP_ENABLE_INTERACTION_MODEL
2320     VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE);
2321     (void) onSuccessCallback;
2322     (void) onFailureCallback;
2323
2324     app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kSetWeekdayScheduleCommandId,
2325                                               (chip::app::Command::CommandPathFlags::kEndpointIdValid) };
2326     app::Command * ZCLcommand             = mDevice->GetCommandSender();
2327
2328     TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter();
2329
2330     TLV::TLVType dummyType = TLV::kTLVType_NotSpecified;
2331     ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType));
2332
2333     uint8_t argSeqNumber = 0;
2334     // scheduleId: int8u
2335     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), scheduleId));
2336     // userId: int16u
2337     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), userId));
2338     // daysMask: doorLockDayOfWeek
2339     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), daysMask));
2340     // startHour: int8u
2341     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), startHour));
2342     // startMinute: int8u
2343     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), startMinute));
2344     // endHour: int8u
2345     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), endHour));
2346     // endMinute: int8u
2347     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), endMinute));
2348
2349     ReturnErrorOnFailure(writer.EndContainer(dummyType));
2350     ReturnErrorOnFailure(writer.Finalize());
2351     ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams));
2352
2353     return mDevice->SendCommands();
2354 #else
2355     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
2356     System::PacketBufferHandle encodedCommand = encodeDoorLockClusterSetWeekdayScheduleCommand(
2357         seqNum, mEndpoint, scheduleId, userId, daysMask, startHour, startMinute, endHour, endMinute);
2358     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
2359 #endif
2360 }
2361
2362 CHIP_ERROR DoorLockCluster::SetYeardaySchedule(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback,
2363                                                uint8_t scheduleId, uint16_t userId, uint32_t localStartTime, uint32_t localEndTime)
2364 {
2365 #if CHIP_ENABLE_INTERACTION_MODEL
2366     VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE);
2367     (void) onSuccessCallback;
2368     (void) onFailureCallback;
2369
2370     app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kSetYeardayScheduleCommandId,
2371                                               (chip::app::Command::CommandPathFlags::kEndpointIdValid) };
2372     app::Command * ZCLcommand             = mDevice->GetCommandSender();
2373
2374     TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter();
2375
2376     TLV::TLVType dummyType = TLV::kTLVType_NotSpecified;
2377     ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType));
2378
2379     uint8_t argSeqNumber = 0;
2380     // scheduleId: int8u
2381     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), scheduleId));
2382     // userId: int16u
2383     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), userId));
2384     // localStartTime: int32u
2385     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), localStartTime));
2386     // localEndTime: int32u
2387     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), localEndTime));
2388
2389     ReturnErrorOnFailure(writer.EndContainer(dummyType));
2390     ReturnErrorOnFailure(writer.Finalize());
2391     ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams));
2392
2393     return mDevice->SendCommands();
2394 #else
2395     uint8_t seqNum = mDevice->GetNextSequenceNumber();
2396     System::PacketBufferHandle encodedCommand =
2397         encodeDoorLockClusterSetYeardayScheduleCommand(seqNum, mEndpoint, scheduleId, userId, localStartTime, localEndTime);
2398     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
2399 #endif
2400 }
2401
2402 CHIP_ERROR DoorLockCluster::UnlockDoor(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback,
2403                                        chip::ByteSpan pin)
2404 {
2405 #if CHIP_ENABLE_INTERACTION_MODEL
2406     VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE);
2407     (void) onSuccessCallback;
2408     (void) onFailureCallback;
2409
2410     app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kUnlockDoorCommandId,
2411                                               (chip::app::Command::CommandPathFlags::kEndpointIdValid) };
2412     app::Command * ZCLcommand             = mDevice->GetCommandSender();
2413
2414     TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter();
2415
2416     TLV::TLVType dummyType = TLV::kTLVType_NotSpecified;
2417     ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType));
2418
2419     uint8_t argSeqNumber = 0;
2420     // pin: charString
2421     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), pin));
2422
2423     ReturnErrorOnFailure(writer.EndContainer(dummyType));
2424     ReturnErrorOnFailure(writer.Finalize());
2425     ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams));
2426
2427     return mDevice->SendCommands();
2428 #else
2429     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
2430     System::PacketBufferHandle encodedCommand = encodeDoorLockClusterUnlockDoorCommand(seqNum, mEndpoint, pin);
2431     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
2432 #endif
2433 }
2434
2435 CHIP_ERROR DoorLockCluster::UnlockWithTimeout(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback,
2436                                               uint16_t timeoutInSeconds, chip::ByteSpan pin)
2437 {
2438 #if CHIP_ENABLE_INTERACTION_MODEL
2439     VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE);
2440     (void) onSuccessCallback;
2441     (void) onFailureCallback;
2442
2443     app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kUnlockWithTimeoutCommandId,
2444                                               (chip::app::Command::CommandPathFlags::kEndpointIdValid) };
2445     app::Command * ZCLcommand             = mDevice->GetCommandSender();
2446
2447     TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter();
2448
2449     TLV::TLVType dummyType = TLV::kTLVType_NotSpecified;
2450     ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType));
2451
2452     uint8_t argSeqNumber = 0;
2453     // timeoutInSeconds: int16u
2454     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), timeoutInSeconds));
2455     // pin: charString
2456     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), pin));
2457
2458     ReturnErrorOnFailure(writer.EndContainer(dummyType));
2459     ReturnErrorOnFailure(writer.Finalize());
2460     ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams));
2461
2462     return mDevice->SendCommands();
2463 #else
2464     uint8_t seqNum = mDevice->GetNextSequenceNumber();
2465     System::PacketBufferHandle encodedCommand =
2466         encodeDoorLockClusterUnlockWithTimeoutCommand(seqNum, mEndpoint, timeoutInSeconds, pin);
2467     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
2468 #endif
2469 }
2470
2471 // DoorLock Cluster Attributes
2472 CHIP_ERROR DoorLockCluster::DiscoverAttributes(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback)
2473 {
2474     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
2475     System::PacketBufferHandle encodedCommand = encodeDoorLockClusterDiscoverAttributes(seqNum, mEndpoint);
2476     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
2477 }
2478 CHIP_ERROR DoorLockCluster::ReadAttributeLockState(Callback::Cancelable * onSuccessCallback,
2479                                                    Callback::Cancelable * onFailureCallback)
2480 {
2481     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
2482     System::PacketBufferHandle encodedCommand = encodeDoorLockClusterReadLockStateAttribute(seqNum, mEndpoint);
2483     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
2484 }
2485
2486 CHIP_ERROR DoorLockCluster::ConfigureAttributeLockState(Callback::Cancelable * onSuccessCallback,
2487                                                         Callback::Cancelable * onFailureCallback, uint16_t minInterval,
2488                                                         uint16_t maxInterval)
2489 {
2490     uint8_t seqNum = mDevice->GetNextSequenceNumber();
2491     System::PacketBufferHandle encodedCommand =
2492         encodeDoorLockClusterConfigureLockStateAttribute(seqNum, mEndpoint, minInterval, maxInterval);
2493     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
2494 }
2495
2496 CHIP_ERROR DoorLockCluster::ReportAttributeLockState(Callback::Cancelable * onReportCallback)
2497 {
2498     return RequestAttributeReporting(0x0000, onReportCallback);
2499 }
2500
2501 CHIP_ERROR DoorLockCluster::ReadAttributeLockType(Callback::Cancelable * onSuccessCallback,
2502                                                   Callback::Cancelable * onFailureCallback)
2503 {
2504     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
2505     System::PacketBufferHandle encodedCommand = encodeDoorLockClusterReadLockTypeAttribute(seqNum, mEndpoint);
2506     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
2507 }
2508
2509 CHIP_ERROR DoorLockCluster::ReadAttributeActuatorEnabled(Callback::Cancelable * onSuccessCallback,
2510                                                          Callback::Cancelable * onFailureCallback)
2511 {
2512     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
2513     System::PacketBufferHandle encodedCommand = encodeDoorLockClusterReadActuatorEnabledAttribute(seqNum, mEndpoint);
2514     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
2515 }
2516
2517 CHIP_ERROR DoorLockCluster::ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback,
2518                                                          Callback::Cancelable * onFailureCallback)
2519 {
2520     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
2521     System::PacketBufferHandle encodedCommand = encodeDoorLockClusterReadClusterRevisionAttribute(seqNum, mEndpoint);
2522     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
2523 }
2524
2525 // GeneralCommissioning Cluster Commands
2526 CHIP_ERROR GeneralCommissioningCluster::ArmFailSafe(Callback::Cancelable * onSuccessCallback,
2527                                                     Callback::Cancelable * onFailureCallback, uint16_t expiryLengthSeconds,
2528                                                     uint64_t breadcrumb, uint32_t timeoutMs)
2529 {
2530 #if CHIP_ENABLE_INTERACTION_MODEL
2531     VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE);
2532     (void) onSuccessCallback;
2533     (void) onFailureCallback;
2534
2535     app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kArmFailSafeCommandId,
2536                                               (chip::app::Command::CommandPathFlags::kEndpointIdValid) };
2537     app::Command * ZCLcommand             = mDevice->GetCommandSender();
2538
2539     TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter();
2540
2541     TLV::TLVType dummyType = TLV::kTLVType_NotSpecified;
2542     ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType));
2543
2544     uint8_t argSeqNumber = 0;
2545     // expiryLengthSeconds: int16u
2546     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), expiryLengthSeconds));
2547     // breadcrumb: int64u
2548     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), breadcrumb));
2549     // timeoutMs: int32u
2550     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), timeoutMs));
2551
2552     ReturnErrorOnFailure(writer.EndContainer(dummyType));
2553     ReturnErrorOnFailure(writer.Finalize());
2554     ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams));
2555
2556     return mDevice->SendCommands();
2557 #else
2558     uint8_t seqNum = mDevice->GetNextSequenceNumber();
2559     System::PacketBufferHandle encodedCommand =
2560         encodeGeneralCommissioningClusterArmFailSafeCommand(seqNum, mEndpoint, expiryLengthSeconds, breadcrumb, timeoutMs);
2561     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
2562 #endif
2563 }
2564
2565 CHIP_ERROR GeneralCommissioningCluster::CommissioningComplete(Callback::Cancelable * onSuccessCallback,
2566                                                               Callback::Cancelable * onFailureCallback)
2567 {
2568 #if CHIP_ENABLE_INTERACTION_MODEL
2569     VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE);
2570     (void) onSuccessCallback;
2571     (void) onFailureCallback;
2572
2573     app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kCommissioningCompleteCommandId,
2574                                               (chip::app::Command::CommandPathFlags::kEndpointIdValid) };
2575     app::Command * ZCLcommand             = mDevice->GetCommandSender();
2576
2577     TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter();
2578
2579     TLV::TLVType dummyType = TLV::kTLVType_NotSpecified;
2580     ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType));
2581
2582     // Command takes no arguments.
2583
2584     ReturnErrorOnFailure(writer.EndContainer(dummyType));
2585     ReturnErrorOnFailure(writer.Finalize());
2586     ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams));
2587
2588     return mDevice->SendCommands();
2589 #else
2590     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
2591     System::PacketBufferHandle encodedCommand = encodeGeneralCommissioningClusterCommissioningCompleteCommand(seqNum, mEndpoint);
2592     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
2593 #endif
2594 }
2595
2596 CHIP_ERROR GeneralCommissioningCluster::SetFabric(Callback::Cancelable * onSuccessCallback,
2597                                                   Callback::Cancelable * onFailureCallback, chip::ByteSpan fabricId,
2598                                                   chip::ByteSpan fabricSecret, uint64_t breadcrumb, uint32_t timeoutMs)
2599 {
2600 #if CHIP_ENABLE_INTERACTION_MODEL
2601     VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE);
2602     (void) onSuccessCallback;
2603     (void) onFailureCallback;
2604
2605     app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kSetFabricCommandId,
2606                                               (chip::app::Command::CommandPathFlags::kEndpointIdValid) };
2607     app::Command * ZCLcommand             = mDevice->GetCommandSender();
2608
2609     TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter();
2610
2611     TLV::TLVType dummyType = TLV::kTLVType_NotSpecified;
2612     ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType));
2613
2614     uint8_t argSeqNumber = 0;
2615     // fabricId: octetString
2616     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), fabricId));
2617     // fabricSecret: octetString
2618     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), fabricSecret));
2619     // breadcrumb: int64u
2620     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), breadcrumb));
2621     // timeoutMs: int32u
2622     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), timeoutMs));
2623
2624     ReturnErrorOnFailure(writer.EndContainer(dummyType));
2625     ReturnErrorOnFailure(writer.Finalize());
2626     ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams));
2627
2628     return mDevice->SendCommands();
2629 #else
2630     uint8_t seqNum = mDevice->GetNextSequenceNumber();
2631     System::PacketBufferHandle encodedCommand =
2632         encodeGeneralCommissioningClusterSetFabricCommand(seqNum, mEndpoint, fabricId, fabricSecret, breadcrumb, timeoutMs);
2633     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
2634 #endif
2635 }
2636
2637 // GeneralCommissioning Cluster Attributes
2638 CHIP_ERROR GeneralCommissioningCluster::DiscoverAttributes(Callback::Cancelable * onSuccessCallback,
2639                                                            Callback::Cancelable * onFailureCallback)
2640 {
2641     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
2642     System::PacketBufferHandle encodedCommand = encodeGeneralCommissioningClusterDiscoverAttributes(seqNum, mEndpoint);
2643     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
2644 }
2645 CHIP_ERROR GeneralCommissioningCluster::ReadAttributeFabricId(Callback::Cancelable * onSuccessCallback,
2646                                                               Callback::Cancelable * onFailureCallback)
2647 {
2648     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
2649     System::PacketBufferHandle encodedCommand = encodeGeneralCommissioningClusterReadFabricIdAttribute(seqNum, mEndpoint);
2650     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
2651 }
2652
2653 CHIP_ERROR GeneralCommissioningCluster::ReadAttributeBreadcrumb(Callback::Cancelable * onSuccessCallback,
2654                                                                 Callback::Cancelable * onFailureCallback)
2655 {
2656     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
2657     System::PacketBufferHandle encodedCommand = encodeGeneralCommissioningClusterReadBreadcrumbAttribute(seqNum, mEndpoint);
2658     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
2659 }
2660
2661 CHIP_ERROR GeneralCommissioningCluster::WriteAttributeBreadcrumb(Callback::Cancelable * onSuccessCallback,
2662                                                                  Callback::Cancelable * onFailureCallback, uint64_t value)
2663 {
2664     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
2665     System::PacketBufferHandle encodedCommand = encodeGeneralCommissioningClusterWriteBreadcrumbAttribute(seqNum, mEndpoint, value);
2666     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
2667 }
2668
2669 CHIP_ERROR GeneralCommissioningCluster::ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback,
2670                                                                      Callback::Cancelable * onFailureCallback)
2671 {
2672     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
2673     System::PacketBufferHandle encodedCommand = encodeGeneralCommissioningClusterReadClusterRevisionAttribute(seqNum, mEndpoint);
2674     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
2675 }
2676
2677 // GroupKeyManagement Cluster Commands
2678 // GroupKeyManagement Cluster Attributes
2679 CHIP_ERROR GroupKeyManagementCluster::DiscoverAttributes(Callback::Cancelable * onSuccessCallback,
2680                                                          Callback::Cancelable * onFailureCallback)
2681 {
2682     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
2683     System::PacketBufferHandle encodedCommand = encodeGroupKeyManagementClusterDiscoverAttributes(seqNum, mEndpoint);
2684     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
2685 }
2686 CHIP_ERROR GroupKeyManagementCluster::ReadAttributeGroups(Callback::Cancelable * onSuccessCallback,
2687                                                           Callback::Cancelable * onFailureCallback)
2688 {
2689     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
2690     System::PacketBufferHandle encodedCommand = encodeGroupKeyManagementClusterReadGroupsAttribute(seqNum, mEndpoint);
2691     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
2692 }
2693
2694 CHIP_ERROR GroupKeyManagementCluster::ReadAttributeGroupKeys(Callback::Cancelable * onSuccessCallback,
2695                                                              Callback::Cancelable * onFailureCallback)
2696 {
2697     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
2698     System::PacketBufferHandle encodedCommand = encodeGroupKeyManagementClusterReadGroupKeysAttribute(seqNum, mEndpoint);
2699     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
2700 }
2701
2702 CHIP_ERROR GroupKeyManagementCluster::ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback,
2703                                                                    Callback::Cancelable * onFailureCallback)
2704 {
2705     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
2706     System::PacketBufferHandle encodedCommand = encodeGroupKeyManagementClusterReadClusterRevisionAttribute(seqNum, mEndpoint);
2707     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
2708 }
2709
2710 // Groups Cluster Commands
2711 CHIP_ERROR GroupsCluster::AddGroup(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback,
2712                                    uint16_t groupId, chip::ByteSpan groupName)
2713 {
2714 #if CHIP_ENABLE_INTERACTION_MODEL
2715     VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE);
2716     (void) onSuccessCallback;
2717     (void) onFailureCallback;
2718
2719     app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kAddGroupCommandId,
2720                                               (chip::app::Command::CommandPathFlags::kEndpointIdValid) };
2721     app::Command * ZCLcommand             = mDevice->GetCommandSender();
2722
2723     TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter();
2724
2725     TLV::TLVType dummyType = TLV::kTLVType_NotSpecified;
2726     ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType));
2727
2728     uint8_t argSeqNumber = 0;
2729     // groupId: int16u
2730     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), groupId));
2731     // groupName: charString
2732     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), groupName));
2733
2734     ReturnErrorOnFailure(writer.EndContainer(dummyType));
2735     ReturnErrorOnFailure(writer.Finalize());
2736     ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams));
2737
2738     return mDevice->SendCommands();
2739 #else
2740     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
2741     System::PacketBufferHandle encodedCommand = encodeGroupsClusterAddGroupCommand(seqNum, mEndpoint, groupId, groupName);
2742     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
2743 #endif
2744 }
2745
2746 CHIP_ERROR GroupsCluster::AddGroupIfIdentifying(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback,
2747                                                 uint16_t groupId, chip::ByteSpan groupName)
2748 {
2749 #if CHIP_ENABLE_INTERACTION_MODEL
2750     VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE);
2751     (void) onSuccessCallback;
2752     (void) onFailureCallback;
2753
2754     app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kAddGroupIfIdentifyingCommandId,
2755                                               (chip::app::Command::CommandPathFlags::kEndpointIdValid) };
2756     app::Command * ZCLcommand             = mDevice->GetCommandSender();
2757
2758     TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter();
2759
2760     TLV::TLVType dummyType = TLV::kTLVType_NotSpecified;
2761     ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType));
2762
2763     uint8_t argSeqNumber = 0;
2764     // groupId: int16u
2765     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), groupId));
2766     // groupName: charString
2767     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), groupName));
2768
2769     ReturnErrorOnFailure(writer.EndContainer(dummyType));
2770     ReturnErrorOnFailure(writer.Finalize());
2771     ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams));
2772
2773     return mDevice->SendCommands();
2774 #else
2775     uint8_t seqNum = mDevice->GetNextSequenceNumber();
2776     System::PacketBufferHandle encodedCommand =
2777         encodeGroupsClusterAddGroupIfIdentifyingCommand(seqNum, mEndpoint, groupId, groupName);
2778     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
2779 #endif
2780 }
2781
2782 CHIP_ERROR GroupsCluster::GetGroupMembership(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback,
2783                                              uint8_t groupCount, uint16_t groupList)
2784 {
2785 #if CHIP_ENABLE_INTERACTION_MODEL
2786     VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE);
2787     (void) onSuccessCallback;
2788     (void) onFailureCallback;
2789
2790     app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kGetGroupMembershipCommandId,
2791                                               (chip::app::Command::CommandPathFlags::kEndpointIdValid) };
2792     app::Command * ZCLcommand             = mDevice->GetCommandSender();
2793
2794     TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter();
2795
2796     TLV::TLVType dummyType = TLV::kTLVType_NotSpecified;
2797     ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType));
2798
2799     uint8_t argSeqNumber = 0;
2800     // groupCount: int8u
2801     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), groupCount));
2802     // groupList: int16u
2803     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), groupList));
2804
2805     ReturnErrorOnFailure(writer.EndContainer(dummyType));
2806     ReturnErrorOnFailure(writer.Finalize());
2807     ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams));
2808
2809     return mDevice->SendCommands();
2810 #else
2811     uint8_t seqNum = mDevice->GetNextSequenceNumber();
2812     System::PacketBufferHandle encodedCommand =
2813         encodeGroupsClusterGetGroupMembershipCommand(seqNum, mEndpoint, groupCount, groupList);
2814     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
2815 #endif
2816 }
2817
2818 CHIP_ERROR GroupsCluster::RemoveAllGroups(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback)
2819 {
2820 #if CHIP_ENABLE_INTERACTION_MODEL
2821     VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE);
2822     (void) onSuccessCallback;
2823     (void) onFailureCallback;
2824
2825     app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kRemoveAllGroupsCommandId,
2826                                               (chip::app::Command::CommandPathFlags::kEndpointIdValid) };
2827     app::Command * ZCLcommand             = mDevice->GetCommandSender();
2828
2829     TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter();
2830
2831     TLV::TLVType dummyType = TLV::kTLVType_NotSpecified;
2832     ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType));
2833
2834     // Command takes no arguments.
2835
2836     ReturnErrorOnFailure(writer.EndContainer(dummyType));
2837     ReturnErrorOnFailure(writer.Finalize());
2838     ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams));
2839
2840     return mDevice->SendCommands();
2841 #else
2842     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
2843     System::PacketBufferHandle encodedCommand = encodeGroupsClusterRemoveAllGroupsCommand(seqNum, mEndpoint);
2844     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
2845 #endif
2846 }
2847
2848 CHIP_ERROR GroupsCluster::RemoveGroup(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback,
2849                                       uint16_t groupId)
2850 {
2851 #if CHIP_ENABLE_INTERACTION_MODEL
2852     VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE);
2853     (void) onSuccessCallback;
2854     (void) onFailureCallback;
2855
2856     app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kRemoveGroupCommandId,
2857                                               (chip::app::Command::CommandPathFlags::kEndpointIdValid) };
2858     app::Command * ZCLcommand             = mDevice->GetCommandSender();
2859
2860     TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter();
2861
2862     TLV::TLVType dummyType = TLV::kTLVType_NotSpecified;
2863     ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType));
2864
2865     uint8_t argSeqNumber = 0;
2866     // groupId: int16u
2867     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), groupId));
2868
2869     ReturnErrorOnFailure(writer.EndContainer(dummyType));
2870     ReturnErrorOnFailure(writer.Finalize());
2871     ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams));
2872
2873     return mDevice->SendCommands();
2874 #else
2875     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
2876     System::PacketBufferHandle encodedCommand = encodeGroupsClusterRemoveGroupCommand(seqNum, mEndpoint, groupId);
2877     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
2878 #endif
2879 }
2880
2881 CHIP_ERROR GroupsCluster::ViewGroup(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback,
2882                                     uint16_t groupId)
2883 {
2884 #if CHIP_ENABLE_INTERACTION_MODEL
2885     VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE);
2886     (void) onSuccessCallback;
2887     (void) onFailureCallback;
2888
2889     app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kViewGroupCommandId,
2890                                               (chip::app::Command::CommandPathFlags::kEndpointIdValid) };
2891     app::Command * ZCLcommand             = mDevice->GetCommandSender();
2892
2893     TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter();
2894
2895     TLV::TLVType dummyType = TLV::kTLVType_NotSpecified;
2896     ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType));
2897
2898     uint8_t argSeqNumber = 0;
2899     // groupId: int16u
2900     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), groupId));
2901
2902     ReturnErrorOnFailure(writer.EndContainer(dummyType));
2903     ReturnErrorOnFailure(writer.Finalize());
2904     ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams));
2905
2906     return mDevice->SendCommands();
2907 #else
2908     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
2909     System::PacketBufferHandle encodedCommand = encodeGroupsClusterViewGroupCommand(seqNum, mEndpoint, groupId);
2910     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
2911 #endif
2912 }
2913
2914 // Groups Cluster Attributes
2915 CHIP_ERROR GroupsCluster::DiscoverAttributes(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback)
2916 {
2917     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
2918     System::PacketBufferHandle encodedCommand = encodeGroupsClusterDiscoverAttributes(seqNum, mEndpoint);
2919     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
2920 }
2921 CHIP_ERROR GroupsCluster::ReadAttributeNameSupport(Callback::Cancelable * onSuccessCallback,
2922                                                    Callback::Cancelable * onFailureCallback)
2923 {
2924     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
2925     System::PacketBufferHandle encodedCommand = encodeGroupsClusterReadNameSupportAttribute(seqNum, mEndpoint);
2926     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
2927 }
2928
2929 CHIP_ERROR GroupsCluster::ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback,
2930                                                        Callback::Cancelable * onFailureCallback)
2931 {
2932     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
2933     System::PacketBufferHandle encodedCommand = encodeGroupsClusterReadClusterRevisionAttribute(seqNum, mEndpoint);
2934     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
2935 }
2936
2937 // IasZone Cluster Commands
2938 // IasZone Cluster Attributes
2939 CHIP_ERROR IasZoneCluster::DiscoverAttributes(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback)
2940 {
2941     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
2942     System::PacketBufferHandle encodedCommand = encodeIasZoneClusterDiscoverAttributes(seqNum, mEndpoint);
2943     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
2944 }
2945 CHIP_ERROR IasZoneCluster::ReadAttributeZoneState(Callback::Cancelable * onSuccessCallback,
2946                                                   Callback::Cancelable * onFailureCallback)
2947 {
2948     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
2949     System::PacketBufferHandle encodedCommand = encodeIasZoneClusterReadZoneStateAttribute(seqNum, mEndpoint);
2950     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
2951 }
2952
2953 CHIP_ERROR IasZoneCluster::ReadAttributeZoneType(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback)
2954 {
2955     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
2956     System::PacketBufferHandle encodedCommand = encodeIasZoneClusterReadZoneTypeAttribute(seqNum, mEndpoint);
2957     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
2958 }
2959
2960 CHIP_ERROR IasZoneCluster::ReadAttributeZoneStatus(Callback::Cancelable * onSuccessCallback,
2961                                                    Callback::Cancelable * onFailureCallback)
2962 {
2963     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
2964     System::PacketBufferHandle encodedCommand = encodeIasZoneClusterReadZoneStatusAttribute(seqNum, mEndpoint);
2965     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
2966 }
2967
2968 CHIP_ERROR IasZoneCluster::ReadAttributeIasCieAddress(Callback::Cancelable * onSuccessCallback,
2969                                                       Callback::Cancelable * onFailureCallback)
2970 {
2971     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
2972     System::PacketBufferHandle encodedCommand = encodeIasZoneClusterReadIasCieAddressAttribute(seqNum, mEndpoint);
2973     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
2974 }
2975
2976 CHIP_ERROR IasZoneCluster::WriteAttributeIasCieAddress(Callback::Cancelable * onSuccessCallback,
2977                                                        Callback::Cancelable * onFailureCallback, uint64_t value)
2978 {
2979     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
2980     System::PacketBufferHandle encodedCommand = encodeIasZoneClusterWriteIasCieAddressAttribute(seqNum, mEndpoint, value);
2981     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
2982 }
2983
2984 CHIP_ERROR IasZoneCluster::ReadAttributeZoneId(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback)
2985 {
2986     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
2987     System::PacketBufferHandle encodedCommand = encodeIasZoneClusterReadZoneIdAttribute(seqNum, mEndpoint);
2988     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
2989 }
2990
2991 CHIP_ERROR IasZoneCluster::ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback,
2992                                                         Callback::Cancelable * onFailureCallback)
2993 {
2994     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
2995     System::PacketBufferHandle encodedCommand = encodeIasZoneClusterReadClusterRevisionAttribute(seqNum, mEndpoint);
2996     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
2997 }
2998
2999 // Identify Cluster Commands
3000 CHIP_ERROR IdentifyCluster::Identify(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback,
3001                                      uint16_t identifyTime)
3002 {
3003 #if CHIP_ENABLE_INTERACTION_MODEL
3004     VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE);
3005     (void) onSuccessCallback;
3006     (void) onFailureCallback;
3007
3008     app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kIdentifyCommandId,
3009                                               (chip::app::Command::CommandPathFlags::kEndpointIdValid) };
3010     app::Command * ZCLcommand             = mDevice->GetCommandSender();
3011
3012     TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter();
3013
3014     TLV::TLVType dummyType = TLV::kTLVType_NotSpecified;
3015     ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType));
3016
3017     uint8_t argSeqNumber = 0;
3018     // identifyTime: int16u
3019     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), identifyTime));
3020
3021     ReturnErrorOnFailure(writer.EndContainer(dummyType));
3022     ReturnErrorOnFailure(writer.Finalize());
3023     ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams));
3024
3025     return mDevice->SendCommands();
3026 #else
3027     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
3028     System::PacketBufferHandle encodedCommand = encodeIdentifyClusterIdentifyCommand(seqNum, mEndpoint, identifyTime);
3029     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
3030 #endif
3031 }
3032
3033 CHIP_ERROR IdentifyCluster::IdentifyQuery(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback)
3034 {
3035 #if CHIP_ENABLE_INTERACTION_MODEL
3036     VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE);
3037     (void) onSuccessCallback;
3038     (void) onFailureCallback;
3039
3040     app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kIdentifyQueryCommandId,
3041                                               (chip::app::Command::CommandPathFlags::kEndpointIdValid) };
3042     app::Command * ZCLcommand             = mDevice->GetCommandSender();
3043
3044     TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter();
3045
3046     TLV::TLVType dummyType = TLV::kTLVType_NotSpecified;
3047     ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType));
3048
3049     // Command takes no arguments.
3050
3051     ReturnErrorOnFailure(writer.EndContainer(dummyType));
3052     ReturnErrorOnFailure(writer.Finalize());
3053     ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams));
3054
3055     return mDevice->SendCommands();
3056 #else
3057     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
3058     System::PacketBufferHandle encodedCommand = encodeIdentifyClusterIdentifyQueryCommand(seqNum, mEndpoint);
3059     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
3060 #endif
3061 }
3062
3063 // Identify Cluster Attributes
3064 CHIP_ERROR IdentifyCluster::DiscoverAttributes(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback)
3065 {
3066     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
3067     System::PacketBufferHandle encodedCommand = encodeIdentifyClusterDiscoverAttributes(seqNum, mEndpoint);
3068     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
3069 }
3070 CHIP_ERROR IdentifyCluster::ReadAttributeIdentifyTime(Callback::Cancelable * onSuccessCallback,
3071                                                       Callback::Cancelable * onFailureCallback)
3072 {
3073     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
3074     System::PacketBufferHandle encodedCommand = encodeIdentifyClusterReadIdentifyTimeAttribute(seqNum, mEndpoint);
3075     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
3076 }
3077
3078 CHIP_ERROR IdentifyCluster::WriteAttributeIdentifyTime(Callback::Cancelable * onSuccessCallback,
3079                                                        Callback::Cancelable * onFailureCallback, uint16_t value)
3080 {
3081     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
3082     System::PacketBufferHandle encodedCommand = encodeIdentifyClusterWriteIdentifyTimeAttribute(seqNum, mEndpoint, value);
3083     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
3084 }
3085
3086 CHIP_ERROR IdentifyCluster::ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback,
3087                                                          Callback::Cancelable * onFailureCallback)
3088 {
3089     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
3090     System::PacketBufferHandle encodedCommand = encodeIdentifyClusterReadClusterRevisionAttribute(seqNum, mEndpoint);
3091     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
3092 }
3093
3094 // LevelControl Cluster Commands
3095 CHIP_ERROR LevelControlCluster::Move(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback,
3096                                      uint8_t moveMode, uint8_t rate, uint8_t optionMask, uint8_t optionOverride)
3097 {
3098 #if CHIP_ENABLE_INTERACTION_MODEL
3099     VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE);
3100     (void) onSuccessCallback;
3101     (void) onFailureCallback;
3102
3103     app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kMoveCommandId,
3104                                               (chip::app::Command::CommandPathFlags::kEndpointIdValid) };
3105     app::Command * ZCLcommand             = mDevice->GetCommandSender();
3106
3107     TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter();
3108
3109     TLV::TLVType dummyType = TLV::kTLVType_NotSpecified;
3110     ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType));
3111
3112     uint8_t argSeqNumber = 0;
3113     // moveMode: moveMode
3114     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), moveMode));
3115     // rate: int8u
3116     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), rate));
3117     // optionMask: bitmap8
3118     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), optionMask));
3119     // optionOverride: bitmap8
3120     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), optionOverride));
3121
3122     ReturnErrorOnFailure(writer.EndContainer(dummyType));
3123     ReturnErrorOnFailure(writer.Finalize());
3124     ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams));
3125
3126     return mDevice->SendCommands();
3127 #else
3128     uint8_t seqNum = mDevice->GetNextSequenceNumber();
3129     System::PacketBufferHandle encodedCommand =
3130         encodeLevelControlClusterMoveCommand(seqNum, mEndpoint, moveMode, rate, optionMask, optionOverride);
3131     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
3132 #endif
3133 }
3134
3135 CHIP_ERROR LevelControlCluster::MoveToLevel(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback,
3136                                             uint8_t level, uint16_t transitionTime, uint8_t optionMask, uint8_t optionOverride)
3137 {
3138 #if CHIP_ENABLE_INTERACTION_MODEL
3139     VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE);
3140     (void) onSuccessCallback;
3141     (void) onFailureCallback;
3142
3143     app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kMoveToLevelCommandId,
3144                                               (chip::app::Command::CommandPathFlags::kEndpointIdValid) };
3145     app::Command * ZCLcommand             = mDevice->GetCommandSender();
3146
3147     TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter();
3148
3149     TLV::TLVType dummyType = TLV::kTLVType_NotSpecified;
3150     ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType));
3151
3152     uint8_t argSeqNumber = 0;
3153     // level: int8u
3154     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), level));
3155     // transitionTime: int16u
3156     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), transitionTime));
3157     // optionMask: bitmap8
3158     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), optionMask));
3159     // optionOverride: bitmap8
3160     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), optionOverride));
3161
3162     ReturnErrorOnFailure(writer.EndContainer(dummyType));
3163     ReturnErrorOnFailure(writer.Finalize());
3164     ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams));
3165
3166     return mDevice->SendCommands();
3167 #else
3168     uint8_t seqNum = mDevice->GetNextSequenceNumber();
3169     System::PacketBufferHandle encodedCommand =
3170         encodeLevelControlClusterMoveToLevelCommand(seqNum, mEndpoint, level, transitionTime, optionMask, optionOverride);
3171     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
3172 #endif
3173 }
3174
3175 CHIP_ERROR LevelControlCluster::MoveToLevelWithOnOff(Callback::Cancelable * onSuccessCallback,
3176                                                      Callback::Cancelable * onFailureCallback, uint8_t level,
3177                                                      uint16_t transitionTime)
3178 {
3179 #if CHIP_ENABLE_INTERACTION_MODEL
3180     VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE);
3181     (void) onSuccessCallback;
3182     (void) onFailureCallback;
3183
3184     app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kMoveToLevelWithOnOffCommandId,
3185                                               (chip::app::Command::CommandPathFlags::kEndpointIdValid) };
3186     app::Command * ZCLcommand             = mDevice->GetCommandSender();
3187
3188     TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter();
3189
3190     TLV::TLVType dummyType = TLV::kTLVType_NotSpecified;
3191     ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType));
3192
3193     uint8_t argSeqNumber = 0;
3194     // level: int8u
3195     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), level));
3196     // transitionTime: int16u
3197     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), transitionTime));
3198
3199     ReturnErrorOnFailure(writer.EndContainer(dummyType));
3200     ReturnErrorOnFailure(writer.Finalize());
3201     ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams));
3202
3203     return mDevice->SendCommands();
3204 #else
3205     uint8_t seqNum = mDevice->GetNextSequenceNumber();
3206     System::PacketBufferHandle encodedCommand =
3207         encodeLevelControlClusterMoveToLevelWithOnOffCommand(seqNum, mEndpoint, level, transitionTime);
3208     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
3209 #endif
3210 }
3211
3212 CHIP_ERROR LevelControlCluster::MoveWithOnOff(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback,
3213                                               uint8_t moveMode, uint8_t rate)
3214 {
3215 #if CHIP_ENABLE_INTERACTION_MODEL
3216     VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE);
3217     (void) onSuccessCallback;
3218     (void) onFailureCallback;
3219
3220     app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kMoveWithOnOffCommandId,
3221                                               (chip::app::Command::CommandPathFlags::kEndpointIdValid) };
3222     app::Command * ZCLcommand             = mDevice->GetCommandSender();
3223
3224     TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter();
3225
3226     TLV::TLVType dummyType = TLV::kTLVType_NotSpecified;
3227     ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType));
3228
3229     uint8_t argSeqNumber = 0;
3230     // moveMode: moveMode
3231     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), moveMode));
3232     // rate: int8u
3233     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), rate));
3234
3235     ReturnErrorOnFailure(writer.EndContainer(dummyType));
3236     ReturnErrorOnFailure(writer.Finalize());
3237     ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams));
3238
3239     return mDevice->SendCommands();
3240 #else
3241     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
3242     System::PacketBufferHandle encodedCommand = encodeLevelControlClusterMoveWithOnOffCommand(seqNum, mEndpoint, moveMode, rate);
3243     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
3244 #endif
3245 }
3246
3247 CHIP_ERROR LevelControlCluster::Step(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback,
3248                                      uint8_t stepMode, uint8_t stepSize, uint16_t transitionTime, uint8_t optionMask,
3249                                      uint8_t optionOverride)
3250 {
3251 #if CHIP_ENABLE_INTERACTION_MODEL
3252     VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE);
3253     (void) onSuccessCallback;
3254     (void) onFailureCallback;
3255
3256     app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kStepCommandId,
3257                                               (chip::app::Command::CommandPathFlags::kEndpointIdValid) };
3258     app::Command * ZCLcommand             = mDevice->GetCommandSender();
3259
3260     TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter();
3261
3262     TLV::TLVType dummyType = TLV::kTLVType_NotSpecified;
3263     ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType));
3264
3265     uint8_t argSeqNumber = 0;
3266     // stepMode: stepMode
3267     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), stepMode));
3268     // stepSize: int8u
3269     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), stepSize));
3270     // transitionTime: int16u
3271     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), transitionTime));
3272     // optionMask: bitmap8
3273     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), optionMask));
3274     // optionOverride: bitmap8
3275     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), optionOverride));
3276
3277     ReturnErrorOnFailure(writer.EndContainer(dummyType));
3278     ReturnErrorOnFailure(writer.Finalize());
3279     ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams));
3280
3281     return mDevice->SendCommands();
3282 #else
3283     uint8_t seqNum = mDevice->GetNextSequenceNumber();
3284     System::PacketBufferHandle encodedCommand =
3285         encodeLevelControlClusterStepCommand(seqNum, mEndpoint, stepMode, stepSize, transitionTime, optionMask, optionOverride);
3286     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
3287 #endif
3288 }
3289
3290 CHIP_ERROR LevelControlCluster::StepWithOnOff(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback,
3291                                               uint8_t stepMode, uint8_t stepSize, uint16_t transitionTime)
3292 {
3293 #if CHIP_ENABLE_INTERACTION_MODEL
3294     VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE);
3295     (void) onSuccessCallback;
3296     (void) onFailureCallback;
3297
3298     app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kStepWithOnOffCommandId,
3299                                               (chip::app::Command::CommandPathFlags::kEndpointIdValid) };
3300     app::Command * ZCLcommand             = mDevice->GetCommandSender();
3301
3302     TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter();
3303
3304     TLV::TLVType dummyType = TLV::kTLVType_NotSpecified;
3305     ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType));
3306
3307     uint8_t argSeqNumber = 0;
3308     // stepMode: stepMode
3309     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), stepMode));
3310     // stepSize: int8u
3311     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), stepSize));
3312     // transitionTime: int16u
3313     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), transitionTime));
3314
3315     ReturnErrorOnFailure(writer.EndContainer(dummyType));
3316     ReturnErrorOnFailure(writer.Finalize());
3317     ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams));
3318
3319     return mDevice->SendCommands();
3320 #else
3321     uint8_t seqNum = mDevice->GetNextSequenceNumber();
3322     System::PacketBufferHandle encodedCommand =
3323         encodeLevelControlClusterStepWithOnOffCommand(seqNum, mEndpoint, stepMode, stepSize, transitionTime);
3324     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
3325 #endif
3326 }
3327
3328 CHIP_ERROR LevelControlCluster::Stop(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback,
3329                                      uint8_t optionMask, uint8_t optionOverride)
3330 {
3331 #if CHIP_ENABLE_INTERACTION_MODEL
3332     VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE);
3333     (void) onSuccessCallback;
3334     (void) onFailureCallback;
3335
3336     app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kStopCommandId,
3337                                               (chip::app::Command::CommandPathFlags::kEndpointIdValid) };
3338     app::Command * ZCLcommand             = mDevice->GetCommandSender();
3339
3340     TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter();
3341
3342     TLV::TLVType dummyType = TLV::kTLVType_NotSpecified;
3343     ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType));
3344
3345     uint8_t argSeqNumber = 0;
3346     // optionMask: bitmap8
3347     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), optionMask));
3348     // optionOverride: bitmap8
3349     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), optionOverride));
3350
3351     ReturnErrorOnFailure(writer.EndContainer(dummyType));
3352     ReturnErrorOnFailure(writer.Finalize());
3353     ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams));
3354
3355     return mDevice->SendCommands();
3356 #else
3357     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
3358     System::PacketBufferHandle encodedCommand = encodeLevelControlClusterStopCommand(seqNum, mEndpoint, optionMask, optionOverride);
3359     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
3360 #endif
3361 }
3362
3363 CHIP_ERROR LevelControlCluster::StopWithOnOff(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback)
3364 {
3365 #if CHIP_ENABLE_INTERACTION_MODEL
3366     VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE);
3367     (void) onSuccessCallback;
3368     (void) onFailureCallback;
3369
3370     app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kStopWithOnOffCommandId,
3371                                               (chip::app::Command::CommandPathFlags::kEndpointIdValid) };
3372     app::Command * ZCLcommand             = mDevice->GetCommandSender();
3373
3374     TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter();
3375
3376     TLV::TLVType dummyType = TLV::kTLVType_NotSpecified;
3377     ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType));
3378
3379     // Command takes no arguments.
3380
3381     ReturnErrorOnFailure(writer.EndContainer(dummyType));
3382     ReturnErrorOnFailure(writer.Finalize());
3383     ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams));
3384
3385     return mDevice->SendCommands();
3386 #else
3387     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
3388     System::PacketBufferHandle encodedCommand = encodeLevelControlClusterStopWithOnOffCommand(seqNum, mEndpoint);
3389     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
3390 #endif
3391 }
3392
3393 // LevelControl Cluster Attributes
3394 CHIP_ERROR LevelControlCluster::DiscoverAttributes(Callback::Cancelable * onSuccessCallback,
3395                                                    Callback::Cancelable * onFailureCallback)
3396 {
3397     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
3398     System::PacketBufferHandle encodedCommand = encodeLevelControlClusterDiscoverAttributes(seqNum, mEndpoint);
3399     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
3400 }
3401 CHIP_ERROR LevelControlCluster::ReadAttributeCurrentLevel(Callback::Cancelable * onSuccessCallback,
3402                                                           Callback::Cancelable * onFailureCallback)
3403 {
3404     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
3405     System::PacketBufferHandle encodedCommand = encodeLevelControlClusterReadCurrentLevelAttribute(seqNum, mEndpoint);
3406     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
3407 }
3408
3409 CHIP_ERROR LevelControlCluster::ConfigureAttributeCurrentLevel(Callback::Cancelable * onSuccessCallback,
3410                                                                Callback::Cancelable * onFailureCallback, uint16_t minInterval,
3411                                                                uint16_t maxInterval, uint8_t change)
3412 {
3413     uint8_t seqNum = mDevice->GetNextSequenceNumber();
3414     System::PacketBufferHandle encodedCommand =
3415         encodeLevelControlClusterConfigureCurrentLevelAttribute(seqNum, mEndpoint, minInterval, maxInterval, change);
3416     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
3417 }
3418
3419 CHIP_ERROR LevelControlCluster::ReportAttributeCurrentLevel(Callback::Cancelable * onReportCallback)
3420 {
3421     return RequestAttributeReporting(0x0000, onReportCallback);
3422 }
3423
3424 CHIP_ERROR LevelControlCluster::ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback,
3425                                                              Callback::Cancelable * onFailureCallback)
3426 {
3427     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
3428     System::PacketBufferHandle encodedCommand = encodeLevelControlClusterReadClusterRevisionAttribute(seqNum, mEndpoint);
3429     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
3430 }
3431
3432 // LowPower Cluster Commands
3433 CHIP_ERROR LowPowerCluster::Sleep(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback)
3434 {
3435 #if CHIP_ENABLE_INTERACTION_MODEL
3436     VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE);
3437     (void) onSuccessCallback;
3438     (void) onFailureCallback;
3439
3440     app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kSleepCommandId,
3441                                               (chip::app::Command::CommandPathFlags::kEndpointIdValid) };
3442     app::Command * ZCLcommand             = mDevice->GetCommandSender();
3443
3444     TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter();
3445
3446     TLV::TLVType dummyType = TLV::kTLVType_NotSpecified;
3447     ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType));
3448
3449     // Command takes no arguments.
3450
3451     ReturnErrorOnFailure(writer.EndContainer(dummyType));
3452     ReturnErrorOnFailure(writer.Finalize());
3453     ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams));
3454
3455     return mDevice->SendCommands();
3456 #else
3457     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
3458     System::PacketBufferHandle encodedCommand = encodeLowPowerClusterSleepCommand(seqNum, mEndpoint);
3459     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
3460 #endif
3461 }
3462
3463 // LowPower Cluster Attributes
3464 CHIP_ERROR LowPowerCluster::DiscoverAttributes(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback)
3465 {
3466     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
3467     System::PacketBufferHandle encodedCommand = encodeLowPowerClusterDiscoverAttributes(seqNum, mEndpoint);
3468     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
3469 }
3470 CHIP_ERROR LowPowerCluster::ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback,
3471                                                          Callback::Cancelable * onFailureCallback)
3472 {
3473     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
3474     System::PacketBufferHandle encodedCommand = encodeLowPowerClusterReadClusterRevisionAttribute(seqNum, mEndpoint);
3475     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
3476 }
3477
3478 // NetworkCommissioning Cluster Commands
3479 CHIP_ERROR NetworkCommissioningCluster::AddThreadNetwork(Callback::Cancelable * onSuccessCallback,
3480                                                          Callback::Cancelable * onFailureCallback,
3481                                                          chip::ByteSpan operationalDataset, uint64_t breadcrumb, uint32_t timeoutMs)
3482 {
3483 #if CHIP_ENABLE_INTERACTION_MODEL
3484     VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE);
3485     (void) onSuccessCallback;
3486     (void) onFailureCallback;
3487
3488     app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kAddThreadNetworkCommandId,
3489                                               (chip::app::Command::CommandPathFlags::kEndpointIdValid) };
3490     app::Command * ZCLcommand             = mDevice->GetCommandSender();
3491
3492     TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter();
3493
3494     TLV::TLVType dummyType = TLV::kTLVType_NotSpecified;
3495     ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType));
3496
3497     uint8_t argSeqNumber = 0;
3498     // operationalDataset: octetString
3499     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), operationalDataset));
3500     // breadcrumb: int64u
3501     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), breadcrumb));
3502     // timeoutMs: int32u
3503     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), timeoutMs));
3504
3505     ReturnErrorOnFailure(writer.EndContainer(dummyType));
3506     ReturnErrorOnFailure(writer.Finalize());
3507     ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams));
3508
3509     return mDevice->SendCommands();
3510 #else
3511     uint8_t seqNum = mDevice->GetNextSequenceNumber();
3512     System::PacketBufferHandle encodedCommand =
3513         encodeNetworkCommissioningClusterAddThreadNetworkCommand(seqNum, mEndpoint, operationalDataset, breadcrumb, timeoutMs);
3514     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
3515 #endif
3516 }
3517
3518 CHIP_ERROR NetworkCommissioningCluster::AddWiFiNetwork(Callback::Cancelable * onSuccessCallback,
3519                                                        Callback::Cancelable * onFailureCallback, chip::ByteSpan ssid,
3520                                                        chip::ByteSpan credentials, uint64_t breadcrumb, uint32_t timeoutMs)
3521 {
3522 #if CHIP_ENABLE_INTERACTION_MODEL
3523     VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE);
3524     (void) onSuccessCallback;
3525     (void) onFailureCallback;
3526
3527     app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kAddWiFiNetworkCommandId,
3528                                               (chip::app::Command::CommandPathFlags::kEndpointIdValid) };
3529     app::Command * ZCLcommand             = mDevice->GetCommandSender();
3530
3531     TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter();
3532
3533     TLV::TLVType dummyType = TLV::kTLVType_NotSpecified;
3534     ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType));
3535
3536     uint8_t argSeqNumber = 0;
3537     // ssid: octetString
3538     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), ssid));
3539     // credentials: octetString
3540     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), credentials));
3541     // breadcrumb: int64u
3542     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), breadcrumb));
3543     // timeoutMs: int32u
3544     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), timeoutMs));
3545
3546     ReturnErrorOnFailure(writer.EndContainer(dummyType));
3547     ReturnErrorOnFailure(writer.Finalize());
3548     ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams));
3549
3550     return mDevice->SendCommands();
3551 #else
3552     uint8_t seqNum = mDevice->GetNextSequenceNumber();
3553     System::PacketBufferHandle encodedCommand =
3554         encodeNetworkCommissioningClusterAddWiFiNetworkCommand(seqNum, mEndpoint, ssid, credentials, breadcrumb, timeoutMs);
3555     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
3556 #endif
3557 }
3558
3559 CHIP_ERROR NetworkCommissioningCluster::DisableNetwork(Callback::Cancelable * onSuccessCallback,
3560                                                        Callback::Cancelable * onFailureCallback, chip::ByteSpan networkID,
3561                                                        uint64_t breadcrumb, uint32_t timeoutMs)
3562 {
3563 #if CHIP_ENABLE_INTERACTION_MODEL
3564     VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE);
3565     (void) onSuccessCallback;
3566     (void) onFailureCallback;
3567
3568     app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kDisableNetworkCommandId,
3569                                               (chip::app::Command::CommandPathFlags::kEndpointIdValid) };
3570     app::Command * ZCLcommand             = mDevice->GetCommandSender();
3571
3572     TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter();
3573
3574     TLV::TLVType dummyType = TLV::kTLVType_NotSpecified;
3575     ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType));
3576
3577     uint8_t argSeqNumber = 0;
3578     // networkID: octetString
3579     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), networkID));
3580     // breadcrumb: int64u
3581     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), breadcrumb));
3582     // timeoutMs: int32u
3583     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), timeoutMs));
3584
3585     ReturnErrorOnFailure(writer.EndContainer(dummyType));
3586     ReturnErrorOnFailure(writer.Finalize());
3587     ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams));
3588
3589     return mDevice->SendCommands();
3590 #else
3591     uint8_t seqNum = mDevice->GetNextSequenceNumber();
3592     System::PacketBufferHandle encodedCommand =
3593         encodeNetworkCommissioningClusterDisableNetworkCommand(seqNum, mEndpoint, networkID, breadcrumb, timeoutMs);
3594     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
3595 #endif
3596 }
3597
3598 CHIP_ERROR NetworkCommissioningCluster::EnableNetwork(Callback::Cancelable * onSuccessCallback,
3599                                                       Callback::Cancelable * onFailureCallback, chip::ByteSpan networkID,
3600                                                       uint64_t breadcrumb, uint32_t timeoutMs)
3601 {
3602 #if CHIP_ENABLE_INTERACTION_MODEL
3603     VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE);
3604     (void) onSuccessCallback;
3605     (void) onFailureCallback;
3606
3607     app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kEnableNetworkCommandId,
3608                                               (chip::app::Command::CommandPathFlags::kEndpointIdValid) };
3609     app::Command * ZCLcommand             = mDevice->GetCommandSender();
3610
3611     TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter();
3612
3613     TLV::TLVType dummyType = TLV::kTLVType_NotSpecified;
3614     ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType));
3615
3616     uint8_t argSeqNumber = 0;
3617     // networkID: octetString
3618     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), networkID));
3619     // breadcrumb: int64u
3620     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), breadcrumb));
3621     // timeoutMs: int32u
3622     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), timeoutMs));
3623
3624     ReturnErrorOnFailure(writer.EndContainer(dummyType));
3625     ReturnErrorOnFailure(writer.Finalize());
3626     ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams));
3627
3628     return mDevice->SendCommands();
3629 #else
3630     uint8_t seqNum = mDevice->GetNextSequenceNumber();
3631     System::PacketBufferHandle encodedCommand =
3632         encodeNetworkCommissioningClusterEnableNetworkCommand(seqNum, mEndpoint, networkID, breadcrumb, timeoutMs);
3633     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
3634 #endif
3635 }
3636
3637 CHIP_ERROR NetworkCommissioningCluster::GetLastNetworkCommissioningResult(Callback::Cancelable * onSuccessCallback,
3638                                                                           Callback::Cancelable * onFailureCallback,
3639                                                                           uint32_t timeoutMs)
3640 {
3641 #if CHIP_ENABLE_INTERACTION_MODEL
3642     VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE);
3643     (void) onSuccessCallback;
3644     (void) onFailureCallback;
3645
3646     app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kGetLastNetworkCommissioningResultCommandId,
3647                                               (chip::app::Command::CommandPathFlags::kEndpointIdValid) };
3648     app::Command * ZCLcommand             = mDevice->GetCommandSender();
3649
3650     TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter();
3651
3652     TLV::TLVType dummyType = TLV::kTLVType_NotSpecified;
3653     ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType));
3654
3655     uint8_t argSeqNumber = 0;
3656     // timeoutMs: int32u
3657     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), timeoutMs));
3658
3659     ReturnErrorOnFailure(writer.EndContainer(dummyType));
3660     ReturnErrorOnFailure(writer.Finalize());
3661     ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams));
3662
3663     return mDevice->SendCommands();
3664 #else
3665     uint8_t seqNum = mDevice->GetNextSequenceNumber();
3666     System::PacketBufferHandle encodedCommand =
3667         encodeNetworkCommissioningClusterGetLastNetworkCommissioningResultCommand(seqNum, mEndpoint, timeoutMs);
3668     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
3669 #endif
3670 }
3671
3672 CHIP_ERROR NetworkCommissioningCluster::RemoveNetwork(Callback::Cancelable * onSuccessCallback,
3673                                                       Callback::Cancelable * onFailureCallback, chip::ByteSpan networkID,
3674                                                       uint64_t breadcrumb, uint32_t timeoutMs)
3675 {
3676 #if CHIP_ENABLE_INTERACTION_MODEL
3677     VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE);
3678     (void) onSuccessCallback;
3679     (void) onFailureCallback;
3680
3681     app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kRemoveNetworkCommandId,
3682                                               (chip::app::Command::CommandPathFlags::kEndpointIdValid) };
3683     app::Command * ZCLcommand             = mDevice->GetCommandSender();
3684
3685     TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter();
3686
3687     TLV::TLVType dummyType = TLV::kTLVType_NotSpecified;
3688     ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType));
3689
3690     uint8_t argSeqNumber = 0;
3691     // networkID: octetString
3692     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), networkID));
3693     // breadcrumb: int64u
3694     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), breadcrumb));
3695     // timeoutMs: int32u
3696     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), timeoutMs));
3697
3698     ReturnErrorOnFailure(writer.EndContainer(dummyType));
3699     ReturnErrorOnFailure(writer.Finalize());
3700     ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams));
3701
3702     return mDevice->SendCommands();
3703 #else
3704     uint8_t seqNum = mDevice->GetNextSequenceNumber();
3705     System::PacketBufferHandle encodedCommand =
3706         encodeNetworkCommissioningClusterRemoveNetworkCommand(seqNum, mEndpoint, networkID, breadcrumb, timeoutMs);
3707     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
3708 #endif
3709 }
3710
3711 CHIP_ERROR NetworkCommissioningCluster::ScanNetworks(Callback::Cancelable * onSuccessCallback,
3712                                                      Callback::Cancelable * onFailureCallback, chip::ByteSpan ssid,
3713                                                      uint64_t breadcrumb, uint32_t timeoutMs)
3714 {
3715 #if CHIP_ENABLE_INTERACTION_MODEL
3716     VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE);
3717     (void) onSuccessCallback;
3718     (void) onFailureCallback;
3719
3720     app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kScanNetworksCommandId,
3721                                               (chip::app::Command::CommandPathFlags::kEndpointIdValid) };
3722     app::Command * ZCLcommand             = mDevice->GetCommandSender();
3723
3724     TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter();
3725
3726     TLV::TLVType dummyType = TLV::kTLVType_NotSpecified;
3727     ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType));
3728
3729     uint8_t argSeqNumber = 0;
3730     // ssid: octetString
3731     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), ssid));
3732     // breadcrumb: int64u
3733     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), breadcrumb));
3734     // timeoutMs: int32u
3735     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), timeoutMs));
3736
3737     ReturnErrorOnFailure(writer.EndContainer(dummyType));
3738     ReturnErrorOnFailure(writer.Finalize());
3739     ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams));
3740
3741     return mDevice->SendCommands();
3742 #else
3743     uint8_t seqNum = mDevice->GetNextSequenceNumber();
3744     System::PacketBufferHandle encodedCommand =
3745         encodeNetworkCommissioningClusterScanNetworksCommand(seqNum, mEndpoint, ssid, breadcrumb, timeoutMs);
3746     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
3747 #endif
3748 }
3749
3750 CHIP_ERROR NetworkCommissioningCluster::UpdateThreadNetwork(Callback::Cancelable * onSuccessCallback,
3751                                                             Callback::Cancelable * onFailureCallback,
3752                                                             chip::ByteSpan operationalDataset, uint64_t breadcrumb,
3753                                                             uint32_t timeoutMs)
3754 {
3755 #if CHIP_ENABLE_INTERACTION_MODEL
3756     VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE);
3757     (void) onSuccessCallback;
3758     (void) onFailureCallback;
3759
3760     app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kUpdateThreadNetworkCommandId,
3761                                               (chip::app::Command::CommandPathFlags::kEndpointIdValid) };
3762     app::Command * ZCLcommand             = mDevice->GetCommandSender();
3763
3764     TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter();
3765
3766     TLV::TLVType dummyType = TLV::kTLVType_NotSpecified;
3767     ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType));
3768
3769     uint8_t argSeqNumber = 0;
3770     // operationalDataset: octetString
3771     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), operationalDataset));
3772     // breadcrumb: int64u
3773     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), breadcrumb));
3774     // timeoutMs: int32u
3775     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), timeoutMs));
3776
3777     ReturnErrorOnFailure(writer.EndContainer(dummyType));
3778     ReturnErrorOnFailure(writer.Finalize());
3779     ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams));
3780
3781     return mDevice->SendCommands();
3782 #else
3783     uint8_t seqNum = mDevice->GetNextSequenceNumber();
3784     System::PacketBufferHandle encodedCommand =
3785         encodeNetworkCommissioningClusterUpdateThreadNetworkCommand(seqNum, mEndpoint, operationalDataset, breadcrumb, timeoutMs);
3786     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
3787 #endif
3788 }
3789
3790 CHIP_ERROR NetworkCommissioningCluster::UpdateWiFiNetwork(Callback::Cancelable * onSuccessCallback,
3791                                                           Callback::Cancelable * onFailureCallback, chip::ByteSpan ssid,
3792                                                           chip::ByteSpan credentials, uint64_t breadcrumb, uint32_t timeoutMs)
3793 {
3794 #if CHIP_ENABLE_INTERACTION_MODEL
3795     VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE);
3796     (void) onSuccessCallback;
3797     (void) onFailureCallback;
3798
3799     app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kUpdateWiFiNetworkCommandId,
3800                                               (chip::app::Command::CommandPathFlags::kEndpointIdValid) };
3801     app::Command * ZCLcommand             = mDevice->GetCommandSender();
3802
3803     TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter();
3804
3805     TLV::TLVType dummyType = TLV::kTLVType_NotSpecified;
3806     ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType));
3807
3808     uint8_t argSeqNumber = 0;
3809     // ssid: octetString
3810     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), ssid));
3811     // credentials: octetString
3812     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), credentials));
3813     // breadcrumb: int64u
3814     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), breadcrumb));
3815     // timeoutMs: int32u
3816     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), timeoutMs));
3817
3818     ReturnErrorOnFailure(writer.EndContainer(dummyType));
3819     ReturnErrorOnFailure(writer.Finalize());
3820     ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams));
3821
3822     return mDevice->SendCommands();
3823 #else
3824     uint8_t seqNum = mDevice->GetNextSequenceNumber();
3825     System::PacketBufferHandle encodedCommand =
3826         encodeNetworkCommissioningClusterUpdateWiFiNetworkCommand(seqNum, mEndpoint, ssid, credentials, breadcrumb, timeoutMs);
3827     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
3828 #endif
3829 }
3830
3831 // NetworkCommissioning Cluster Attributes
3832 CHIP_ERROR NetworkCommissioningCluster::DiscoverAttributes(Callback::Cancelable * onSuccessCallback,
3833                                                            Callback::Cancelable * onFailureCallback)
3834 {
3835     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
3836     System::PacketBufferHandle encodedCommand = encodeNetworkCommissioningClusterDiscoverAttributes(seqNum, mEndpoint);
3837     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
3838 }
3839 CHIP_ERROR NetworkCommissioningCluster::ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback,
3840                                                                      Callback::Cancelable * onFailureCallback)
3841 {
3842     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
3843     System::PacketBufferHandle encodedCommand = encodeNetworkCommissioningClusterReadClusterRevisionAttribute(seqNum, mEndpoint);
3844     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
3845 }
3846
3847 // OnOff Cluster Commands
3848 CHIP_ERROR OnOffCluster::Off(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback)
3849 {
3850 #if CHIP_ENABLE_INTERACTION_MODEL
3851     VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE);
3852     (void) onSuccessCallback;
3853     (void) onFailureCallback;
3854
3855     app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kOffCommandId,
3856                                               (chip::app::Command::CommandPathFlags::kEndpointIdValid) };
3857     app::Command * ZCLcommand             = mDevice->GetCommandSender();
3858
3859     TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter();
3860
3861     TLV::TLVType dummyType = TLV::kTLVType_NotSpecified;
3862     ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType));
3863
3864     // Command takes no arguments.
3865
3866     ReturnErrorOnFailure(writer.EndContainer(dummyType));
3867     ReturnErrorOnFailure(writer.Finalize());
3868     ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams));
3869
3870     return mDevice->SendCommands();
3871 #else
3872     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
3873     System::PacketBufferHandle encodedCommand = encodeOnOffClusterOffCommand(seqNum, mEndpoint);
3874     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
3875 #endif
3876 }
3877
3878 CHIP_ERROR OnOffCluster::On(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback)
3879 {
3880 #if CHIP_ENABLE_INTERACTION_MODEL
3881     VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE);
3882     (void) onSuccessCallback;
3883     (void) onFailureCallback;
3884
3885     app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kOnCommandId,
3886                                               (chip::app::Command::CommandPathFlags::kEndpointIdValid) };
3887     app::Command * ZCLcommand             = mDevice->GetCommandSender();
3888
3889     TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter();
3890
3891     TLV::TLVType dummyType = TLV::kTLVType_NotSpecified;
3892     ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType));
3893
3894     // Command takes no arguments.
3895
3896     ReturnErrorOnFailure(writer.EndContainer(dummyType));
3897     ReturnErrorOnFailure(writer.Finalize());
3898     ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams));
3899
3900     return mDevice->SendCommands();
3901 #else
3902     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
3903     System::PacketBufferHandle encodedCommand = encodeOnOffClusterOnCommand(seqNum, mEndpoint);
3904     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
3905 #endif
3906 }
3907
3908 CHIP_ERROR OnOffCluster::Toggle(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback)
3909 {
3910 #if CHIP_ENABLE_INTERACTION_MODEL
3911     VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE);
3912     (void) onSuccessCallback;
3913     (void) onFailureCallback;
3914
3915     app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kToggleCommandId,
3916                                               (chip::app::Command::CommandPathFlags::kEndpointIdValid) };
3917     app::Command * ZCLcommand             = mDevice->GetCommandSender();
3918
3919     TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter();
3920
3921     TLV::TLVType dummyType = TLV::kTLVType_NotSpecified;
3922     ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType));
3923
3924     // Command takes no arguments.
3925
3926     ReturnErrorOnFailure(writer.EndContainer(dummyType));
3927     ReturnErrorOnFailure(writer.Finalize());
3928     ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams));
3929
3930     return mDevice->SendCommands();
3931 #else
3932     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
3933     System::PacketBufferHandle encodedCommand = encodeOnOffClusterToggleCommand(seqNum, mEndpoint);
3934     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
3935 #endif
3936 }
3937
3938 // OnOff Cluster Attributes
3939 CHIP_ERROR OnOffCluster::DiscoverAttributes(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback)
3940 {
3941     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
3942     System::PacketBufferHandle encodedCommand = encodeOnOffClusterDiscoverAttributes(seqNum, mEndpoint);
3943     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
3944 }
3945 CHIP_ERROR OnOffCluster::ReadAttributeOnOff(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback)
3946 {
3947     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
3948     System::PacketBufferHandle encodedCommand = encodeOnOffClusterReadOnOffAttribute(seqNum, mEndpoint);
3949     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
3950 }
3951
3952 CHIP_ERROR OnOffCluster::ConfigureAttributeOnOff(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback,
3953                                                  uint16_t minInterval, uint16_t maxInterval)
3954 {
3955     uint8_t seqNum = mDevice->GetNextSequenceNumber();
3956     System::PacketBufferHandle encodedCommand =
3957         encodeOnOffClusterConfigureOnOffAttribute(seqNum, mEndpoint, minInterval, maxInterval);
3958     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
3959 }
3960
3961 CHIP_ERROR OnOffCluster::ReportAttributeOnOff(Callback::Cancelable * onReportCallback)
3962 {
3963     return RequestAttributeReporting(0x0000, onReportCallback);
3964 }
3965
3966 CHIP_ERROR OnOffCluster::ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback,
3967                                                       Callback::Cancelable * onFailureCallback)
3968 {
3969     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
3970     System::PacketBufferHandle encodedCommand = encodeOnOffClusterReadClusterRevisionAttribute(seqNum, mEndpoint);
3971     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
3972 }
3973
3974 // Scenes Cluster Commands
3975 CHIP_ERROR ScenesCluster::AddScene(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback,
3976                                    uint16_t groupId, uint8_t sceneId, uint16_t transitionTime, chip::ByteSpan sceneName,
3977                                    chip::ClusterId clusterId, uint8_t length, uint8_t value)
3978 {
3979 #if CHIP_ENABLE_INTERACTION_MODEL
3980     VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE);
3981     (void) onSuccessCallback;
3982     (void) onFailureCallback;
3983
3984     app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kAddSceneCommandId,
3985                                               (chip::app::Command::CommandPathFlags::kEndpointIdValid) };
3986     app::Command * ZCLcommand             = mDevice->GetCommandSender();
3987
3988     TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter();
3989
3990     TLV::TLVType dummyType = TLV::kTLVType_NotSpecified;
3991     ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType));
3992
3993     uint8_t argSeqNumber = 0;
3994     // groupId: int16u
3995     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), groupId));
3996     // sceneId: int8u
3997     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), sceneId));
3998     // transitionTime: int16u
3999     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), transitionTime));
4000     // sceneName: charString
4001     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), sceneName));
4002     // clusterId: clusterId
4003     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), clusterId));
4004     // length: int8u
4005     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), length));
4006     // value: int8u
4007     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), value));
4008
4009     ReturnErrorOnFailure(writer.EndContainer(dummyType));
4010     ReturnErrorOnFailure(writer.Finalize());
4011     ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams));
4012
4013     return mDevice->SendCommands();
4014 #else
4015     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
4016     System::PacketBufferHandle encodedCommand = encodeScenesClusterAddSceneCommand(
4017         seqNum, mEndpoint, groupId, sceneId, transitionTime, sceneName, clusterId, length, value);
4018     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
4019 #endif
4020 }
4021
4022 CHIP_ERROR ScenesCluster::GetSceneMembership(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback,
4023                                              uint16_t groupId)
4024 {
4025 #if CHIP_ENABLE_INTERACTION_MODEL
4026     VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE);
4027     (void) onSuccessCallback;
4028     (void) onFailureCallback;
4029
4030     app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kGetSceneMembershipCommandId,
4031                                               (chip::app::Command::CommandPathFlags::kEndpointIdValid) };
4032     app::Command * ZCLcommand             = mDevice->GetCommandSender();
4033
4034     TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter();
4035
4036     TLV::TLVType dummyType = TLV::kTLVType_NotSpecified;
4037     ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType));
4038
4039     uint8_t argSeqNumber = 0;
4040     // groupId: int16u
4041     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), groupId));
4042
4043     ReturnErrorOnFailure(writer.EndContainer(dummyType));
4044     ReturnErrorOnFailure(writer.Finalize());
4045     ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams));
4046
4047     return mDevice->SendCommands();
4048 #else
4049     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
4050     System::PacketBufferHandle encodedCommand = encodeScenesClusterGetSceneMembershipCommand(seqNum, mEndpoint, groupId);
4051     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
4052 #endif
4053 }
4054
4055 CHIP_ERROR ScenesCluster::RecallScene(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback,
4056                                       uint16_t groupId, uint8_t sceneId, uint16_t transitionTime)
4057 {
4058 #if CHIP_ENABLE_INTERACTION_MODEL
4059     VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE);
4060     (void) onSuccessCallback;
4061     (void) onFailureCallback;
4062
4063     app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kRecallSceneCommandId,
4064                                               (chip::app::Command::CommandPathFlags::kEndpointIdValid) };
4065     app::Command * ZCLcommand             = mDevice->GetCommandSender();
4066
4067     TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter();
4068
4069     TLV::TLVType dummyType = TLV::kTLVType_NotSpecified;
4070     ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType));
4071
4072     uint8_t argSeqNumber = 0;
4073     // groupId: int16u
4074     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), groupId));
4075     // sceneId: int8u
4076     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), sceneId));
4077     // transitionTime: int16u
4078     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), transitionTime));
4079
4080     ReturnErrorOnFailure(writer.EndContainer(dummyType));
4081     ReturnErrorOnFailure(writer.Finalize());
4082     ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams));
4083
4084     return mDevice->SendCommands();
4085 #else
4086     uint8_t seqNum = mDevice->GetNextSequenceNumber();
4087     System::PacketBufferHandle encodedCommand =
4088         encodeScenesClusterRecallSceneCommand(seqNum, mEndpoint, groupId, sceneId, transitionTime);
4089     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
4090 #endif
4091 }
4092
4093 CHIP_ERROR ScenesCluster::RemoveAllScenes(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback,
4094                                           uint16_t groupId)
4095 {
4096 #if CHIP_ENABLE_INTERACTION_MODEL
4097     VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE);
4098     (void) onSuccessCallback;
4099     (void) onFailureCallback;
4100
4101     app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kRemoveAllScenesCommandId,
4102                                               (chip::app::Command::CommandPathFlags::kEndpointIdValid) };
4103     app::Command * ZCLcommand             = mDevice->GetCommandSender();
4104
4105     TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter();
4106
4107     TLV::TLVType dummyType = TLV::kTLVType_NotSpecified;
4108     ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType));
4109
4110     uint8_t argSeqNumber = 0;
4111     // groupId: int16u
4112     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), groupId));
4113
4114     ReturnErrorOnFailure(writer.EndContainer(dummyType));
4115     ReturnErrorOnFailure(writer.Finalize());
4116     ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams));
4117
4118     return mDevice->SendCommands();
4119 #else
4120     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
4121     System::PacketBufferHandle encodedCommand = encodeScenesClusterRemoveAllScenesCommand(seqNum, mEndpoint, groupId);
4122     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
4123 #endif
4124 }
4125
4126 CHIP_ERROR ScenesCluster::RemoveScene(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback,
4127                                       uint16_t groupId, uint8_t sceneId)
4128 {
4129 #if CHIP_ENABLE_INTERACTION_MODEL
4130     VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE);
4131     (void) onSuccessCallback;
4132     (void) onFailureCallback;
4133
4134     app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kRemoveSceneCommandId,
4135                                               (chip::app::Command::CommandPathFlags::kEndpointIdValid) };
4136     app::Command * ZCLcommand             = mDevice->GetCommandSender();
4137
4138     TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter();
4139
4140     TLV::TLVType dummyType = TLV::kTLVType_NotSpecified;
4141     ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType));
4142
4143     uint8_t argSeqNumber = 0;
4144     // groupId: int16u
4145     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), groupId));
4146     // sceneId: int8u
4147     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), sceneId));
4148
4149     ReturnErrorOnFailure(writer.EndContainer(dummyType));
4150     ReturnErrorOnFailure(writer.Finalize());
4151     ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams));
4152
4153     return mDevice->SendCommands();
4154 #else
4155     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
4156     System::PacketBufferHandle encodedCommand = encodeScenesClusterRemoveSceneCommand(seqNum, mEndpoint, groupId, sceneId);
4157     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
4158 #endif
4159 }
4160
4161 CHIP_ERROR ScenesCluster::StoreScene(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback,
4162                                      uint16_t groupId, uint8_t sceneId)
4163 {
4164 #if CHIP_ENABLE_INTERACTION_MODEL
4165     VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE);
4166     (void) onSuccessCallback;
4167     (void) onFailureCallback;
4168
4169     app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kStoreSceneCommandId,
4170                                               (chip::app::Command::CommandPathFlags::kEndpointIdValid) };
4171     app::Command * ZCLcommand             = mDevice->GetCommandSender();
4172
4173     TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter();
4174
4175     TLV::TLVType dummyType = TLV::kTLVType_NotSpecified;
4176     ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType));
4177
4178     uint8_t argSeqNumber = 0;
4179     // groupId: int16u
4180     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), groupId));
4181     // sceneId: int8u
4182     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), sceneId));
4183
4184     ReturnErrorOnFailure(writer.EndContainer(dummyType));
4185     ReturnErrorOnFailure(writer.Finalize());
4186     ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams));
4187
4188     return mDevice->SendCommands();
4189 #else
4190     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
4191     System::PacketBufferHandle encodedCommand = encodeScenesClusterStoreSceneCommand(seqNum, mEndpoint, groupId, sceneId);
4192     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
4193 #endif
4194 }
4195
4196 CHIP_ERROR ScenesCluster::ViewScene(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback,
4197                                     uint16_t groupId, uint8_t sceneId)
4198 {
4199 #if CHIP_ENABLE_INTERACTION_MODEL
4200     VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE);
4201     (void) onSuccessCallback;
4202     (void) onFailureCallback;
4203
4204     app::Command::CommandParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, kViewSceneCommandId,
4205                                               (chip::app::Command::CommandPathFlags::kEndpointIdValid) };
4206     app::Command * ZCLcommand             = mDevice->GetCommandSender();
4207
4208     TLV::TLVWriter writer = ZCLcommand->CreateCommandDataElementTLVWriter();
4209
4210     TLV::TLVType dummyType = TLV::kTLVType_NotSpecified;
4211     ReturnErrorOnFailure(writer.StartContainer(TLV::AnonymousTag, TLV::kTLVType_Structure, dummyType));
4212
4213     uint8_t argSeqNumber = 0;
4214     // groupId: int16u
4215     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), groupId));
4216     // sceneId: int8u
4217     ReturnErrorOnFailure(writer.Put(TLV::ContextTag(argSeqNumber++), sceneId));
4218
4219     ReturnErrorOnFailure(writer.EndContainer(dummyType));
4220     ReturnErrorOnFailure(writer.Finalize());
4221     ReturnErrorOnFailure(ZCLcommand->AddCommand(cmdParams));
4222
4223     return mDevice->SendCommands();
4224 #else
4225     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
4226     System::PacketBufferHandle encodedCommand = encodeScenesClusterViewSceneCommand(seqNum, mEndpoint, groupId, sceneId);
4227     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
4228 #endif
4229 }
4230
4231 // Scenes Cluster Attributes
4232 CHIP_ERROR ScenesCluster::DiscoverAttributes(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback)
4233 {
4234     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
4235     System::PacketBufferHandle encodedCommand = encodeScenesClusterDiscoverAttributes(seqNum, mEndpoint);
4236     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
4237 }
4238 CHIP_ERROR ScenesCluster::ReadAttributeSceneCount(Callback::Cancelable * onSuccessCallback,
4239                                                   Callback::Cancelable * onFailureCallback)
4240 {
4241     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
4242     System::PacketBufferHandle encodedCommand = encodeScenesClusterReadSceneCountAttribute(seqNum, mEndpoint);
4243     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
4244 }
4245
4246 CHIP_ERROR ScenesCluster::ReadAttributeCurrentScene(Callback::Cancelable * onSuccessCallback,
4247                                                     Callback::Cancelable * onFailureCallback)
4248 {
4249     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
4250     System::PacketBufferHandle encodedCommand = encodeScenesClusterReadCurrentSceneAttribute(seqNum, mEndpoint);
4251     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
4252 }
4253
4254 CHIP_ERROR ScenesCluster::ReadAttributeCurrentGroup(Callback::Cancelable * onSuccessCallback,
4255                                                     Callback::Cancelable * onFailureCallback)
4256 {
4257     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
4258     System::PacketBufferHandle encodedCommand = encodeScenesClusterReadCurrentGroupAttribute(seqNum, mEndpoint);
4259     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
4260 }
4261
4262 CHIP_ERROR ScenesCluster::ReadAttributeSceneValid(Callback::Cancelable * onSuccessCallback,
4263                                                   Callback::Cancelable * onFailureCallback)
4264 {
4265     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
4266     System::PacketBufferHandle encodedCommand = encodeScenesClusterReadSceneValidAttribute(seqNum, mEndpoint);
4267     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
4268 }
4269
4270 CHIP_ERROR ScenesCluster::ReadAttributeNameSupport(Callback::Cancelable * onSuccessCallback,
4271                                                    Callback::Cancelable * onFailureCallback)
4272 {
4273     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
4274     System::PacketBufferHandle encodedCommand = encodeScenesClusterReadNameSupportAttribute(seqNum, mEndpoint);
4275     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
4276 }
4277
4278 CHIP_ERROR ScenesCluster::ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback,
4279                                                        Callback::Cancelable * onFailureCallback)
4280 {
4281     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
4282     System::PacketBufferHandle encodedCommand = encodeScenesClusterReadClusterRevisionAttribute(seqNum, mEndpoint);
4283     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
4284 }
4285
4286 // TemperatureMeasurement Cluster Commands
4287 // TemperatureMeasurement Cluster Attributes
4288 CHIP_ERROR TemperatureMeasurementCluster::DiscoverAttributes(Callback::Cancelable * onSuccessCallback,
4289                                                              Callback::Cancelable * onFailureCallback)
4290 {
4291     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
4292     System::PacketBufferHandle encodedCommand = encodeTemperatureMeasurementClusterDiscoverAttributes(seqNum, mEndpoint);
4293     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
4294 }
4295 CHIP_ERROR TemperatureMeasurementCluster::ReadAttributeMeasuredValue(Callback::Cancelable * onSuccessCallback,
4296                                                                      Callback::Cancelable * onFailureCallback)
4297 {
4298     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
4299     System::PacketBufferHandle encodedCommand = encodeTemperatureMeasurementClusterReadMeasuredValueAttribute(seqNum, mEndpoint);
4300     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
4301 }
4302
4303 CHIP_ERROR TemperatureMeasurementCluster::ConfigureAttributeMeasuredValue(Callback::Cancelable * onSuccessCallback,
4304                                                                           Callback::Cancelable * onFailureCallback,
4305                                                                           uint16_t minInterval, uint16_t maxInterval,
4306                                                                           int16_t change)
4307 {
4308     uint8_t seqNum = mDevice->GetNextSequenceNumber();
4309     System::PacketBufferHandle encodedCommand =
4310         encodeTemperatureMeasurementClusterConfigureMeasuredValueAttribute(seqNum, mEndpoint, minInterval, maxInterval, change);
4311     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
4312 }
4313
4314 CHIP_ERROR TemperatureMeasurementCluster::ReportAttributeMeasuredValue(Callback::Cancelable * onReportCallback)
4315 {
4316     return RequestAttributeReporting(0x0000, onReportCallback);
4317 }
4318
4319 CHIP_ERROR TemperatureMeasurementCluster::ReadAttributeMinMeasuredValue(Callback::Cancelable * onSuccessCallback,
4320                                                                         Callback::Cancelable * onFailureCallback)
4321 {
4322     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
4323     System::PacketBufferHandle encodedCommand = encodeTemperatureMeasurementClusterReadMinMeasuredValueAttribute(seqNum, mEndpoint);
4324     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
4325 }
4326
4327 CHIP_ERROR TemperatureMeasurementCluster::ReadAttributeMaxMeasuredValue(Callback::Cancelable * onSuccessCallback,
4328                                                                         Callback::Cancelable * onFailureCallback)
4329 {
4330     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
4331     System::PacketBufferHandle encodedCommand = encodeTemperatureMeasurementClusterReadMaxMeasuredValueAttribute(seqNum, mEndpoint);
4332     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
4333 }
4334
4335 CHIP_ERROR TemperatureMeasurementCluster::ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback,
4336                                                                        Callback::Cancelable * onFailureCallback)
4337 {
4338     uint8_t seqNum                            = mDevice->GetNextSequenceNumber();
4339     System::PacketBufferHandle encodedCommand = encodeTemperatureMeasurementClusterReadClusterRevisionAttribute(seqNum, mEndpoint);
4340     return SendCommand(seqNum, std::move(encodedCommand), onSuccessCallback, onFailureCallback);
4341 }
4342
4343 } // namespace Controller
4344 } // namespace chip