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