src/app/zap-templates/templates/app/CHIPClustersObjc-src.zapt

   1 {{> header}}
   2
   3 {{#if (chip_has_client_clusters)}}
   4 #import <Foundation/Foundation.h>
   5
   6 #import "CHIPDevice.h"
   7 #import "CHIPDevice_Internal.h"
   8 #import "CHIPError.h"
   9 #import "gen/CHIPClustersObjc.h"
  10 #import "gen/CHIPClientCallbacks.h"
  11
  12 #include <controller/CHIPClusters.h>
  13 #include <lib/support/Span.h>
  14
  15 using namespace ::chip;
  16
  17 class CHIPDefaultSuccessCallbackBridge : public Callback::Callback<DefaultSuccessCallback> {
  18 public:
  19     CHIPDefaultSuccessCallbackBridge(ResponseHandler handler, dispatch_queue_t queue)
  20         : Callback::Callback<DefaultSuccessCallback>(CallbackFn, this)
  21         , mHandler(handler)
  22         , mQueue(queue)
  23     {
  24     }
  25
  26     ~CHIPDefaultSuccessCallbackBridge() {};
  27
  28     static void CallbackFn(void * context)
  29     {
  30         CHIPDefaultSuccessCallbackBridge * callback = reinterpret_cast<CHIPDefaultSuccessCallbackBridge *>(context);
  31         if (callback && callback->mQueue) {
  32             dispatch_async(callback->mQueue, ^{
  33                 callback->mHandler(nil, nil);
  34                 callback->Cancel();
  35                 delete callback;
  36             });
  37         }
  38     };
  39
  40 private:
  41     ResponseHandler mHandler;
  42     dispatch_queue_t mQueue;
  43 };
  44
  45 class CHIPDefaultFailureCallbackBridge : public Callback::Callback<DefaultFailureCallback> {
  46 public:
  47     CHIPDefaultFailureCallbackBridge(ResponseHandler handler, dispatch_queue_t queue)
  48         : Callback::Callback<DefaultFailureCallback>(CallbackFn, this)
  49         , mHandler(handler)
  50         , mQueue(queue)
  51     {
  52     }
  53
  54     ~CHIPDefaultFailureCallbackBridge() {};
  55
  56     static void CallbackFn(void * context, uint8_t status)
  57     {
  58         CHIPDefaultFailureCallbackBridge * callback = reinterpret_cast<CHIPDefaultFailureCallbackBridge *>(context);
  59         if (callback && callback->mQueue) {
  60             dispatch_async(callback->mQueue, ^{
  61                 NSError * error = [CHIPError errorForCHIPErrorCode:status];
  62                 callback->mHandler(error, nil);
  63                 callback->Cancel();
  64                 delete callback;
  65             });
  66         }
  67     };
  68
  69 private:
  70     ResponseHandler mHandler;
  71     dispatch_queue_t mQueue;
  72 };
  73
  74 class CHIPStringAttributeCallbackBridge : public Callback::Callback<StringAttributeCallback> {
  75 public:
  76     CHIPStringAttributeCallbackBridge(ResponseHandler handler, dispatch_queue_t queue, bool octetString, bool keepAlive = false)
  77         : Callback::Callback<StringAttributeCallback>(CallbackFn, this)
  78         , mHandler(handler)
  79         , mQueue(queue)
  80         , mOctetString(octetString)
  81         , mKeepAlive(keepAlive)
  82     {
  83     }
  84
  85     ~CHIPStringAttributeCallbackBridge() {};
  86
  87     static void CallbackFn(void * context, chip::ByteSpan value)
  88     {
  89         CHIPStringAttributeCallbackBridge * callback = reinterpret_cast<CHIPStringAttributeCallbackBridge *>(context);
  90         if (callback && callback->mQueue) {
  91             dispatch_async(callback->mQueue, ^{
  92                 if (callback->mOctetString)
  93                 {
  94                     NSData *data = [NSData dataWithBytes: value.data() length: value.size()];
  95                     callback->mHandler(nil, @{ @"value": data });
  96                 }
  97                 else
  98                 {
  99                     NSString * str = [[NSString alloc] initWithBytes:value.data() length:value.size() encoding:NSUTF8StringEncoding];
 100                     callback->mHandler(nil, @{ @"value": str });
 101                 }
 102
 103                 if (!callback->mKeepAlive)
 104                 {
 105                     callback->Cancel();
 106                     delete callback;
 107                 }
 108             });
 109         }
 110     };
 111
 112 private:
 113     ResponseHandler mHandler;
 114     dispatch_queue_t mQueue;
 115     bool mOctetString;
 116     bool mKeepAlive;
 117 };
 118
 119 class CHIPBooleanAttributeCallbackBridge : public Callback::Callback<BooleanAttributeCallback> {
 120 public:
 121     CHIPBooleanAttributeCallbackBridge(ResponseHandler handler, dispatch_queue_t queue, bool keepAlive = false)
 122         : Callback::Callback<BooleanAttributeCallback>(CallbackFn, this)
 123         , mHandler(handler)
 124         , mQueue(queue)
 125         , mKeepAlive(keepAlive)
 126     {
 127     }
 128
 129     ~CHIPBooleanAttributeCallbackBridge() {};
 130
 131     static void CallbackFn(void * context, bool value)
 132     {
 133         CHIPBooleanAttributeCallbackBridge * callback = reinterpret_cast<CHIPBooleanAttributeCallbackBridge *>(context);
 134         if (callback && callback->mQueue) {
 135             dispatch_async(callback->mQueue, ^{
 136                 callback->mHandler(nil, @{ @"value": [NSNumber numberWithBool:value] });
 137                 if (!callback->mKeepAlive)
 138                 {
 139                     callback->Cancel();
 140                     delete callback;
 141                 }
 142             });
 143         }
 144     };
 145
 146 private:
 147     ResponseHandler mHandler;
 148     dispatch_queue_t mQueue;
 149     bool mKeepAlive;
 150 };
 151
 152 class CHIPInt8uAttributeCallbackBridge : public Callback::Callback<Int8uAttributeCallback> {
 153 public:
 154     CHIPInt8uAttributeCallbackBridge(ResponseHandler handler, dispatch_queue_t queue, bool keepAlive = false)
 155         : Callback::Callback<Int8uAttributeCallback>(CallbackFn, this)
 156         , mHandler(handler)
 157         , mQueue(queue)
 158         , mKeepAlive(keepAlive)
 159     {
 160     }
 161
 162     ~CHIPInt8uAttributeCallbackBridge() {};
 163
 164     static void CallbackFn(void * context, uint8_t value)
 165     {
 166         CHIPInt8uAttributeCallbackBridge * callback = reinterpret_cast<CHIPInt8uAttributeCallbackBridge *>(context);
 167         if (callback && callback->mQueue) {
 168             dispatch_async(callback->mQueue, ^{
 169                 callback->mHandler(nil, @{ @"value": [NSNumber numberWithUnsignedChar:value] });
 170                 if (!callback->mKeepAlive)
 171                 {
 172                     callback->Cancel();
 173                     delete callback;
 174                 }
 175             });
 176         }
 177     };
 178
 179 private:
 180     ResponseHandler mHandler;
 181     dispatch_queue_t mQueue;
 182     bool mKeepAlive;
 183 };
 184
 185 class CHIPInt8sAttributeCallbackBridge : public Callback::Callback<Int8sAttributeCallback> {
 186 public:
 187     CHIPInt8sAttributeCallbackBridge(ResponseHandler handler, dispatch_queue_t queue, bool keepAlive = false)
 188         : Callback::Callback<Int8sAttributeCallback>(CallbackFn, this)
 189         , mHandler(handler)
 190         , mQueue(queue)
 191         , mKeepAlive(keepAlive)
 192     {
 193     }
 194
 195     ~CHIPInt8sAttributeCallbackBridge() {};
 196
 197     static void CallbackFn(void * context, int8_t value)
 198     {
 199         CHIPInt8sAttributeCallbackBridge * callback = reinterpret_cast<CHIPInt8sAttributeCallbackBridge *>(context);
 200         if (callback && callback->mQueue) {
 201             dispatch_async(callback->mQueue, ^{
 202                 callback->mHandler(nil, @{ @"value": [NSNumber numberWithChar:value] });
 203                 if (!callback->mKeepAlive)
 204                 {
 205                     callback->Cancel();
 206                     delete callback;
 207                 }
 208             });
 209         }
 210     };
 211
 212 private:
 213     ResponseHandler mHandler;
 214     dispatch_queue_t mQueue;
 215     bool mKeepAlive;
 216 };
 217
 218 class CHIPInt16uAttributeCallbackBridge : public Callback::Callback<Int16uAttributeCallback> {
 219 public:
 220     CHIPInt16uAttributeCallbackBridge(ResponseHandler handler, dispatch_queue_t queue, bool keepAlive = false)
 221         : Callback::Callback<Int16uAttributeCallback>(CallbackFn, this)
 222         , mHandler(handler)
 223         , mQueue(queue)
 224         , mKeepAlive(keepAlive)
 225     {
 226     }
 227
 228     ~CHIPInt16uAttributeCallbackBridge() {};
 229
 230     static void CallbackFn(void * context, uint16_t value)
 231     {
 232         CHIPInt16uAttributeCallbackBridge * callback = reinterpret_cast<CHIPInt16uAttributeCallbackBridge *>(context);
 233         if (callback && callback->mQueue) {
 234             dispatch_async(callback->mQueue, ^{
 235                 callback->mHandler(nil, @{ @"value": [NSNumber numberWithUnsignedShort:value] });
 236                 if (!callback->mKeepAlive)
 237                 {
 238                     callback->Cancel();
 239                     delete callback;
 240                 }
 241             });
 242         }
 243     };
 244
 245 private:
 246     ResponseHandler mHandler;
 247     dispatch_queue_t mQueue;
 248     bool mKeepAlive;
 249 };
 250
 251 class CHIPInt32uAttributeCallbackBridge : public Callback::Callback<Int32uAttributeCallback> {
 252 public:
 253     CHIPInt32uAttributeCallbackBridge(ResponseHandler handler, dispatch_queue_t queue, bool keepAlive = false)
 254         : Callback::Callback<Int32uAttributeCallback>(CallbackFn, this)
 255         , mHandler(handler)
 256         , mQueue(queue)
 257         , mKeepAlive(keepAlive)
 258     {
 259     }
 260
 261     ~CHIPInt32uAttributeCallbackBridge() {};
 262
 263     static void CallbackFn(void * context, uint32_t value)
 264     {
 265         CHIPInt32uAttributeCallbackBridge * callback = reinterpret_cast<CHIPInt32uAttributeCallbackBridge *>(context);
 266         if (callback && callback->mQueue) {
 267             dispatch_async(callback->mQueue, ^{
 268                 callback->mHandler(nil, @{ @"value": [NSNumber numberWithUnsignedLong:value] });
 269                 if (!callback->mKeepAlive)
 270                 {
 271                     callback->Cancel();
 272                     delete callback;
 273                 }
 274             });
 275         }
 276     };
 277
 278 private:
 279     ResponseHandler mHandler;
 280     dispatch_queue_t mQueue;
 281     bool mKeepAlive;
 282 };
 283
 284 class CHIPInt64uAttributeCallbackBridge : public Callback::Callback<Int64uAttributeCallback> {
 285 public:
 286     CHIPInt64uAttributeCallbackBridge(ResponseHandler handler, dispatch_queue_t queue, bool keepAlive = false)
 287         : Callback::Callback<Int64uAttributeCallback>(CallbackFn, this)
 288         , mHandler(handler)
 289         , mQueue(queue)
 290         , mKeepAlive(keepAlive)
 291     {
 292     }
 293
 294     ~CHIPInt64uAttributeCallbackBridge() {};
 295
 296     static void CallbackFn(void * context, uint64_t value)
 297     {
 298         CHIPInt64uAttributeCallbackBridge * callback = reinterpret_cast<CHIPInt64uAttributeCallbackBridge *>(context);
 299         if (callback && callback->mQueue) {
 300             dispatch_async(callback->mQueue, ^{
 301                 callback->mHandler(nil, @{ @"value": [NSNumber numberWithUnsignedLongLong:value] });
 302                 if (!callback->mKeepAlive)
 303                 {
 304                     callback->Cancel();
 305                     delete callback;
 306                 }
 307             });
 308         }
 309     };
 310
 311 private:
 312     ResponseHandler mHandler;
 313     dispatch_queue_t mQueue;
 314     bool mKeepAlive;
 315 };
 316
 317 class CHIPInt16sAttributeCallbackBridge : public Callback::Callback<Int16sAttributeCallback> {
 318 public:
 319     CHIPInt16sAttributeCallbackBridge(ResponseHandler handler, dispatch_queue_t queue, bool keepAlive = false)
 320         : Callback::Callback<Int16sAttributeCallback>(CallbackFn, this)
 321         , mHandler(handler)
 322         , mQueue(queue)
 323         , mKeepAlive(keepAlive)
 324     {
 325     }
 326
 327     ~CHIPInt16sAttributeCallbackBridge() {};
 328
 329     static void CallbackFn(void * context, int16_t value)
 330     {
 331         CHIPInt16sAttributeCallbackBridge * callback = reinterpret_cast<CHIPInt16sAttributeCallbackBridge *>(context);
 332         if (callback && callback->mQueue) {
 333             dispatch_async(callback->mQueue, ^{
 334                 callback->mHandler(nil, @{ @"value": [NSNumber numberWithShort:value] });
 335                 if (!callback->mKeepAlive)
 336                 {
 337                     callback->Cancel();
 338                     delete callback;
 339                 }
 340             });
 341         }
 342     };
 343
 344 private:
 345     ResponseHandler mHandler;
 346     dispatch_queue_t mQueue;
 347     bool mKeepAlive;
 348 };
 349
 350 {{#all_user_clusters}}
 351 {{#if (isClient side) }}
 352 {{#if (user_cluster_has_enabled_command name side)}}
 353 {{#all_user_cluster_commands}}
 354 {{#if (isStrEqual clusterName parent.name)}}
 355 {{#if (isCommandAvailable parent.side incoming outgoing commandSource name)}}
 356 class CHIP{{asCamelCased parent.name false}}Cluster{{asCamelCased name false}}CallbackBridge : public Callback::Callback<{{asCamelCased parent.name false}}Cluster{{asCamelCased name false}}Callback>
 357 {
 358 public:
 359     CHIP{{asCamelCased parent.name false}}Cluster{{asCamelCased name false}}CallbackBridge(ResponseHandler handler, dispatch_queue_t queue): Callback::Callback<{{asCamelCased parent.name false}}Cluster{{asCamelCased name false}}Callback>(CallbackFn, this), mHandler(handler), mQueue(queue) {}
 360
 361     ~CHIP{{asCamelCased parent.name false}}Cluster{{asCamelCased name false}}CallbackBridge() {};
 362
 363     static void CallbackFn(void * context{{#zcl_command_arguments}}{{#unless (isStrEqual label "status")}}, {{asUnderlyingZclType type}} {{asSymbol label}}{{/unless}}{{/zcl_command_arguments}})
 364     {
 365         CHIP{{asCamelCased parent.name false}}Cluster{{asCamelCased name false}}CallbackBridge * callback = reinterpret_cast<CHIP{{asCamelCased parent.name false}}Cluster{{asCamelCased name false}}CallbackBridge *>(context);
 366         if (callback && callback->mQueue)
 367         {
 368             dispatch_async(callback->mQueue, ^{
 369                 callback->mHandler(nil, @{
 370                   {{#zcl_command_arguments}}
 371                   {{#unless (isStrEqual label "status")}}
 372                   {{#if isArray}}
 373                   // {{asSymbol label}}: {{asUnderlyingZclType type}}
 374                   // Conversion from this type to Objc is not properly implemented yet
 375                   {{else if (isShortString type)}}
 376                   @"{{asSymbol label}}": [NSString stringWithFormat:@"%s", {{asSymbol label}}],
 377                   {{else}}
 378                   @"{{asSymbol label}}": [NSNumber numberWith{{asObjectiveCNumberType label type}}:{{asSymbol label}}],
 379                   {{/if}}
 380                   {{/unless}}
 381                   {{/zcl_command_arguments}}
 382                 });
 383                 callback->Cancel();
 384                 delete callback;
 385             });
 386         }
 387     };
 388
 389 private:
 390     ResponseHandler mHandler;
 391     dispatch_queue_t mQueue;
 392 };
 393
 394 {{/if}}
 395 {{/if}}
 396 {{/all_user_cluster_commands}}
 397 {{/if}}
 398 {{/if}}
 399 {{/all_user_clusters}}
 400
 401 @interface CHIPCluster ()
 402 @property (readonly, nonatomic) dispatch_queue_t callbackQueue;
 403 - (Controller::ClusterBase *)getCluster;
 404 @end
 405
 406 @implementation CHIPCluster
 407 - (instancetype)initWithDevice:(CHIPDevice *)device endpoint:(EndpointId)endpoint queue:(dispatch_queue_t)queue
 408 {
 409     if (self = [super init]) {
 410         Controller::ClusterBase * cppCluster = [self getCluster];
 411         if (cppCluster == nullptr)
 412         {
 413             return nil;
 414         }
 415
 416         CHIP_ERROR err = cppCluster->Associate([device internalDevice], endpoint);
 417         if (err != CHIP_NO_ERROR) {
 418             return nil;
 419         }
 420
 421         _callbackQueue = queue;
 422     }
 423     return self;
 424 }
 425
 426 - (Controller::ClusterBase *)getCluster
 427 {
 428     return nullptr;
 429 }
 430 @end
 431
 432
 433 {{#chip_client_clusters}}
 434
 435 @interface CHIP{{asCamelCased name false}} ()
 436 @property (readonly) Controller::{{asCamelCased name false}}Cluster cppCluster;
 437 @end
 438
 439 @implementation CHIP{{asCamelCased name false}}
 440
 441 - (Controller::ClusterBase *)getCluster
 442 {
 443     return &_cppCluster;
 444 }
 445
 446 {{#chip_server_cluster_commands}}
 447 {{#if (zcl_command_arguments_count this.id)}}
 448 - (void){{asCamelCased name}}:{{#chip_server_cluster_command_arguments}}{{#if (isFirstElement index)}}{{else}}{{asCamelCased label}}:{{/if}}({{asObjectiveCBasicType type}}){{asCamelCased label}} {{/chip_server_cluster_command_arguments}}completionHandler:(ResponseHandler)completionHandler
 449 {{else}}
 450 - (void){{asCamelCased name}}:(ResponseHandler)completionHandler
 451 {{/if}}
 452 {
 453 {{#if (hasSpecificResponse name)}}
 454     CHIP{{asCamelCased parent.name false}}Cluster{{asCamelCased name false}}ResponseCallbackBridge * onSuccess = new CHIP{{asCamelCased parent.name false}}Cluster{{asCamelCased name false}}ResponseCallbackBridge(completionHandler, [self callbackQueue]);
 455 {{else}}
 456     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
 457 {{/if}}
 458     if (!onSuccess) {
 459         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 460         return;
 461     }
 462
 463     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
 464     if (!onFailure) {
 465         delete onSuccess;
 466         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 467         return;
 468     }
 469
 470     CHIP_ERROR err = self.cppCluster.{{asCamelCased name false}}(onSuccess->Cancel(), onFailure->Cancel(){{#chip_server_cluster_command_arguments}}, {{#if (isOctetString type)}}chip::ByteSpan((const uint8_t*){{asCamelCased label}}.bytes, {{asCamelCased label}}.length){{else if (isCharString type)}}chip::ByteSpan((const uint8_t*)[{{asCamelCased label}} dataUsingEncoding:NSUTF8StringEncoding].bytes, [{{asCamelCased label}} lengthOfBytesUsingEncoding:NSUTF8StringEncoding]){{else}}{{asCamelCased label}}{{/if}}{{/chip_server_cluster_command_arguments}});
 471     if (err != CHIP_NO_ERROR) {
 472         delete onSuccess;
 473         delete onFailure;
 474         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
 475     }
 476 }
 477 {{/chip_server_cluster_commands}}
 478
 479 {{#chip_server_cluster_attributes}}
 480 - (void)readAttribute{{asCamelCased name false}}:(ResponseHandler)completionHandler
 481 {
 482     CHIP{{asCallbackAttributeType atomicTypeId}}AttributeCallbackBridge * onSuccess = new CHIP{{asCallbackAttributeType atomicTypeId}}AttributeCallbackBridge(completionHandler, [self callbackQueue]{{#if (isString type)}},{{#if (isOctetString type)}}true{{else}}false{{/if}}{{/if}});
 483     if (!onSuccess) {
 484         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 485         return;
 486     }
 487
 488     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
 489     if (!onFailure) {
 490         delete onSuccess;
 491         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 492         return;
 493     }
 494
 495     CHIP_ERROR err = self.cppCluster.ReadAttribute{{asCamelCased name false}}(onSuccess->Cancel(), onFailure->Cancel());
 496     if (err != CHIP_NO_ERROR) {
 497         delete onSuccess;
 498         delete onFailure;
 499         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
 500     }
 501 }
 502
 503 {{#if (isWritableAttribute)}}
 504 - (void)writeAttribute{{asCamelCased name false}}:({{asObjectiveCBasicType type}})value completionHandler:(ResponseHandler)completionHandler
 505 {
 506     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
 507     if (!onSuccess) {
 508         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 509         return;
 510     }
 511
 512     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
 513     if (!onFailure) {
 514         delete onSuccess;
 515         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 516         return;
 517     }
 518
 519     {{#if (isOctetString type)}}
 520     CHIP_ERROR err = self.cppCluster.WriteAttribute{{asCamelCased name false}}(onSuccess->Cancel(), onFailure->Cancel(), chip::ByteSpan((const uint8_t*)value.bytes, value.length));
 521     {{else if (isCharString type)}}
 522     NSData * data = [value dataUsingEncoding:NSUTF8StringEncoding];
 523     CHIP_ERROR err = self.cppCluster.WriteAttribute{{asCamelCased name false}}(onSuccess->Cancel(), onFailure->Cancel(), chip::ByteSpan((const uint8_t*)data.bytes, data.length));
 524     {{else}}
 525     CHIP_ERROR err = self.cppCluster.WriteAttribute{{asCamelCased name false}}(onSuccess->Cancel(), onFailure->Cancel(), value);
 526     {{/if}}
 527     if (err != CHIP_NO_ERROR) {
 528         delete onSuccess;
 529         delete onFailure;
 530         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
 531     }
 532 }
 533
 534 {{/if}}
 535 {{#if (isReportableAttribute)}}
 536 - (void) configureAttribute{{asCamelCased name false}}:(uint16_t)minInterval  maxInterval:(uint16_t)maxInterval{{#unless (isDiscreteType)}} change:({{chipType}})change{{/unless}} completionHandler:(ResponseHandler)completionHandler
 537 {
 538     CHIPDefaultSuccessCallbackBridge * onSuccess = new CHIPDefaultSuccessCallbackBridge(completionHandler, [self callbackQueue]);
 539     if (!onSuccess) {
 540         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 541         return;
 542     }
 543
 544     CHIPDefaultFailureCallbackBridge * onFailure = new CHIPDefaultFailureCallbackBridge(completionHandler, [self callbackQueue]);
 545     if (!onFailure) {
 546         delete onSuccess;
 547         completionHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 548         return;
 549     }
 550
 551
 552     CHIP_ERROR err = self.cppCluster.ConfigureAttribute{{asCamelCased name false}}(onSuccess->Cancel(), onFailure->Cancel(), minInterval, maxInterval{{#unless (isDiscreteType)}}, change{{/unless}});
 553     if (err != CHIP_NO_ERROR) {
 554         delete onSuccess;
 555         delete onFailure;
 556         completionHandler([CHIPError errorForCHIPErrorCode:err], nil);
 557     }
 558 }
 559
 560 - (void) reportAttribute{{asCamelCased name false}}:(ResponseHandler)reportHandler
 561 {
 562     CHIP{{asCallbackAttributeType atomicTypeId}}AttributeCallbackBridge * onReport = new CHIP{{asCallbackAttributeType atomicTypeId}}AttributeCallbackBridge(reportHandler, [self callbackQueue]{{#if (isString type)}},{{#if (isOctetString type)}}true{{else}}false{{/if}}{{/if}}, true);
 563     if (!onReport) {
 564         reportHandler([CHIPError errorForCHIPErrorCode:CHIP_ERROR_INCORRECT_STATE], nil);
 565         return;
 566     }
 567
 568     CHIP_ERROR err = self.cppCluster.ReportAttribute{{asCamelCased name false}}(onReport->Cancel());
 569     if (err != CHIP_NO_ERROR) {
 570         delete onReport;
 571         reportHandler([CHIPError errorForCHIPErrorCode:err], nil);
 572     }
 573 }
 574
 575 {{/if}}
 576 {{/chip_server_cluster_attributes}}
 577
 578 @end
 579
 580 {{/chip_client_clusters}}
 581 {{/if}}