examples/lock-app/lock-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 CHIPOnOff ()
 703 @property (readonly) Controller::OnOffCluster cppCluster;
 704 @end
 705
 706 @implementation CHIPOnOff
 707
 708 - (Controller::ClusterBase *)getCluster
 709 {
 710     return &_cppCluster;
 711 }
 712
 713 - (void)off:(ResponseHandler)completionHandler
 714 {
 715     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
 716     if (!onSuccess) {
 717         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 718         return;
 719     }
 720
 721     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
 722     if (!onFailure) {
 723         delete onSuccess;
 724         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 725         return;
 726     }
 727
 728     CHIP_ERROR err = self.cppCluster.Off(onSuccess->Cancel(), onFailure->Cancel());
 729     if (err != CHIP_NO_ERROR) {
 730         delete onSuccess;
 731         delete onFailure;
 732         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
 733     }
 734 }
 735 - (void)on:(ResponseHandler)completionHandler
 736 {
 737     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
 738     if (!onSuccess) {
 739         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 740         return;
 741     }
 742
 743     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
 744     if (!onFailure) {
 745         delete onSuccess;
 746         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 747         return;
 748     }
 749
 750     CHIP_ERROR err = self.cppCluster.On(onSuccess->Cancel(), onFailure->Cancel());
 751     if (err != CHIP_NO_ERROR) {
 752         delete onSuccess;
 753         delete onFailure;
 754         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
 755     }
 756 }
 757 - (void)toggle:(ResponseHandler)completionHandler
 758 {
 759     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
 760     if (!onSuccess) {
 761         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 762         return;
 763     }
 764
 765     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
 766     if (!onFailure) {
 767         delete onSuccess;
 768         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 769         return;
 770     }
 771
 772     CHIP_ERROR err = self.cppCluster.Toggle(onSuccess->Cancel(), onFailure->Cancel());
 773     if (err != CHIP_NO_ERROR) {
 774         delete onSuccess;
 775         delete onFailure;
 776         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
 777     }
 778 }
 779
 780 - (void)readAttributeOnOff:(ResponseHandler)completionHandler
 781 {
 782     CHIPBooleanAttributeCallbackBridge * onSuccess
 783         = new CHIPBooleanAttributeCallbackBridge(completionHandler, [self callbackQueue]);
 784     if (!onSuccess) {
 785         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 786         return;
 787     }
 788
 789     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
 790     if (!onFailure) {
 791         delete onSuccess;
 792         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 793         return;
 794     }
 795
 796     CHIP_ERROR err = self.cppCluster.ReadAttributeOnOff(onSuccess->Cancel(), onFailure->Cancel());
 797     if (err != CHIP_NO_ERROR) {
 798         delete onSuccess;
 799         delete onFailure;
 800         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
 801     }
 802 }
 803
 804 - (void)configureAttributeOnOff:(uint16_t)minInterval
 805                     maxInterval:(uint16_t)maxInterval
 806               completionHandler:(ResponseHandler)completionHandler
 807 {
 808     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
 809     if (!onSuccess) {
 810         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 811         return;
 812     }
 813
 814     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
 815     if (!onFailure) {
 816         delete onSuccess;
 817         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 818         return;
 819     }
 820
 821     CHIP_ERROR err = self.cppCluster.ConfigureAttributeOnOff(onSuccess->Cancel(), onFailure->Cancel(), minInterval, maxInterval);
 822     if (err != CHIP_NO_ERROR) {
 823         delete onSuccess;
 824         delete onFailure;
 825         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
 826     }
 827 }
 828
 829 - (void)reportAttributeOnOff:(ResponseHandler)reportHandler
 830 {
 831     CHIPBooleanAttributeCallbackBridge * onReport
 832         = new CHIPBooleanAttributeCallbackBridge(reportHandler, [self callbackQueue], true);
 833     if (!onReport) {
 834         reportHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 835         return;
 836     }
 837
 838     CHIP_ERROR err = self.cppCluster.ReportAttributeOnOff(onReport->Cancel());
 839     if (err != CHIP_NO_ERROR) {
 840         delete onReport;
 841         reportHandler([CHIPError errorForCHIPErrorCode:err], nil);
 842     }
 843 }
 844
 845 - (void)readAttributeClusterRevision:(ResponseHandler)completionHandler
 846 {
 847     CHIPInt16uAttributeCallbackBridge * onSuccess = new CHIPInt16uAttributeCallbackBridge(completionHandler, [self callbackQueue]);
 848     if (!onSuccess) {
 849         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 850         return;
 851     }
 852
 853     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
 854     if (!onFailure) {
 855         delete onSuccess;
 856         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 857         return;
 858     }
 859
 860     CHIP_ERROR err = self.cppCluster.ReadAttributeClusterRevision(onSuccess->Cancel(), onFailure->Cancel());
 861     if (err != CHIP_NO_ERROR) {
 862         delete onSuccess;
 863         delete onFailure;
 864         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
 865     }
 866 }
 867
 868 @end