examples/lighting-app/lighting-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)readAttributeClusterRevision:(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.ReadAttributeClusterRevision(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 @end
 999
1000 @interface CHIPNetworkCommissioning ()
1001 @property (readonly) Controller::NetworkCommissioningCluster cppCluster;
1002 @end
1003
1004 @implementation CHIPNetworkCommissioning
1005
1006 - (Controller::ClusterBase *)getCluster
1007 {
1008     return &_cppCluster;
1009 }
1010
1011 - (void)addThreadNetwork:(NSData *)operationalDataset
1012               breadcrumb:(uint64_t)breadcrumb
1013                timeoutMs:(uint32_t)timeoutMs
1014        completionHandler:(ResponseHandler)completionHandler
1015 {
1016     CHIPNetworkCommissioningClusterAddThreadNetworkResponseCallbackBridge * onSuccess
1017         = new CHIPNetworkCommissioningClusterAddThreadNetworkResponseCallbackBridge(completionHandler, [self callbackQueue]);
1018     if (!onSuccess) {
1019         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1020         return;
1021     }
1022
1023     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
1024     if (!onFailure) {
1025         delete onSuccess;
1026         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1027         return;
1028     }
1029
1030     CHIP_ERROR err = self.cppCluster.AddThreadNetwork(onSuccess->Cancel(), onFailure->Cancel(),
1031         chip::ByteSpan((const uint8_t *) operationalDataset.bytes, operationalDataset.length), breadcrumb, timeoutMs);
1032     if (err != CHIP_NO_ERROR) {
1033         delete onSuccess;
1034         delete onFailure;
1035         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
1036     }
1037 }
1038 - (void)addWiFiNetwork:(NSData *)ssid
1039            credentials:(NSData *)credentials
1040             breadcrumb:(uint64_t)breadcrumb
1041              timeoutMs:(uint32_t)timeoutMs
1042      completionHandler:(ResponseHandler)completionHandler
1043 {
1044     CHIPNetworkCommissioningClusterAddWiFiNetworkResponseCallbackBridge * onSuccess
1045         = new CHIPNetworkCommissioningClusterAddWiFiNetworkResponseCallbackBridge(completionHandler, [self callbackQueue]);
1046     if (!onSuccess) {
1047         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1048         return;
1049     }
1050
1051     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
1052     if (!onFailure) {
1053         delete onSuccess;
1054         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1055         return;
1056     }
1057
1058     CHIP_ERROR err = self.cppCluster.AddWiFiNetwork(onSuccess->Cancel(), onFailure->Cancel(),
1059         chip::ByteSpan((const uint8_t *) ssid.bytes, ssid.length),
1060         chip::ByteSpan((const uint8_t *) credentials.bytes, credentials.length), breadcrumb, timeoutMs);
1061     if (err != CHIP_NO_ERROR) {
1062         delete onSuccess;
1063         delete onFailure;
1064         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
1065     }
1066 }
1067 - (void)disableNetwork:(NSData *)networkID
1068             breadcrumb:(uint64_t)breadcrumb
1069              timeoutMs:(uint32_t)timeoutMs
1070      completionHandler:(ResponseHandler)completionHandler
1071 {
1072     CHIPNetworkCommissioningClusterDisableNetworkResponseCallbackBridge * onSuccess
1073         = new CHIPNetworkCommissioningClusterDisableNetworkResponseCallbackBridge(completionHandler, [self callbackQueue]);
1074     if (!onSuccess) {
1075         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1076         return;
1077     }
1078
1079     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
1080     if (!onFailure) {
1081         delete onSuccess;
1082         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1083         return;
1084     }
1085
1086     CHIP_ERROR err = self.cppCluster.DisableNetwork(onSuccess->Cancel(), onFailure->Cancel(),
1087         chip::ByteSpan((const uint8_t *) networkID.bytes, networkID.length), breadcrumb, timeoutMs);
1088     if (err != CHIP_NO_ERROR) {
1089         delete onSuccess;
1090         delete onFailure;
1091         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
1092     }
1093 }
1094 - (void)enableNetwork:(NSData *)networkID
1095            breadcrumb:(uint64_t)breadcrumb
1096             timeoutMs:(uint32_t)timeoutMs
1097     completionHandler:(ResponseHandler)completionHandler
1098 {
1099     CHIPNetworkCommissioningClusterEnableNetworkResponseCallbackBridge * onSuccess
1100         = new CHIPNetworkCommissioningClusterEnableNetworkResponseCallbackBridge(completionHandler, [self callbackQueue]);
1101     if (!onSuccess) {
1102         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1103         return;
1104     }
1105
1106     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
1107     if (!onFailure) {
1108         delete onSuccess;
1109         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1110         return;
1111     }
1112
1113     CHIP_ERROR err = self.cppCluster.EnableNetwork(onSuccess->Cancel(), onFailure->Cancel(),
1114         chip::ByteSpan((const uint8_t *) networkID.bytes, networkID.length), breadcrumb, timeoutMs);
1115     if (err != CHIP_NO_ERROR) {
1116         delete onSuccess;
1117         delete onFailure;
1118         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
1119     }
1120 }
1121 - (void)getLastNetworkCommissioningResult:(uint32_t)timeoutMs 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.GetLastNetworkCommissioningResult(onSuccess->Cancel(), onFailure->Cancel(), timeoutMs);
1137     if (err != CHIP_NO_ERROR) {
1138         delete onSuccess;
1139         delete onFailure;
1140         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
1141     }
1142 }
1143 - (void)removeNetwork:(NSData *)networkID
1144            breadcrumb:(uint64_t)breadcrumb
1145             timeoutMs:(uint32_t)timeoutMs
1146     completionHandler:(ResponseHandler)completionHandler
1147 {
1148     CHIPNetworkCommissioningClusterRemoveNetworkResponseCallbackBridge * onSuccess
1149         = new CHIPNetworkCommissioningClusterRemoveNetworkResponseCallbackBridge(completionHandler, [self callbackQueue]);
1150     if (!onSuccess) {
1151         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1152         return;
1153     }
1154
1155     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
1156     if (!onFailure) {
1157         delete onSuccess;
1158         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1159         return;
1160     }
1161
1162     CHIP_ERROR err = self.cppCluster.RemoveNetwork(onSuccess->Cancel(), onFailure->Cancel(),
1163         chip::ByteSpan((const uint8_t *) networkID.bytes, networkID.length), breadcrumb, timeoutMs);
1164     if (err != CHIP_NO_ERROR) {
1165         delete onSuccess;
1166         delete onFailure;
1167         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
1168     }
1169 }
1170 - (void)scanNetworks:(NSData *)ssid
1171            breadcrumb:(uint64_t)breadcrumb
1172             timeoutMs:(uint32_t)timeoutMs
1173     completionHandler:(ResponseHandler)completionHandler
1174 {
1175     CHIPNetworkCommissioningClusterScanNetworksResponseCallbackBridge * onSuccess
1176         = new CHIPNetworkCommissioningClusterScanNetworksResponseCallbackBridge(completionHandler, [self callbackQueue]);
1177     if (!onSuccess) {
1178         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1179         return;
1180     }
1181
1182     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
1183     if (!onFailure) {
1184         delete onSuccess;
1185         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1186         return;
1187     }
1188
1189     CHIP_ERROR err = self.cppCluster.ScanNetworks(
1190         onSuccess->Cancel(), onFailure->Cancel(), chip::ByteSpan((const uint8_t *) ssid.bytes, ssid.length), breadcrumb, timeoutMs);
1191     if (err != CHIP_NO_ERROR) {
1192         delete onSuccess;
1193         delete onFailure;
1194         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
1195     }
1196 }
1197 - (void)updateThreadNetwork:(NSData *)operationalDataset
1198                  breadcrumb:(uint64_t)breadcrumb
1199                   timeoutMs:(uint32_t)timeoutMs
1200           completionHandler:(ResponseHandler)completionHandler
1201 {
1202     CHIPNetworkCommissioningClusterUpdateThreadNetworkResponseCallbackBridge * onSuccess
1203         = new CHIPNetworkCommissioningClusterUpdateThreadNetworkResponseCallbackBridge(completionHandler, [self callbackQueue]);
1204     if (!onSuccess) {
1205         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1206         return;
1207     }
1208
1209     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
1210     if (!onFailure) {
1211         delete onSuccess;
1212         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1213         return;
1214     }
1215
1216     CHIP_ERROR err = self.cppCluster.UpdateThreadNetwork(onSuccess->Cancel(), onFailure->Cancel(),
1217         chip::ByteSpan((const uint8_t *) operationalDataset.bytes, operationalDataset.length), breadcrumb, timeoutMs);
1218     if (err != CHIP_NO_ERROR) {
1219         delete onSuccess;
1220         delete onFailure;
1221         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
1222     }
1223 }
1224 - (void)updateWiFiNetwork:(NSData *)ssid
1225               credentials:(NSData *)credentials
1226                breadcrumb:(uint64_t)breadcrumb
1227                 timeoutMs:(uint32_t)timeoutMs
1228         completionHandler:(ResponseHandler)completionHandler
1229 {
1230     CHIPNetworkCommissioningClusterUpdateWiFiNetworkResponseCallbackBridge * onSuccess
1231         = new CHIPNetworkCommissioningClusterUpdateWiFiNetworkResponseCallbackBridge(completionHandler, [self callbackQueue]);
1232     if (!onSuccess) {
1233         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1234         return;
1235     }
1236
1237     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
1238     if (!onFailure) {
1239         delete onSuccess;
1240         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1241         return;
1242     }
1243
1244     CHIP_ERROR err = self.cppCluster.UpdateWiFiNetwork(onSuccess->Cancel(), onFailure->Cancel(),
1245         chip::ByteSpan((const uint8_t *) ssid.bytes, ssid.length),
1246         chip::ByteSpan((const uint8_t *) credentials.bytes, credentials.length), breadcrumb, timeoutMs);
1247     if (err != CHIP_NO_ERROR) {
1248         delete onSuccess;
1249         delete onFailure;
1250         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
1251     }
1252 }
1253
1254 - (void)readAttributeClusterRevision:(ResponseHandler)completionHandler
1255 {
1256     CHIPInt16uAttributeCallbackBridge * onSuccess = new CHIPInt16uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
1257     if (!onSuccess) {
1258         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1259         return;
1260     }
1261
1262     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
1263     if (!onFailure) {
1264         delete onSuccess;
1265         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1266         return;
1267     }
1268
1269     CHIP_ERROR err = self.cppCluster.ReadAttributeClusterRevision(onSuccess->Cancel(), onFailure->Cancel());
1270     if (err != CHIP_NO_ERROR) {
1271         delete onSuccess;
1272         delete onFailure;
1273         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
1274     }
1275 }
1276
1277 @end
1278
1279 @interface CHIPOnOff ()
1280 @property (readonly) Controller::OnOffCluster cppCluster;
1281 @end
1282
1283 @implementation CHIPOnOff
1284
1285 - (Controller::ClusterBase *)getCluster
1286 {
1287     return &_cppCluster;
1288 }
1289
1290 - (void)off:(ResponseHandler)completionHandler
1291 {
1292     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
1293     if (!onSuccess) {
1294         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1295         return;
1296     }
1297
1298     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
1299     if (!onFailure) {
1300         delete onSuccess;
1301         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1302         return;
1303     }
1304
1305     CHIP_ERROR err = self.cppCluster.Off(onSuccess->Cancel(), onFailure->Cancel());
1306     if (err != CHIP_NO_ERROR) {
1307         delete onSuccess;
1308         delete onFailure;
1309         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
1310     }
1311 }
1312 - (void)on:(ResponseHandler)completionHandler
1313 {
1314     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
1315     if (!onSuccess) {
1316         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1317         return;
1318     }
1319
1320     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
1321     if (!onFailure) {
1322         delete onSuccess;
1323         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1324         return;
1325     }
1326
1327     CHIP_ERROR err = self.cppCluster.On(onSuccess->Cancel(), onFailure->Cancel());
1328     if (err != CHIP_NO_ERROR) {
1329         delete onSuccess;
1330         delete onFailure;
1331         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
1332     }
1333 }
1334 - (void)toggle:(ResponseHandler)completionHandler
1335 {
1336     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
1337     if (!onSuccess) {
1338         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1339         return;
1340     }
1341
1342     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
1343     if (!onFailure) {
1344         delete onSuccess;
1345         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1346         return;
1347     }
1348
1349     CHIP_ERROR err = self.cppCluster.Toggle(onSuccess->Cancel(), onFailure->Cancel());
1350     if (err != CHIP_NO_ERROR) {
1351         delete onSuccess;
1352         delete onFailure;
1353         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
1354     }
1355 }
1356
1357 - (void)readAttributeOnOff:(ResponseHandler)completionHandler
1358 {
1359     CHIPBooleanAttributeCallbackBridge * onSuccess
1360         = new CHIPBooleanAttributeCallbackBridge(completionHandler, [self callbackQueue]);
1361     if (!onSuccess) {
1362         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1363         return;
1364     }
1365
1366     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
1367     if (!onFailure) {
1368         delete onSuccess;
1369         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1370         return;
1371     }
1372
1373     CHIP_ERROR err = self.cppCluster.ReadAttributeOnOff(onSuccess->Cancel(), onFailure->Cancel());
1374     if (err != CHIP_NO_ERROR) {
1375         delete onSuccess;
1376         delete onFailure;
1377         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
1378     }
1379 }
1380
1381 - (void)configureAttributeOnOff:(uint16_t)minInterval
1382                     maxInterval:(uint16_t)maxInterval
1383               completionHandler:(ResponseHandler)completionHandler
1384 {
1385     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
1386     if (!onSuccess) {
1387         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1388         return;
1389     }
1390
1391     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
1392     if (!onFailure) {
1393         delete onSuccess;
1394         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1395         return;
1396     }
1397
1398     CHIP_ERROR err = self.cppCluster.ConfigureAttributeOnOff(onSuccess->Cancel(), onFailure->Cancel(), minInterval, maxInterval);
1399     if (err != CHIP_NO_ERROR) {
1400         delete onSuccess;
1401         delete onFailure;
1402         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
1403     }
1404 }
1405
1406 - (void)reportAttributeOnOff:(ResponseHandler)reportHandler
1407 {
1408     CHIPBooleanAttributeCallbackBridge * onReport
1409         = new CHIPBooleanAttributeCallbackBridge(reportHandler, [self callbackQueue], true);
1410     if (!onReport) {
1411         reportHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1412         return;
1413     }
1414
1415     CHIP_ERROR err = self.cppCluster.ReportAttributeOnOff(onReport->Cancel());
1416     if (err != CHIP_NO_ERROR) {
1417         delete onReport;
1418         reportHandler([CHIPError errorForCHIPErrorCode:err], nil);
1419     }
1420 }
1421
1422 - (void)readAttributeClusterRevision:(ResponseHandler)completionHandler
1423 {
1424     CHIPInt16uAttributeCallbackBridge * onSuccess = new CHIPInt16uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
1425     if (!onSuccess) {
1426         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1427         return;
1428     }
1429
1430     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
1431     if (!onFailure) {
1432         delete onSuccess;
1433         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
1434         return;
1435     }
1436
1437     CHIP_ERROR err = self.cppCluster.ReadAttributeClusterRevision(onSuccess->Cancel(), onFailure->Cancel());
1438     if (err != CHIP_NO_ERROR) {
1439         delete onSuccess;
1440         delete onFailure;
1441         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
1442     }
1443 }
1444
1445 @end