examples/bridge-app/bridge-common/gen/CHIPClustersObjc.mm

   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
  20 #import <Foundation/Foundation.h>
  21
  22 #import "CHIPDevice.h"
  23 #import "CHIPDevice_Internal.h"
  24 #import "ChipError.h"
  25 #import "gen/CHIPClientCallbacks.h"
  26 #import "gen/CHIPClustersObjc.h"
  27
  28 #include <controller/CHIPClusters.h>
  29 #include <lib/support/Span.h>
  30
  31 using namespace ::chip;
  32
  33 class CHIPDefaultSuccessCallbackBridge : public Callback::Callback<DefaultSuccessCallback> {
  34 public:
  35     CHIPDefaultSuccessCallbackBridge(ResponseHandler handler, dispatch_queue_t queue)
  36         : Callback::Callback<DefaultSuccessCallback>(CallbackFn, this)
  37         , mHandler(handler)
  38         , mQueue(queue)
  39     {
  40     }
  41
  42     ~CHIPDefaultSuccessCallbackBridge() {};
  43
  44     static void CallbackFn(void * context)
  45     {
  46         CHIPDefaultSuccessCallbackBridge * callback = reinterpret_cast<CHIPDefaultSuccessCallbackBridge *>(context);
  47         if (callback && callback->mQueue) {
  48             dispatch_async(callback->mQueue, ^{
  49                 callback->mHandler(nil, nil);
  50                 callback->Cancel();
  51                 delete callback;
  52             });
  53         }
  54     };
  55
  56 private:
  57     ResponseHandler mHandler;
  58     dispatch_queue_t mQueue;
  59 };
  60
  61 class CHIPDefaultFailureCallbackBridge : public Callback::Callback<DefaultFailureCallback> {
  62 public:
  63     CHIPDefaultFailureCallbackBridge(ResponseHandler handler, dispatch_queue_t queue)
  64         : Callback::Callback<DefaultFailureCallback>(CallbackFn, this)
  65         , mHandler(handler)
  66         , mQueue(queue)
  67     {
  68     }
  69
  70     ~CHIPDefaultFailureCallbackBridge() {};
  71
  72     static void CallbackFn(void * context, uint8_t status)
  73     {
  74         CHIPDefaultFailureCallbackBridge * callback = reinterpret_cast<CHIPDefaultFailureCallbackBridge *>(context);
  75         if (callback && callback->mQueue) {
  76             dispatch_async(callback->mQueue, ^{
  77                 NSError * error = [NSError errorWithDomain:CHIPErrorDomain
  78                                                       code:status
  79                                                   userInfo:@ { NSLocalizedDescriptionKey : @"" }];
  80                 callback->mHandler(error, nil);
  81                 callback->Cancel();
  82                 delete callback;
  83             });
  84         }
  85     };
  86
  87 private:
  88     ResponseHandler mHandler;
  89     dispatch_queue_t mQueue;
  90 };
  91
  92 class CHIPUnsupportedAttributeCallbackBridge : public Callback::Callback<DefaultSuccessCallback> {
  93 public:
  94     CHIPUnsupportedAttributeCallbackBridge(ResponseHandler handler, dispatch_queue_t queue)
  95         : Callback::Callback<DefaultSuccessCallback>(CallbackFn, this)
  96     {
  97     }
  98
  99     ~CHIPUnsupportedAttributeCallbackBridge() {};
 100
 101     static void CallbackFn(void * context)
 102     {
 103         CHIPUnsupportedAttributeCallbackBridge * callback = reinterpret_cast<CHIPUnsupportedAttributeCallbackBridge *>(context);
 104         if (callback && callback->mQueue) {
 105             dispatch_async(callback->mQueue, ^{
 106                 NSError * error = [NSError errorWithDomain:CHIPErrorDomain
 107                                                       code:CHIPErrorCodeUndefinedError
 108                                                   userInfo:@ { NSLocalizedDescriptionKey : @"Unsupported attribute type" }];
 109                 callback->mHandler(error, nil);
 110                 callback->Cancel();
 111                 delete callback;
 112             });
 113         }
 114     };
 115
 116 private:
 117     ResponseHandler mHandler;
 118     dispatch_queue_t mQueue;
 119 };
 120
 121 class CHIPBooleanAttributeCallbackBridge : public Callback::Callback<BooleanAttributeCallback> {
 122 public:
 123     CHIPBooleanAttributeCallbackBridge(ResponseHandler handler, dispatch_queue_t queue, bool keepAlive = false)
 124         : Callback::Callback<BooleanAttributeCallback>(CallbackFn, this)
 125         , mHandler(handler)
 126         , mQueue(queue)
 127         , mKeepAlive(keepAlive)
 128     {
 129     }
 130
 131     ~CHIPBooleanAttributeCallbackBridge() {};
 132
 133     static void CallbackFn(void * context, bool value)
 134     {
 135         CHIPBooleanAttributeCallbackBridge * callback = reinterpret_cast<CHIPBooleanAttributeCallbackBridge *>(context);
 136         if (callback && callback->mQueue) {
 137             dispatch_async(callback->mQueue, ^{
 138                 callback->mHandler(nil, @ { @"value" : [NSNumber numberWithBool:value] });
 139                 if (!callback->mKeepAlive) {
 140                     callback->Cancel();
 141                     delete callback;
 142                 }
 143             });
 144         }
 145     };
 146
 147 private:
 148     ResponseHandler mHandler;
 149     dispatch_queue_t mQueue;
 150     bool mKeepAlive;
 151 };
 152
 153 class CHIPInt8uAttributeCallbackBridge : public Callback::Callback<Int8uAttributeCallback> {
 154 public:
 155     CHIPInt8uAttributeCallbackBridge(ResponseHandler handler, dispatch_queue_t queue, bool keepAlive = false)
 156         : Callback::Callback<Int8uAttributeCallback>(CallbackFn, this)
 157         , mHandler(handler)
 158         , mQueue(queue)
 159         , mKeepAlive(keepAlive)
 160     {
 161     }
 162
 163     ~CHIPInt8uAttributeCallbackBridge() {};
 164
 165     static void CallbackFn(void * context, uint8_t value)
 166     {
 167         CHIPInt8uAttributeCallbackBridge * callback = reinterpret_cast<CHIPInt8uAttributeCallbackBridge *>(context);
 168         if (callback && callback->mQueue) {
 169             dispatch_async(callback->mQueue, ^{
 170                 callback->mHandler(nil, @ { @"value" : [NSNumber numberWithUnsignedChar:value] });
 171                 if (!callback->mKeepAlive) {
 172                     callback->Cancel();
 173                     delete callback;
 174                 }
 175             });
 176         }
 177     };
 178
 179 private:
 180     ResponseHandler mHandler;
 181     dispatch_queue_t mQueue;
 182     bool mKeepAlive;
 183 };
 184
 185 class CHIPInt8sAttributeCallbackBridge : public Callback::Callback<Int8sAttributeCallback> {
 186 public:
 187     CHIPInt8sAttributeCallbackBridge(ResponseHandler handler, dispatch_queue_t queue, bool keepAlive = false)
 188         : Callback::Callback<Int8sAttributeCallback>(CallbackFn, this)
 189         , mHandler(handler)
 190         , mQueue(queue)
 191         , mKeepAlive(keepAlive)
 192     {
 193     }
 194
 195     ~CHIPInt8sAttributeCallbackBridge() {};
 196
 197     static void CallbackFn(void * context, int8_t value)
 198     {
 199         CHIPInt8sAttributeCallbackBridge * callback = reinterpret_cast<CHIPInt8sAttributeCallbackBridge *>(context);
 200         if (callback && callback->mQueue) {
 201             dispatch_async(callback->mQueue, ^{
 202                 callback->mHandler(nil, @ { @"value" : [NSNumber numberWithChar:value] });
 203                 if (!callback->mKeepAlive) {
 204                     callback->Cancel();
 205                     delete callback;
 206                 }
 207             });
 208         }
 209     };
 210
 211 private:
 212     ResponseHandler mHandler;
 213     dispatch_queue_t mQueue;
 214     bool mKeepAlive;
 215 };
 216
 217 class CHIPInt16uAttributeCallbackBridge : public Callback::Callback<Int16uAttributeCallback> {
 218 public:
 219     CHIPInt16uAttributeCallbackBridge(ResponseHandler handler, dispatch_queue_t queue, bool keepAlive = false)
 220         : Callback::Callback<Int16uAttributeCallback>(CallbackFn, this)
 221         , mHandler(handler)
 222         , mQueue(queue)
 223         , mKeepAlive(keepAlive)
 224     {
 225     }
 226
 227     ~CHIPInt16uAttributeCallbackBridge() {};
 228
 229     static void CallbackFn(void * context, uint16_t value)
 230     {
 231         CHIPInt16uAttributeCallbackBridge * callback = reinterpret_cast<CHIPInt16uAttributeCallbackBridge *>(context);
 232         if (callback && callback->mQueue) {
 233             dispatch_async(callback->mQueue, ^{
 234                 callback->mHandler(nil, @ { @"value" : [NSNumber numberWithUnsignedShort:value] });
 235                 if (!callback->mKeepAlive) {
 236                     callback->Cancel();
 237                     delete callback;
 238                 }
 239             });
 240         }
 241     };
 242
 243 private:
 244     ResponseHandler mHandler;
 245     dispatch_queue_t mQueue;
 246     bool mKeepAlive;
 247 };
 248
 249 class CHIPInt16sAttributeCallbackBridge : public Callback::Callback<Int16sAttributeCallback> {
 250 public:
 251     CHIPInt16sAttributeCallbackBridge(ResponseHandler handler, dispatch_queue_t queue, bool keepAlive = false)
 252         : Callback::Callback<Int16sAttributeCallback>(CallbackFn, this)
 253         , mHandler(handler)
 254         , mQueue(queue)
 255         , mKeepAlive(keepAlive)
 256     {
 257     }
 258
 259     ~CHIPInt16sAttributeCallbackBridge() {};
 260
 261     static void CallbackFn(void * context, int16_t value)
 262     {
 263         CHIPInt16sAttributeCallbackBridge * callback = reinterpret_cast<CHIPInt16sAttributeCallbackBridge *>(context);
 264         if (callback && callback->mQueue) {
 265             dispatch_async(callback->mQueue, ^{
 266                 callback->mHandler(nil, @ { @"value" : [NSNumber numberWithShort:value] });
 267                 if (!callback->mKeepAlive) {
 268                     callback->Cancel();
 269                     delete callback;
 270                 }
 271             });
 272         }
 273     };
 274
 275 private:
 276     ResponseHandler mHandler;
 277     dispatch_queue_t mQueue;
 278     bool mKeepAlive;
 279 };
 280
 281 @interface CHIPCluster ()
 282 @property (readonly, nonatomic) dispatch_queue_t callbackQueue;
 283 - (Controller::ClusterBase *)getCluster;
 284 @end
 285
 286 @implementation CHIPCluster
 287 - (instancetype)initWithDevice:(CHIPDevice *)device endpoint:(EndpointId)endpoint queue:(dispatch_queue_t)queue
 288 {
 289     if (self = [super init]) {
 290         Controller::ClusterBase * cppCluster = [self getCluster];
 291         if (cppCluster == nullptr) {
 292             return nil;
 293         }
 294
 295         CHIP_ERROR err = cppCluster->Associate([device internalDevice], endpoint);
 296         if (err != CHIP_NO_ERROR) {
 297             return nil;
 298         }
 299
 300         _callbackQueue = queue;
 301     }
 302     return self;
 303 }
 304
 305 - (Controller::ClusterBase *)getCluster
 306 {
 307     return nullptr;
 308 }
 309 @end
 310
 311 @interface CHIPBasic ()
 312 @property (readonly) Controller::BasicCluster cppCluster;
 313 @end
 314
 315 @implementation CHIPBasic
 316
 317 - (Controller::ClusterBase *)getCluster
 318 {
 319     return &_cppCluster;
 320 }
 321
 322 - (void)resetToFactoryDefaults:(ResponseHandler)completionHandler
 323 {
 324     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
 325     if (!onSuccess) {
 326         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 327         return;
 328     }
 329
 330     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
 331     if (!onFailure) {
 332         delete onSuccess;
 333         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 334         return;
 335     }
 336
 337     CHIP_ERROR err = self.cppCluster.ResetToFactoryDefaults(onSuccess->Cancel(), onFailure->Cancel());
 338     if (err != CHIP_NO_ERROR) {
 339         delete onSuccess;
 340         delete onFailure;
 341         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
 342     }
 343 }
 344
 345 - (void)readAttributeZclVersion:(ResponseHandler)completionHandler
 346 {
 347     CHIPInt8uAttributeCallbackBridge * onSuccess = new CHIPInt8uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
 348     if (!onSuccess) {
 349         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 350         return;
 351     }
 352
 353     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
 354     if (!onFailure) {
 355         delete onSuccess;
 356         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 357         return;
 358     }
 359
 360     CHIP_ERROR err = self.cppCluster.ReadAttributeZclVersion(onSuccess->Cancel(), onFailure->Cancel());
 361     if (err != CHIP_NO_ERROR) {
 362         delete onSuccess;
 363         delete onFailure;
 364         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
 365     }
 366 }
 367
 368 - (void)readAttributeApplicationVersion:(ResponseHandler)completionHandler
 369 {
 370     CHIPInt8uAttributeCallbackBridge * onSuccess = new CHIPInt8uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
 371     if (!onSuccess) {
 372         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 373         return;
 374     }
 375
 376     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
 377     if (!onFailure) {
 378         delete onSuccess;
 379         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 380         return;
 381     }
 382
 383     CHIP_ERROR err = self.cppCluster.ReadAttributeApplicationVersion(onSuccess->Cancel(), onFailure->Cancel());
 384     if (err != CHIP_NO_ERROR) {
 385         delete onSuccess;
 386         delete onFailure;
 387         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
 388     }
 389 }
 390
 391 - (void)readAttributeStackVersion:(ResponseHandler)completionHandler
 392 {
 393     CHIPInt8uAttributeCallbackBridge * onSuccess = new CHIPInt8uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
 394     if (!onSuccess) {
 395         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 396         return;
 397     }
 398
 399     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
 400     if (!onFailure) {
 401         delete onSuccess;
 402         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 403         return;
 404     }
 405
 406     CHIP_ERROR err = self.cppCluster.ReadAttributeStackVersion(onSuccess->Cancel(), onFailure->Cancel());
 407     if (err != CHIP_NO_ERROR) {
 408         delete onSuccess;
 409         delete onFailure;
 410         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
 411     }
 412 }
 413
 414 - (void)readAttributeHardwareVersion:(ResponseHandler)completionHandler
 415 {
 416     CHIPInt8uAttributeCallbackBridge * onSuccess = new CHIPInt8uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
 417     if (!onSuccess) {
 418         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 419         return;
 420     }
 421
 422     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
 423     if (!onFailure) {
 424         delete onSuccess;
 425         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 426         return;
 427     }
 428
 429     CHIP_ERROR err = self.cppCluster.ReadAttributeHardwareVersion(onSuccess->Cancel(), onFailure->Cancel());
 430     if (err != CHIP_NO_ERROR) {
 431         delete onSuccess;
 432         delete onFailure;
 433         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
 434     }
 435 }
 436
 437 - (void)readAttributeManufacturerName:(ResponseHandler)completionHandler
 438 {
 439     CHIPUnsupportedAttributeCallbackBridge * onSuccess
 440         = new CHIPUnsupportedAttributeCallbackBridge(completionHandler, [self callbackQueue]);
 441     if (!onSuccess) {
 442         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 443         return;
 444     }
 445
 446     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
 447     if (!onFailure) {
 448         delete onSuccess;
 449         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 450         return;
 451     }
 452
 453     CHIP_ERROR err = self.cppCluster.ReadAttributeManufacturerName(onSuccess->Cancel(), onFailure->Cancel());
 454     if (err != CHIP_NO_ERROR) {
 455         delete onSuccess;
 456         delete onFailure;
 457         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
 458     }
 459 }
 460
 461 - (void)readAttributeModelIdentifier:(ResponseHandler)completionHandler
 462 {
 463     CHIPUnsupportedAttributeCallbackBridge * onSuccess
 464         = new CHIPUnsupportedAttributeCallbackBridge(completionHandler, [self callbackQueue]);
 465     if (!onSuccess) {
 466         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 467         return;
 468     }
 469
 470     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
 471     if (!onFailure) {
 472         delete onSuccess;
 473         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 474         return;
 475     }
 476
 477     CHIP_ERROR err = self.cppCluster.ReadAttributeModelIdentifier(onSuccess->Cancel(), onFailure->Cancel());
 478     if (err != CHIP_NO_ERROR) {
 479         delete onSuccess;
 480         delete onFailure;
 481         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
 482     }
 483 }
 484
 485 - (void)readAttributeDateCode:(ResponseHandler)completionHandler
 486 {
 487     CHIPUnsupportedAttributeCallbackBridge * onSuccess
 488         = new CHIPUnsupportedAttributeCallbackBridge(completionHandler, [self callbackQueue]);
 489     if (!onSuccess) {
 490         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 491         return;
 492     }
 493
 494     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
 495     if (!onFailure) {
 496         delete onSuccess;
 497         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 498         return;
 499     }
 500
 501     CHIP_ERROR err = self.cppCluster.ReadAttributeDateCode(onSuccess->Cancel(), onFailure->Cancel());
 502     if (err != CHIP_NO_ERROR) {
 503         delete onSuccess;
 504         delete onFailure;
 505         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
 506     }
 507 }
 508
 509 - (void)readAttributePowerSource:(ResponseHandler)completionHandler
 510 {
 511     CHIPInt8uAttributeCallbackBridge * onSuccess = new CHIPInt8uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
 512     if (!onSuccess) {
 513         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 514         return;
 515     }
 516
 517     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
 518     if (!onFailure) {
 519         delete onSuccess;
 520         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 521         return;
 522     }
 523
 524     CHIP_ERROR err = self.cppCluster.ReadAttributePowerSource(onSuccess->Cancel(), onFailure->Cancel());
 525     if (err != CHIP_NO_ERROR) {
 526         delete onSuccess;
 527         delete onFailure;
 528         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
 529     }
 530 }
 531
 532 - (void)readAttributeGenericDeviceClass:(ResponseHandler)completionHandler
 533 {
 534     CHIPInt8uAttributeCallbackBridge * onSuccess = new CHIPInt8uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
 535     if (!onSuccess) {
 536         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 537         return;
 538     }
 539
 540     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
 541     if (!onFailure) {
 542         delete onSuccess;
 543         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 544         return;
 545     }
 546
 547     CHIP_ERROR err = self.cppCluster.ReadAttributeGenericDeviceClass(onSuccess->Cancel(), onFailure->Cancel());
 548     if (err != CHIP_NO_ERROR) {
 549         delete onSuccess;
 550         delete onFailure;
 551         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
 552     }
 553 }
 554
 555 - (void)readAttributeGenericDeviceType:(ResponseHandler)completionHandler
 556 {
 557     CHIPInt8uAttributeCallbackBridge * onSuccess = new CHIPInt8uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
 558     if (!onSuccess) {
 559         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 560         return;
 561     }
 562
 563     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
 564     if (!onFailure) {
 565         delete onSuccess;
 566         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 567         return;
 568     }
 569
 570     CHIP_ERROR err = self.cppCluster.ReadAttributeGenericDeviceType(onSuccess->Cancel(), onFailure->Cancel());
 571     if (err != CHIP_NO_ERROR) {
 572         delete onSuccess;
 573         delete onFailure;
 574         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
 575     }
 576 }
 577
 578 - (void)readAttributeProductCode:(ResponseHandler)completionHandler
 579 {
 580     CHIPUnsupportedAttributeCallbackBridge * onSuccess
 581         = new CHIPUnsupportedAttributeCallbackBridge(completionHandler, [self callbackQueue]);
 582     if (!onSuccess) {
 583         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 584         return;
 585     }
 586
 587     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
 588     if (!onFailure) {
 589         delete onSuccess;
 590         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 591         return;
 592     }
 593
 594     CHIP_ERROR err = self.cppCluster.ReadAttributeProductCode(onSuccess->Cancel(), onFailure->Cancel());
 595     if (err != CHIP_NO_ERROR) {
 596         delete onSuccess;
 597         delete onFailure;
 598         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
 599     }
 600 }
 601
 602 - (void)readAttributeProductUrl:(ResponseHandler)completionHandler
 603 {
 604     CHIPUnsupportedAttributeCallbackBridge * onSuccess
 605         = new CHIPUnsupportedAttributeCallbackBridge(completionHandler, [self callbackQueue]);
 606     if (!onSuccess) {
 607         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 608         return;
 609     }
 610
 611     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
 612     if (!onFailure) {
 613         delete onSuccess;
 614         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 615         return;
 616     }
 617
 618     CHIP_ERROR err = self.cppCluster.ReadAttributeProductUrl(onSuccess->Cancel(), onFailure->Cancel());
 619     if (err != CHIP_NO_ERROR) {
 620         delete onSuccess;
 621         delete onFailure;
 622         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
 623     }
 624 }
 625
 626 - (void)readAttributeSwBuildId:(ResponseHandler)completionHandler
 627 {
 628     CHIPUnsupportedAttributeCallbackBridge * onSuccess
 629         = new CHIPUnsupportedAttributeCallbackBridge(completionHandler, [self callbackQueue]);
 630     if (!onSuccess) {
 631         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 632         return;
 633     }
 634
 635     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
 636     if (!onFailure) {
 637         delete onSuccess;
 638         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 639         return;
 640     }
 641
 642     CHIP_ERROR err = self.cppCluster.ReadAttributeSwBuildId(onSuccess->Cancel(), onFailure->Cancel());
 643     if (err != CHIP_NO_ERROR) {
 644         delete onSuccess;
 645         delete onFailure;
 646         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
 647     }
 648 }
 649
 650 - (void)readAttributeClusterRevision:(ResponseHandler)completionHandler
 651 {
 652     CHIPInt16uAttributeCallbackBridge * onSuccess = new CHIPInt16uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
 653     if (!onSuccess) {
 654         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 655         return;
 656     }
 657
 658     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
 659     if (!onFailure) {
 660         delete onSuccess;
 661         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 662         return;
 663     }
 664
 665     CHIP_ERROR err = self.cppCluster.ReadAttributeClusterRevision(onSuccess->Cancel(), onFailure->Cancel());
 666     if (err != CHIP_NO_ERROR) {
 667         delete onSuccess;
 668         delete onFailure;
 669         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
 670     }
 671 }
 672
 673 @end
 674
 675 @interface CHIPLevelControl ()
 676 @property (readonly) Controller::LevelControlCluster cppCluster;
 677 @end
 678
 679 @implementation CHIPLevelControl
 680
 681 - (Controller::ClusterBase *)getCluster
 682 {
 683     return &_cppCluster;
 684 }
 685
 686 - (void)move:(uint8_t)moveMode
 687                  rate:(uint8_t)rate
 688            optionMask:(uint8_t)optionMask
 689        optionOverride:(uint8_t)optionOverride
 690     completionHandler:(ResponseHandler)completionHandler
 691 {
 692     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
 693     if (!onSuccess) {
 694         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 695         return;
 696     }
 697
 698     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
 699     if (!onFailure) {
 700         delete onSuccess;
 701         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 702         return;
 703     }
 704
 705     CHIP_ERROR err = self.cppCluster.Move(onSuccess->Cancel(), onFailure->Cancel(), moveMode, rate, optionMask, optionOverride);
 706     if (err != CHIP_NO_ERROR) {
 707         delete onSuccess;
 708         delete onFailure;
 709         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
 710     }
 711 }
 712 - (void)moveToLevel:(uint8_t)level
 713        transitionTime:(uint16_t)transitionTime
 714            optionMask:(uint8_t)optionMask
 715        optionOverride:(uint8_t)optionOverride
 716     completionHandler:(ResponseHandler)completionHandler
 717 {
 718     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
 719     if (!onSuccess) {
 720         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 721         return;
 722     }
 723
 724     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
 725     if (!onFailure) {
 726         delete onSuccess;
 727         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 728         return;
 729     }
 730
 731     CHIP_ERROR err
 732         = self.cppCluster.MoveToLevel(onSuccess->Cancel(), onFailure->Cancel(), level, transitionTime, optionMask, optionOverride);
 733     if (err != CHIP_NO_ERROR) {
 734         delete onSuccess;
 735         delete onFailure;
 736         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
 737     }
 738 }
 739 - (void)moveToLevelWithOnOff:(uint8_t)level
 740               transitionTime:(uint16_t)transitionTime
 741            completionHandler:(ResponseHandler)completionHandler
 742 {
 743     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
 744     if (!onSuccess) {
 745         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 746         return;
 747     }
 748
 749     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
 750     if (!onFailure) {
 751         delete onSuccess;
 752         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 753         return;
 754     }
 755
 756     CHIP_ERROR err = self.cppCluster.MoveToLevelWithOnOff(onSuccess->Cancel(), onFailure->Cancel(), level, transitionTime);
 757     if (err != CHIP_NO_ERROR) {
 758         delete onSuccess;
 759         delete onFailure;
 760         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
 761     }
 762 }
 763 - (void)moveWithOnOff:(uint8_t)moveMode rate:(uint8_t)rate completionHandler:(ResponseHandler)completionHandler
 764 {
 765     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
 766     if (!onSuccess) {
 767         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 768         return;
 769     }
 770
 771     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
 772     if (!onFailure) {
 773         delete onSuccess;
 774         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 775         return;
 776     }
 777
 778     CHIP_ERROR err = self.cppCluster.MoveWithOnOff(onSuccess->Cancel(), onFailure->Cancel(), moveMode, rate);
 779     if (err != CHIP_NO_ERROR) {
 780         delete onSuccess;
 781         delete onFailure;
 782         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
 783     }
 784 }
 785 - (void)step:(uint8_t)stepMode
 786              stepSize:(uint8_t)stepSize
 787        transitionTime:(uint16_t)transitionTime
 788            optionMask:(uint8_t)optionMask
 789        optionOverride:(uint8_t)optionOverride
 790     completionHandler:(ResponseHandler)completionHandler
 791 {
 792     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
 793     if (!onSuccess) {
 794         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 795         return;
 796     }
 797
 798     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
 799     if (!onFailure) {
 800         delete onSuccess;
 801         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 802         return;
 803     }
 804
 805     CHIP_ERROR err = self.cppCluster.Step(
 806         onSuccess->Cancel(), onFailure->Cancel(), stepMode, stepSize, transitionTime, optionMask, optionOverride);
 807     if (err != CHIP_NO_ERROR) {
 808         delete onSuccess;
 809         delete onFailure;
 810         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
 811     }
 812 }
 813 - (void)stepWithOnOff:(uint8_t)stepMode
 814              stepSize:(uint8_t)stepSize
 815        transitionTime:(uint16_t)transitionTime
 816     completionHandler:(ResponseHandler)completionHandler
 817 {
 818     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
 819     if (!onSuccess) {
 820         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 821         return;
 822     }
 823
 824     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
 825     if (!onFailure) {
 826         delete onSuccess;
 827         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 828         return;
 829     }
 830
 831     CHIP_ERROR err = self.cppCluster.StepWithOnOff(onSuccess->Cancel(), onFailure->Cancel(), stepMode, stepSize, transitionTime);
 832     if (err != CHIP_NO_ERROR) {
 833         delete onSuccess;
 834         delete onFailure;
 835         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
 836     }
 837 }
 838 - (void)stop:(uint8_t)optionMask optionOverride:(uint8_t)optionOverride completionHandler:(ResponseHandler)completionHandler
 839 {
 840     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
 841     if (!onSuccess) {
 842         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 843         return;
 844     }
 845
 846     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
 847     if (!onFailure) {
 848         delete onSuccess;
 849         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 850         return;
 851     }
 852
 853     CHIP_ERROR err = self.cppCluster.Stop(onSuccess->Cancel(), onFailure->Cancel(), optionMask, optionOverride);
 854     if (err != CHIP_NO_ERROR) {
 855         delete onSuccess;
 856         delete onFailure;
 857         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
 858     }
 859 }
 860 - (void)stopWithOnOff:(ResponseHandler)completionHandler
 861 {
 862     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
 863     if (!onSuccess) {
 864         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 865         return;
 866     }
 867
 868     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
 869     if (!onFailure) {
 870         delete onSuccess;
 871         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 872         return;
 873     }
 874
 875     CHIP_ERROR err = self.cppCluster.StopWithOnOff(onSuccess->Cancel(), onFailure->Cancel());
 876     if (err != CHIP_NO_ERROR) {
 877         delete onSuccess;
 878         delete onFailure;
 879         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
 880     }
 881 }
 882
 883 - (void)readAttributeCurrentLevel:(ResponseHandler)completionHandler
 884 {
 885     CHIPInt8uAttributeCallbackBridge * onSuccess = new CHIPInt8uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
 886     if (!onSuccess) {
 887         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 888         return;
 889     }
 890
 891     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
 892     if (!onFailure) {
 893         delete onSuccess;
 894         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 895         return;
 896     }
 897
 898     CHIP_ERROR err = self.cppCluster.ReadAttributeCurrentLevel(onSuccess->Cancel(), onFailure->Cancel());
 899     if (err != CHIP_NO_ERROR) {
 900         delete onSuccess;
 901         delete onFailure;
 902         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
 903     }
 904 }
 905
 906 - (void)configureAttributeCurrentLevel:(uint16_t)minInterval
 907                            maxInterval:(uint16_t)maxInterval
 908                                 change:(uint8_t)change
 909                      completionHandler:(ResponseHandler)completionHandler
 910 {
 911     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
 912     if (!onSuccess) {
 913         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 914         return;
 915     }
 916
 917     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
 918     if (!onFailure) {
 919         delete onSuccess;
 920         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 921         return;
 922     }
 923
 924     CHIP_ERROR err = self.cppCluster.ConfigureAttributeCurrentLevel(
 925         onSuccess->Cancel(), onFailure->Cancel(), minInterval, maxInterval, change);
 926     if (err != CHIP_NO_ERROR) {
 927         delete onSuccess;
 928         delete onFailure;
 929         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
 930     }
 931 }
 932
 933 - (void)reportAttributeCurrentLevel:(ResponseHandler)reportHandler
 934 {
 935     CHIPInt8uAttributeCallbackBridge * onReport = new CHIPInt8uAttributeCallbackBridge(reportHandler, [self callbackQueue], true);
 936     if (!onReport) {
 937         reportHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 938         return;
 939     }
 940
 941     CHIP_ERROR err = self.cppCluster.ReportAttributeCurrentLevel(onReport->Cancel());
 942     if (err != CHIP_NO_ERROR) {
 943         delete onReport;
 944         reportHandler([CHIPError errorForCHIPErrorCode:err], nil);
 945     }
 946 }
 947
 948 - (void)readAttributeRemainingTime:(ResponseHandler)completionHandler
 949 {
 950     CHIPInt16uAttributeCallbackBridge * onSuccess = new CHIPInt16uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
 951     if (!onSuccess) {
 952         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 953         return;
 954     }
 955
 956     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
 957     if (!onFailure) {
 958         delete onSuccess;
 959         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 960         return;
 961     }
 962
 963     CHIP_ERROR err = self.cppCluster.ReadAttributeRemainingTime(onSuccess->Cancel(), onFailure->Cancel());
 964     if (err != CHIP_NO_ERROR) {
 965         delete onSuccess;
 966         delete onFailure;
 967         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
 968     }
 969 }
 970
 971 - (void)readAttributeOptions:(ResponseHandler)completionHandler
 972 {
 973     CHIPInt8uAttributeCallbackBridge * onSuccess = new CHIPInt8uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
 974     if (!onSuccess) {
 975         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 976         return;
 977     }
 978
 979     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
 980     if (!onFailure) {
 981         delete onSuccess;
 982         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 983         return;
 984     }
 985
 986     CHIP_ERROR err = self.cppCluster.ReadAttributeOptions(onSuccess->Cancel(), onFailure->Cancel());
 987     if (err != CHIP_NO_ERROR) {
 988         delete onSuccess;
 989         delete onFailure;
 990         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
 991     }
 992 }
 993
 994 - (void)writeAttributeOptions:(uint8_t)value completionHandler:(ResponseHandler)completionHandler
 995 {
 996     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
 997     if (!onSuccess) {
 998         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 999         return;
1000     }
1001
1002     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
1003     if (!onFailure) {
1004         delete onSuccess;
1005         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1006         return;
1007     }
1008
1009     CHIP_ERROR err = self.cppCluster.WriteAttributeOptions(onSuccess->Cancel(), onFailure->Cancel(), value);
1010     if (err != CHIP_NO_ERROR) {
1011         delete onSuccess;
1012         delete onFailure;
1013         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
1014     }
1015 }
1016
1017 - (void)readAttributeStartUpCurrentLevel:(ResponseHandler)completionHandler
1018 {
1019     CHIPInt8uAttributeCallbackBridge * onSuccess = new CHIPInt8uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
1020     if (!onSuccess) {
1021         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1022         return;
1023     }
1024
1025     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
1026     if (!onFailure) {
1027         delete onSuccess;
1028         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1029         return;
1030     }
1031
1032     CHIP_ERROR err = self.cppCluster.ReadAttributeStartUpCurrentLevel(onSuccess->Cancel(), onFailure->Cancel());
1033     if (err != CHIP_NO_ERROR) {
1034         delete onSuccess;
1035         delete onFailure;
1036         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
1037     }
1038 }
1039
1040 - (void)writeAttributeStartUpCurrentLevel:(uint8_t)value completionHandler:(ResponseHandler)completionHandler
1041 {
1042     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
1043     if (!onSuccess) {
1044         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1045         return;
1046     }
1047
1048     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
1049     if (!onFailure) {
1050         delete onSuccess;
1051         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1052         return;
1053     }
1054
1055     CHIP_ERROR err = self.cppCluster.WriteAttributeStartUpCurrentLevel(onSuccess->Cancel(), onFailure->Cancel(), value);
1056     if (err != CHIP_NO_ERROR) {
1057         delete onSuccess;
1058         delete onFailure;
1059         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
1060     }
1061 }
1062
1063 - (void)readAttributeClusterRevision:(ResponseHandler)completionHandler
1064 {
1065     CHIPInt16uAttributeCallbackBridge * onSuccess = new CHIPInt16uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
1066     if (!onSuccess) {
1067         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1068         return;
1069     }
1070
1071     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
1072     if (!onFailure) {
1073         delete onSuccess;
1074         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1075         return;
1076     }
1077
1078     CHIP_ERROR err = self.cppCluster.ReadAttributeClusterRevision(onSuccess->Cancel(), onFailure->Cancel());
1079     if (err != CHIP_NO_ERROR) {
1080         delete onSuccess;
1081         delete onFailure;
1082         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
1083     }
1084 }
1085
1086 @end
1087
1088 @interface CHIPOnOff ()
1089 @property (readonly) Controller::OnOffCluster cppCluster;
1090 @end
1091
1092 @implementation CHIPOnOff
1093
1094 - (Controller::ClusterBase *)getCluster
1095 {
1096     return &_cppCluster;
1097 }
1098
1099 - (void)off:(ResponseHandler)completionHandler
1100 {
1101     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
1102     if (!onSuccess) {
1103         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1104         return;
1105     }
1106
1107     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
1108     if (!onFailure) {
1109         delete onSuccess;
1110         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1111         return;
1112     }
1113
1114     CHIP_ERROR err = self.cppCluster.Off(onSuccess->Cancel(), onFailure->Cancel());
1115     if (err != CHIP_NO_ERROR) {
1116         delete onSuccess;
1117         delete onFailure;
1118         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
1119     }
1120 }
1121 - (void)offWithEffect:(uint8_t)effectId effectVariant:(uint8_t)effectVariant completionHandler:(ResponseHandler)completionHandler
1122 {
1123     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
1124     if (!onSuccess) {
1125         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1126         return;
1127     }
1128
1129     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
1130     if (!onFailure) {
1131         delete onSuccess;
1132         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1133         return;
1134     }
1135
1136     CHIP_ERROR err = self.cppCluster.OffWithEffect(onSuccess->Cancel(), onFailure->Cancel(), effectId, effectVariant);
1137     if (err != CHIP_NO_ERROR) {
1138         delete onSuccess;
1139         delete onFailure;
1140         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
1141     }
1142 }
1143 - (void)on:(ResponseHandler)completionHandler
1144 {
1145     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
1146     if (!onSuccess) {
1147         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1148         return;
1149     }
1150
1151     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
1152     if (!onFailure) {
1153         delete onSuccess;
1154         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1155         return;
1156     }
1157
1158     CHIP_ERROR err = self.cppCluster.On(onSuccess->Cancel(), onFailure->Cancel());
1159     if (err != CHIP_NO_ERROR) {
1160         delete onSuccess;
1161         delete onFailure;
1162         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
1163     }
1164 }
1165 - (void)onWithRecallGlobalScene:(ResponseHandler)completionHandler
1166 {
1167     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
1168     if (!onSuccess) {
1169         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1170         return;
1171     }
1172
1173     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
1174     if (!onFailure) {
1175         delete onSuccess;
1176         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1177         return;
1178     }
1179
1180     CHIP_ERROR err = self.cppCluster.OnWithRecallGlobalScene(onSuccess->Cancel(), onFailure->Cancel());
1181     if (err != CHIP_NO_ERROR) {
1182         delete onSuccess;
1183         delete onFailure;
1184         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
1185     }
1186 }
1187 - (void)onWithTimedOff:(uint8_t)onOffControl
1188                 onTime:(uint16_t)onTime
1189            offWaitTime:(uint16_t)offWaitTime
1190      completionHandler:(ResponseHandler)completionHandler
1191 {
1192     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
1193     if (!onSuccess) {
1194         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1195         return;
1196     }
1197
1198     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
1199     if (!onFailure) {
1200         delete onSuccess;
1201         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1202         return;
1203     }
1204
1205     CHIP_ERROR err = self.cppCluster.OnWithTimedOff(onSuccess->Cancel(), onFailure->Cancel(), onOffControl, onTime, offWaitTime);
1206     if (err != CHIP_NO_ERROR) {
1207         delete onSuccess;
1208         delete onFailure;
1209         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
1210     }
1211 }
1212 - (void)toggle:(ResponseHandler)completionHandler
1213 {
1214     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
1215     if (!onSuccess) {
1216         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1217         return;
1218     }
1219
1220     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
1221     if (!onFailure) {
1222         delete onSuccess;
1223         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1224         return;
1225     }
1226
1227     CHIP_ERROR err = self.cppCluster.Toggle(onSuccess->Cancel(), onFailure->Cancel());
1228     if (err != CHIP_NO_ERROR) {
1229         delete onSuccess;
1230         delete onFailure;
1231         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
1232     }
1233 }
1234
1235 - (void)readAttributeOnOff:(ResponseHandler)completionHandler
1236 {
1237     CHIPBooleanAttributeCallbackBridge * onSuccess
1238         = new CHIPBooleanAttributeCallbackBridge(completionHandler, [self callbackQueue]);
1239     if (!onSuccess) {
1240         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1241         return;
1242     }
1243
1244     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
1245     if (!onFailure) {
1246         delete onSuccess;
1247         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1248         return;
1249     }
1250
1251     CHIP_ERROR err = self.cppCluster.ReadAttributeOnOff(onSuccess->Cancel(), onFailure->Cancel());
1252     if (err != CHIP_NO_ERROR) {
1253         delete onSuccess;
1254         delete onFailure;
1255         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
1256     }
1257 }
1258
1259 - (void)configureAttributeOnOff:(uint16_t)minInterval
1260                     maxInterval:(uint16_t)maxInterval
1261               completionHandler:(ResponseHandler)completionHandler
1262 {
1263     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
1264     if (!onSuccess) {
1265         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1266         return;
1267     }
1268
1269     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
1270     if (!onFailure) {
1271         delete onSuccess;
1272         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1273         return;
1274     }
1275
1276     CHIP_ERROR err = self.cppCluster.ConfigureAttributeOnOff(onSuccess->Cancel(), onFailure->Cancel(), minInterval, maxInterval);
1277     if (err != CHIP_NO_ERROR) {
1278         delete onSuccess;
1279         delete onFailure;
1280         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
1281     }
1282 }
1283
1284 - (void)reportAttributeOnOff:(ResponseHandler)reportHandler
1285 {
1286     CHIPBooleanAttributeCallbackBridge * onReport
1287         = new CHIPBooleanAttributeCallbackBridge(reportHandler, [self callbackQueue], true);
1288     if (!onReport) {
1289         reportHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1290         return;
1291     }
1292
1293     CHIP_ERROR err = self.cppCluster.ReportAttributeOnOff(onReport->Cancel());
1294     if (err != CHIP_NO_ERROR) {
1295         delete onReport;
1296         reportHandler([CHIPError errorForCHIPErrorCode:err], nil);
1297     }
1298 }
1299
1300 - (void)readAttributeGlobalSceneControl:(ResponseHandler)completionHandler
1301 {
1302     CHIPBooleanAttributeCallbackBridge * onSuccess
1303         = new CHIPBooleanAttributeCallbackBridge(completionHandler, [self callbackQueue]);
1304     if (!onSuccess) {
1305         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1306         return;
1307     }
1308
1309     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
1310     if (!onFailure) {
1311         delete onSuccess;
1312         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1313         return;
1314     }
1315
1316     CHIP_ERROR err = self.cppCluster.ReadAttributeGlobalSceneControl(onSuccess->Cancel(), onFailure->Cancel());
1317     if (err != CHIP_NO_ERROR) {
1318         delete onSuccess;
1319         delete onFailure;
1320         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
1321     }
1322 }
1323
1324 - (void)readAttributeOnTime:(ResponseHandler)completionHandler
1325 {
1326     CHIPInt16uAttributeCallbackBridge * onSuccess = new CHIPInt16uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
1327     if (!onSuccess) {
1328         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1329         return;
1330     }
1331
1332     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
1333     if (!onFailure) {
1334         delete onSuccess;
1335         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1336         return;
1337     }
1338
1339     CHIP_ERROR err = self.cppCluster.ReadAttributeOnTime(onSuccess->Cancel(), onFailure->Cancel());
1340     if (err != CHIP_NO_ERROR) {
1341         delete onSuccess;
1342         delete onFailure;
1343         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
1344     }
1345 }
1346
1347 - (void)writeAttributeOnTime:(uint16_t)value completionHandler:(ResponseHandler)completionHandler
1348 {
1349     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
1350     if (!onSuccess) {
1351         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1352         return;
1353     }
1354
1355     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
1356     if (!onFailure) {
1357         delete onSuccess;
1358         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1359         return;
1360     }
1361
1362     CHIP_ERROR err = self.cppCluster.WriteAttributeOnTime(onSuccess->Cancel(), onFailure->Cancel(), value);
1363     if (err != CHIP_NO_ERROR) {
1364         delete onSuccess;
1365         delete onFailure;
1366         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
1367     }
1368 }
1369
1370 - (void)readAttributeOffWaitTime:(ResponseHandler)completionHandler
1371 {
1372     CHIPInt16uAttributeCallbackBridge * onSuccess = new CHIPInt16uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
1373     if (!onSuccess) {
1374         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1375         return;
1376     }
1377
1378     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
1379     if (!onFailure) {
1380         delete onSuccess;
1381         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1382         return;
1383     }
1384
1385     CHIP_ERROR err = self.cppCluster.ReadAttributeOffWaitTime(onSuccess->Cancel(), onFailure->Cancel());
1386     if (err != CHIP_NO_ERROR) {
1387         delete onSuccess;
1388         delete onFailure;
1389         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
1390     }
1391 }
1392
1393 - (void)writeAttributeOffWaitTime:(uint16_t)value completionHandler:(ResponseHandler)completionHandler
1394 {
1395     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
1396     if (!onSuccess) {
1397         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1398         return;
1399     }
1400
1401     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
1402     if (!onFailure) {
1403         delete onSuccess;
1404         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1405         return;
1406     }
1407
1408     CHIP_ERROR err = self.cppCluster.WriteAttributeOffWaitTime(onSuccess->Cancel(), onFailure->Cancel(), value);
1409     if (err != CHIP_NO_ERROR) {
1410         delete onSuccess;
1411         delete onFailure;
1412         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
1413     }
1414 }
1415
1416 - (void)readAttributeStartUpOnOff:(ResponseHandler)completionHandler
1417 {
1418     CHIPInt8uAttributeCallbackBridge * onSuccess = new CHIPInt8uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
1419     if (!onSuccess) {
1420         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1421         return;
1422     }
1423
1424     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
1425     if (!onFailure) {
1426         delete onSuccess;
1427         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1428         return;
1429     }
1430
1431     CHIP_ERROR err = self.cppCluster.ReadAttributeStartUpOnOff(onSuccess->Cancel(), onFailure->Cancel());
1432     if (err != CHIP_NO_ERROR) {
1433         delete onSuccess;
1434         delete onFailure;
1435         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
1436     }
1437 }
1438
1439 - (void)writeAttributeStartUpOnOff:(uint8_t)value completionHandler:(ResponseHandler)completionHandler
1440 {
1441     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
1442     if (!onSuccess) {
1443         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1444         return;
1445     }
1446
1447     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
1448     if (!onFailure) {
1449         delete onSuccess;
1450         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1451         return;
1452     }
1453
1454     CHIP_ERROR err = self.cppCluster.WriteAttributeStartUpOnOff(onSuccess->Cancel(), onFailure->Cancel(), value);
1455     if (err != CHIP_NO_ERROR) {
1456         delete onSuccess;
1457         delete onFailure;
1458         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
1459     }
1460 }
1461
1462 - (void)readAttributeClusterRevision:(ResponseHandler)completionHandler
1463 {
1464     CHIPInt16uAttributeCallbackBridge * onSuccess = new CHIPInt16uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
1465     if (!onSuccess) {
1466         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1467         return;
1468     }
1469
1470     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
1471     if (!onFailure) {
1472         delete onSuccess;
1473         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1474         return;
1475     }
1476
1477     CHIP_ERROR err = self.cppCluster.ReadAttributeClusterRevision(onSuccess->Cancel(), onFailure->Cancel());
1478     if (err != CHIP_NO_ERROR) {
1479         delete onSuccess;
1480         delete onFailure;
1481         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
1482     }
1483 }
1484
1485 @end