src/darwin/Framework/CHIP/gen/callback.h

   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 // Prevent multiple inclusion
  21 #pragma once
  22
  23 #include "af-structs.h"
  24 #include "af-types.h"
  25 #include "basic-types.h"
  26
  27 /** @brief Cluster Init
  28  *
  29  * This function is called when a specific cluster is initialized. It gives the
  30  * application an opportunity to take care of cluster initialization procedures.
  31  * It is called exactly once for each endpoint where cluster is present.
  32  *
  33  * @param endpoint   Ver.: always
  34  * @param clusterId   Ver.: always
  35  */
  36 void emberAfClusterInitCallback(chip::EndpointId endpoint, chip::ClusterId clusterId);
  37
  38 // Cluster Init Functions
  39
  40 /** @brief Application Basic Cluster Init
  41  *
  42  * Cluster Init
  43  *
  44  * @param endpoint    Endpoint that is being initialized
  45  */
  46 void emberAfApplicationBasicClusterInitCallback(chip::EndpointId endpoint);
  47
  48 /** @brief Barrier Control Cluster Init
  49  *
  50  * Cluster Init
  51  *
  52  * @param endpoint    Endpoint that is being initialized
  53  */
  54 void emberAfBarrierControlClusterInitCallback(chip::EndpointId endpoint);
  55
  56 /** @brief Basic Cluster Init
  57  *
  58  * Cluster Init
  59  *
  60  * @param endpoint    Endpoint that is being initialized
  61  */
  62 void emberAfBasicClusterInitCallback(chip::EndpointId endpoint);
  63
  64 /** @brief Binding Cluster Init
  65  *
  66  * Cluster Init
  67  *
  68  * @param endpoint    Endpoint that is being initialized
  69  */
  70 void emberAfBindingClusterInitCallback(chip::EndpointId endpoint);
  71
  72 /** @brief Color Control Cluster Init
  73  *
  74  * Cluster Init
  75  *
  76  * @param endpoint    Endpoint that is being initialized
  77  */
  78 void emberAfColorControlClusterInitCallback(chip::EndpointId endpoint);
  79
  80 /** @brief Content Launch Cluster Init
  81  *
  82  * Cluster Init
  83  *
  84  * @param endpoint    Endpoint that is being initialized
  85  */
  86 void emberAfContentLaunchClusterInitCallback(chip::EndpointId endpoint);
  87
  88 /** @brief Door Lock Cluster Init
  89  *
  90  * Cluster Init
  91  *
  92  * @param endpoint    Endpoint that is being initialized
  93  */
  94 void emberAfDoorLockClusterInitCallback(chip::EndpointId endpoint);
  95
  96 /** @brief General Commissioning Cluster Init
  97  *
  98  * Cluster Init
  99  *
 100  * @param endpoint    Endpoint that is being initialized
 101  */
 102 void emberAfGeneralCommissioningClusterInitCallback(chip::EndpointId endpoint);
 103
 104 /** @brief Groups Cluster Init
 105  *
 106  * Cluster Init
 107  *
 108  * @param endpoint    Endpoint that is being initialized
 109  */
 110 void emberAfGroupsClusterInitCallback(chip::EndpointId endpoint);
 111
 112 /** @brief Identify Cluster Init
 113  *
 114  * Cluster Init
 115  *
 116  * @param endpoint    Endpoint that is being initialized
 117  */
 118 void emberAfIdentifyClusterInitCallback(chip::EndpointId endpoint);
 119
 120 /** @brief Level Control Cluster Init
 121  *
 122  * Cluster Init
 123  *
 124  * @param endpoint    Endpoint that is being initialized
 125  */
 126 void emberAfLevelControlClusterInitCallback(chip::EndpointId endpoint);
 127
 128 /** @brief Low Power Cluster Init
 129  *
 130  * Cluster Init
 131  *
 132  * @param endpoint    Endpoint that is being initialized
 133  */
 134 void emberAfLowPowerClusterInitCallback(chip::EndpointId endpoint);
 135
 136 /** @brief Media Playback Cluster Init
 137  *
 138  * Cluster Init
 139  *
 140  * @param endpoint    Endpoint that is being initialized
 141  */
 142 void emberAfMediaPlaybackClusterInitCallback(chip::EndpointId endpoint);
 143
 144 /** @brief On/off Cluster Init
 145  *
 146  * Cluster Init
 147  *
 148  * @param endpoint    Endpoint that is being initialized
 149  */
 150 void emberAfOnOffClusterInitCallback(chip::EndpointId endpoint);
 151
 152 /** @brief Scenes Cluster Init
 153  *
 154  * Cluster Init
 155  *
 156  * @param endpoint    Endpoint that is being initialized
 157  */
 158 void emberAfScenesClusterInitCallback(chip::EndpointId endpoint);
 159
 160 /** @brief Temperature Measurement Cluster Init
 161  *
 162  * Cluster Init
 163  *
 164  * @param endpoint    Endpoint that is being initialized
 165  */
 166 void emberAfTemperatureMeasurementClusterInitCallback(chip::EndpointId endpoint);
 167
 168 // Cluster Server/Client Init Functions
 169
 170 //
 171 // Application Basic Cluster client
 172 //
 173
 174 /** @brief Application Basic Cluster Client Init
 175  *
 176  * Client Init
 177  *
 178  * @param endpoint    Endpoint that is being initialized
 179  */
 180 void emberAfApplicationBasicClusterClientInitCallback(chip::EndpointId endpoint);
 181
 182 /** @brief Application Basic Cluster Client Attribute Changed
 183  *
 184  * Client Attribute Changed
 185  *
 186  * @param endpoint    Endpoint that is being initialized
 187  * @param attributeId Attribute that changed
 188  */
 189 void emberAfApplicationBasicClusterClientAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId);
 190
 191 /** @brief Application Basic Cluster Client Manufacturer Specific Attribute Changed
 192  *
 193  * Client Manufacturer Specific Attribute Changed
 194  *
 195  * @param endpoint          Endpoint that is being initialized
 196  * @param attributeId       Attribute that changed
 197  * @param manufacturerCode  Manufacturer Code of the attribute that changed
 198  */
 199 void emberAfApplicationBasicClusterClientManufacturerSpecificAttributeChangedCallback(chip::EndpointId endpoint,
 200                                                                                       chip::AttributeId attributeId,
 201                                                                                       uint16_t manufacturerCode);
 202
 203 /** @brief Application Basic Cluster Client Message Sent
 204  *
 205  * Client Message Sent
 206  *
 207  * @param type               The type of message sent
 208  * @param indexOrDestination The destination or address to which the message was sent
 209  * @param apsFrame           The APS frame for the message
 210  * @param msgLen             The length of the message
 211  * @param message            The message that was sent
 212  * @param status             The status of the sent message
 213  */
 214 void emberAfApplicationBasicClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint64_t indexOrDestination,
 215                                                              EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message,
 216                                                              EmberStatus status);
 217
 218 /** @brief Application Basic Cluster Client Pre Attribute Changed
 219  *
 220  * client Pre Attribute Changed
 221  *
 222  * @param endpoint      Endpoint that is being initialized
 223  * @param attributeId   Attribute to be changed
 224  * @param attributeType Attribute type
 225  * @param size          Attribute size
 226  * @param value         Attribute value
 227  */
 228 EmberAfStatus emberAfApplicationBasicClusterClientPreAttributeChangedCallback(chip::EndpointId endpoint,
 229                                                                               chip::AttributeId attributeId,
 230                                                                               EmberAfAttributeType attributeType, uint8_t size,
 231                                                                               uint8_t * value);
 232
 233 /** @brief Application Basic Cluster Client Tick
 234  *
 235  * client Tick
 236  *
 237  * @param endpoint  Endpoint that is being served
 238  */
 239 void emberAfApplicationBasicClusterClientTickCallback(chip::EndpointId endpoint);
 240
 241 //
 242 // Barrier Control Cluster client
 243 //
 244
 245 /** @brief Barrier Control Cluster Client Init
 246  *
 247  * Client Init
 248  *
 249  * @param endpoint    Endpoint that is being initialized
 250  */
 251 void emberAfBarrierControlClusterClientInitCallback(chip::EndpointId endpoint);
 252
 253 /** @brief Barrier Control Cluster Client Attribute Changed
 254  *
 255  * Client Attribute Changed
 256  *
 257  * @param endpoint    Endpoint that is being initialized
 258  * @param attributeId Attribute that changed
 259  */
 260 void emberAfBarrierControlClusterClientAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId);
 261
 262 /** @brief Barrier Control Cluster Client Manufacturer Specific Attribute Changed
 263  *
 264  * Client Manufacturer Specific Attribute Changed
 265  *
 266  * @param endpoint          Endpoint that is being initialized
 267  * @param attributeId       Attribute that changed
 268  * @param manufacturerCode  Manufacturer Code of the attribute that changed
 269  */
 270 void emberAfBarrierControlClusterClientManufacturerSpecificAttributeChangedCallback(chip::EndpointId endpoint,
 271                                                                                     chip::AttributeId attributeId,
 272                                                                                     uint16_t manufacturerCode);
 273
 274 /** @brief Barrier Control Cluster Client Message Sent
 275  *
 276  * Client Message Sent
 277  *
 278  * @param type               The type of message sent
 279  * @param indexOrDestination The destination or address to which the message was sent
 280  * @param apsFrame           The APS frame for the message
 281  * @param msgLen             The length of the message
 282  * @param message            The message that was sent
 283  * @param status             The status of the sent message
 284  */
 285 void emberAfBarrierControlClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint64_t indexOrDestination,
 286                                                            EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message,
 287                                                            EmberStatus status);
 288
 289 /** @brief Barrier Control Cluster Client Pre Attribute Changed
 290  *
 291  * client Pre Attribute Changed
 292  *
 293  * @param endpoint      Endpoint that is being initialized
 294  * @param attributeId   Attribute to be changed
 295  * @param attributeType Attribute type
 296  * @param size          Attribute size
 297  * @param value         Attribute value
 298  */
 299 EmberAfStatus emberAfBarrierControlClusterClientPreAttributeChangedCallback(chip::EndpointId endpoint,
 300                                                                             chip::AttributeId attributeId,
 301                                                                             EmberAfAttributeType attributeType, uint8_t size,
 302                                                                             uint8_t * value);
 303
 304 /** @brief Barrier Control Cluster Client Tick
 305  *
 306  * client Tick
 307  *
 308  * @param endpoint  Endpoint that is being served
 309  */
 310 void emberAfBarrierControlClusterClientTickCallback(chip::EndpointId endpoint);
 311
 312 //
 313 // Basic Cluster client
 314 //
 315
 316 /** @brief Basic Cluster Client Init
 317  *
 318  * Client Init
 319  *
 320  * @param endpoint    Endpoint that is being initialized
 321  */
 322 void emberAfBasicClusterClientInitCallback(chip::EndpointId endpoint);
 323
 324 /** @brief Basic Cluster Client Attribute Changed
 325  *
 326  * Client Attribute Changed
 327  *
 328  * @param endpoint    Endpoint that is being initialized
 329  * @param attributeId Attribute that changed
 330  */
 331 void emberAfBasicClusterClientAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId);
 332
 333 /** @brief Basic Cluster Client Manufacturer Specific Attribute Changed
 334  *
 335  * Client Manufacturer Specific Attribute Changed
 336  *
 337  * @param endpoint          Endpoint that is being initialized
 338  * @param attributeId       Attribute that changed
 339  * @param manufacturerCode  Manufacturer Code of the attribute that changed
 340  */
 341 void emberAfBasicClusterClientManufacturerSpecificAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId,
 342                                                                            uint16_t manufacturerCode);
 343
 344 /** @brief Basic Cluster Client Message Sent
 345  *
 346  * Client Message Sent
 347  *
 348  * @param type               The type of message sent
 349  * @param indexOrDestination The destination or address to which the message was sent
 350  * @param apsFrame           The APS frame for the message
 351  * @param msgLen             The length of the message
 352  * @param message            The message that was sent
 353  * @param status             The status of the sent message
 354  */
 355 void emberAfBasicClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint64_t indexOrDestination,
 356                                                   EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status);
 357
 358 /** @brief Basic Cluster Client Pre Attribute Changed
 359  *
 360  * client Pre Attribute Changed
 361  *
 362  * @param endpoint      Endpoint that is being initialized
 363  * @param attributeId   Attribute to be changed
 364  * @param attributeType Attribute type
 365  * @param size          Attribute size
 366  * @param value         Attribute value
 367  */
 368 EmberAfStatus emberAfBasicClusterClientPreAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId,
 369                                                                    EmberAfAttributeType attributeType, uint8_t size,
 370                                                                    uint8_t * value);
 371
 372 /** @brief Basic Cluster Client Tick
 373  *
 374  * client Tick
 375  *
 376  * @param endpoint  Endpoint that is being served
 377  */
 378 void emberAfBasicClusterClientTickCallback(chip::EndpointId endpoint);
 379
 380 //
 381 // Binding Cluster client
 382 //
 383
 384 /** @brief Binding Cluster Client Init
 385  *
 386  * Client Init
 387  *
 388  * @param endpoint    Endpoint that is being initialized
 389  */
 390 void emberAfBindingClusterClientInitCallback(chip::EndpointId endpoint);
 391
 392 /** @brief Binding Cluster Client Attribute Changed
 393  *
 394  * Client Attribute Changed
 395  *
 396  * @param endpoint    Endpoint that is being initialized
 397  * @param attributeId Attribute that changed
 398  */
 399 void emberAfBindingClusterClientAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId);
 400
 401 /** @brief Binding Cluster Client Manufacturer Specific Attribute Changed
 402  *
 403  * Client Manufacturer Specific Attribute Changed
 404  *
 405  * @param endpoint          Endpoint that is being initialized
 406  * @param attributeId       Attribute that changed
 407  * @param manufacturerCode  Manufacturer Code of the attribute that changed
 408  */
 409 void emberAfBindingClusterClientManufacturerSpecificAttributeChangedCallback(chip::EndpointId endpoint,
 410                                                                              chip::AttributeId attributeId,
 411                                                                              uint16_t manufacturerCode);
 412
 413 /** @brief Binding Cluster Client Message Sent
 414  *
 415  * Client Message Sent
 416  *
 417  * @param type               The type of message sent
 418  * @param indexOrDestination The destination or address to which the message was sent
 419  * @param apsFrame           The APS frame for the message
 420  * @param msgLen             The length of the message
 421  * @param message            The message that was sent
 422  * @param status             The status of the sent message
 423  */
 424 void emberAfBindingClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint64_t indexOrDestination,
 425                                                     EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message,
 426                                                     EmberStatus status);
 427
 428 /** @brief Binding Cluster Client Pre Attribute Changed
 429  *
 430  * client Pre Attribute Changed
 431  *
 432  * @param endpoint      Endpoint that is being initialized
 433  * @param attributeId   Attribute to be changed
 434  * @param attributeType Attribute type
 435  * @param size          Attribute size
 436  * @param value         Attribute value
 437  */
 438 EmberAfStatus emberAfBindingClusterClientPreAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId,
 439                                                                      EmberAfAttributeType attributeType, uint8_t size,
 440                                                                      uint8_t * value);
 441
 442 /** @brief Binding Cluster Client Tick
 443  *
 444  * client Tick
 445  *
 446  * @param endpoint  Endpoint that is being served
 447  */
 448 void emberAfBindingClusterClientTickCallback(chip::EndpointId endpoint);
 449
 450 //
 451 // Color Control Cluster client
 452 //
 453
 454 /** @brief Color Control Cluster Client Init
 455  *
 456  * Client Init
 457  *
 458  * @param endpoint    Endpoint that is being initialized
 459  */
 460 void emberAfColorControlClusterClientInitCallback(chip::EndpointId endpoint);
 461
 462 /** @brief Color Control Cluster Client Attribute Changed
 463  *
 464  * Client Attribute Changed
 465  *
 466  * @param endpoint    Endpoint that is being initialized
 467  * @param attributeId Attribute that changed
 468  */
 469 void emberAfColorControlClusterClientAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId);
 470
 471 /** @brief Color Control Cluster Client Manufacturer Specific Attribute Changed
 472  *
 473  * Client Manufacturer Specific Attribute Changed
 474  *
 475  * @param endpoint          Endpoint that is being initialized
 476  * @param attributeId       Attribute that changed
 477  * @param manufacturerCode  Manufacturer Code of the attribute that changed
 478  */
 479 void emberAfColorControlClusterClientManufacturerSpecificAttributeChangedCallback(chip::EndpointId endpoint,
 480                                                                                   chip::AttributeId attributeId,
 481                                                                                   uint16_t manufacturerCode);
 482
 483 /** @brief Color Control Cluster Client Message Sent
 484  *
 485  * Client Message Sent
 486  *
 487  * @param type               The type of message sent
 488  * @param indexOrDestination The destination or address to which the message was sent
 489  * @param apsFrame           The APS frame for the message
 490  * @param msgLen             The length of the message
 491  * @param message            The message that was sent
 492  * @param status             The status of the sent message
 493  */
 494 void emberAfColorControlClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint64_t indexOrDestination,
 495                                                          EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message,
 496                                                          EmberStatus status);
 497
 498 /** @brief Color Control Cluster Client Pre Attribute Changed
 499  *
 500  * client Pre Attribute Changed
 501  *
 502  * @param endpoint      Endpoint that is being initialized
 503  * @param attributeId   Attribute to be changed
 504  * @param attributeType Attribute type
 505  * @param size          Attribute size
 506  * @param value         Attribute value
 507  */
 508 EmberAfStatus emberAfColorControlClusterClientPreAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId,
 509                                                                           EmberAfAttributeType attributeType, uint8_t size,
 510                                                                           uint8_t * value);
 511
 512 /** @brief Color Control Cluster Client Tick
 513  *
 514  * client Tick
 515  *
 516  * @param endpoint  Endpoint that is being served
 517  */
 518 void emberAfColorControlClusterClientTickCallback(chip::EndpointId endpoint);
 519
 520 //
 521 // Content Launch Cluster client
 522 //
 523
 524 /** @brief Content Launch Cluster Client Init
 525  *
 526  * Client Init
 527  *
 528  * @param endpoint    Endpoint that is being initialized
 529  */
 530 void emberAfContentLaunchClusterClientInitCallback(chip::EndpointId endpoint);
 531
 532 /** @brief Content Launch Cluster Client Attribute Changed
 533  *
 534  * Client Attribute Changed
 535  *
 536  * @param endpoint    Endpoint that is being initialized
 537  * @param attributeId Attribute that changed
 538  */
 539 void emberAfContentLaunchClusterClientAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId);
 540
 541 /** @brief Content Launch Cluster Client Manufacturer Specific Attribute Changed
 542  *
 543  * Client Manufacturer Specific Attribute Changed
 544  *
 545  * @param endpoint          Endpoint that is being initialized
 546  * @param attributeId       Attribute that changed
 547  * @param manufacturerCode  Manufacturer Code of the attribute that changed
 548  */
 549 void emberAfContentLaunchClusterClientManufacturerSpecificAttributeChangedCallback(chip::EndpointId endpoint,
 550                                                                                    chip::AttributeId attributeId,
 551                                                                                    uint16_t manufacturerCode);
 552
 553 /** @brief Content Launch Cluster Client Message Sent
 554  *
 555  * Client Message Sent
 556  *
 557  * @param type               The type of message sent
 558  * @param indexOrDestination The destination or address to which the message was sent
 559  * @param apsFrame           The APS frame for the message
 560  * @param msgLen             The length of the message
 561  * @param message            The message that was sent
 562  * @param status             The status of the sent message
 563  */
 564 void emberAfContentLaunchClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint64_t indexOrDestination,
 565                                                           EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message,
 566                                                           EmberStatus status);
 567
 568 /** @brief Content Launch Cluster Client Pre Attribute Changed
 569  *
 570  * client Pre Attribute Changed
 571  *
 572  * @param endpoint      Endpoint that is being initialized
 573  * @param attributeId   Attribute to be changed
 574  * @param attributeType Attribute type
 575  * @param size          Attribute size
 576  * @param value         Attribute value
 577  */
 578 EmberAfStatus emberAfContentLaunchClusterClientPreAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId,
 579                                                                            EmberAfAttributeType attributeType, uint8_t size,
 580                                                                            uint8_t * value);
 581
 582 /** @brief Content Launch Cluster Client Tick
 583  *
 584  * client Tick
 585  *
 586  * @param endpoint  Endpoint that is being served
 587  */
 588 void emberAfContentLaunchClusterClientTickCallback(chip::EndpointId endpoint);
 589
 590 //
 591 // Door Lock Cluster client
 592 //
 593
 594 /** @brief Door Lock Cluster Client Init
 595  *
 596  * Client Init
 597  *
 598  * @param endpoint    Endpoint that is being initialized
 599  */
 600 void emberAfDoorLockClusterClientInitCallback(chip::EndpointId endpoint);
 601
 602 /** @brief Door Lock Cluster Client Attribute Changed
 603  *
 604  * Client Attribute Changed
 605  *
 606  * @param endpoint    Endpoint that is being initialized
 607  * @param attributeId Attribute that changed
 608  */
 609 void emberAfDoorLockClusterClientAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId);
 610
 611 /** @brief Door Lock Cluster Client Manufacturer Specific Attribute Changed
 612  *
 613  * Client Manufacturer Specific Attribute Changed
 614  *
 615  * @param endpoint          Endpoint that is being initialized
 616  * @param attributeId       Attribute that changed
 617  * @param manufacturerCode  Manufacturer Code of the attribute that changed
 618  */
 619 void emberAfDoorLockClusterClientManufacturerSpecificAttributeChangedCallback(chip::EndpointId endpoint,
 620                                                                               chip::AttributeId attributeId,
 621                                                                               uint16_t manufacturerCode);
 622
 623 /** @brief Door Lock Cluster Client Message Sent
 624  *
 625  * Client Message Sent
 626  *
 627  * @param type               The type of message sent
 628  * @param indexOrDestination The destination or address to which the message was sent
 629  * @param apsFrame           The APS frame for the message
 630  * @param msgLen             The length of the message
 631  * @param message            The message that was sent
 632  * @param status             The status of the sent message
 633  */
 634 void emberAfDoorLockClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint64_t indexOrDestination,
 635                                                      EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message,
 636                                                      EmberStatus status);
 637
 638 /** @brief Door Lock Cluster Client Pre Attribute Changed
 639  *
 640  * client Pre Attribute Changed
 641  *
 642  * @param endpoint      Endpoint that is being initialized
 643  * @param attributeId   Attribute to be changed
 644  * @param attributeType Attribute type
 645  * @param size          Attribute size
 646  * @param value         Attribute value
 647  */
 648 EmberAfStatus emberAfDoorLockClusterClientPreAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId,
 649                                                                       EmberAfAttributeType attributeType, uint8_t size,
 650                                                                       uint8_t * value);
 651
 652 /** @brief Door Lock Cluster Client Tick
 653  *
 654  * client Tick
 655  *
 656  * @param endpoint  Endpoint that is being served
 657  */
 658 void emberAfDoorLockClusterClientTickCallback(chip::EndpointId endpoint);
 659
 660 //
 661 // General Commissioning Cluster client
 662 //
 663
 664 /** @brief General Commissioning Cluster Client Init
 665  *
 666  * Client Init
 667  *
 668  * @param endpoint    Endpoint that is being initialized
 669  */
 670 void emberAfGeneralCommissioningClusterClientInitCallback(chip::EndpointId endpoint);
 671
 672 /** @brief General Commissioning Cluster Client Attribute Changed
 673  *
 674  * Client Attribute Changed
 675  *
 676  * @param endpoint    Endpoint that is being initialized
 677  * @param attributeId Attribute that changed
 678  */
 679 void emberAfGeneralCommissioningClusterClientAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId);
 680
 681 /** @brief General Commissioning Cluster Client Manufacturer Specific Attribute Changed
 682  *
 683  * Client Manufacturer Specific Attribute Changed
 684  *
 685  * @param endpoint          Endpoint that is being initialized
 686  * @param attributeId       Attribute that changed
 687  * @param manufacturerCode  Manufacturer Code of the attribute that changed
 688  */
 689 void emberAfGeneralCommissioningClusterClientManufacturerSpecificAttributeChangedCallback(chip::EndpointId endpoint,
 690                                                                                           chip::AttributeId attributeId,
 691                                                                                           uint16_t manufacturerCode);
 692
 693 /** @brief General Commissioning Cluster Client Message Sent
 694  *
 695  * Client Message Sent
 696  *
 697  * @param type               The type of message sent
 698  * @param indexOrDestination The destination or address to which the message was sent
 699  * @param apsFrame           The APS frame for the message
 700  * @param msgLen             The length of the message
 701  * @param message            The message that was sent
 702  * @param status             The status of the sent message
 703  */
 704 void emberAfGeneralCommissioningClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint64_t indexOrDestination,
 705                                                                  EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message,
 706                                                                  EmberStatus status);
 707
 708 /** @brief General Commissioning Cluster Client Pre Attribute Changed
 709  *
 710  * client Pre Attribute Changed
 711  *
 712  * @param endpoint      Endpoint that is being initialized
 713  * @param attributeId   Attribute to be changed
 714  * @param attributeType Attribute type
 715  * @param size          Attribute size
 716  * @param value         Attribute value
 717  */
 718 EmberAfStatus emberAfGeneralCommissioningClusterClientPreAttributeChangedCallback(chip::EndpointId endpoint,
 719                                                                                   chip::AttributeId attributeId,
 720                                                                                   EmberAfAttributeType attributeType, uint8_t size,
 721                                                                                   uint8_t * value);
 722
 723 /** @brief General Commissioning Cluster Client Tick
 724  *
 725  * client Tick
 726  *
 727  * @param endpoint  Endpoint that is being served
 728  */
 729 void emberAfGeneralCommissioningClusterClientTickCallback(chip::EndpointId endpoint);
 730
 731 //
 732 // Groups Cluster client
 733 //
 734
 735 /** @brief Groups Cluster Client Init
 736  *
 737  * Client Init
 738  *
 739  * @param endpoint    Endpoint that is being initialized
 740  */
 741 void emberAfGroupsClusterClientInitCallback(chip::EndpointId endpoint);
 742
 743 /** @brief Groups Cluster Client Attribute Changed
 744  *
 745  * Client Attribute Changed
 746  *
 747  * @param endpoint    Endpoint that is being initialized
 748  * @param attributeId Attribute that changed
 749  */
 750 void emberAfGroupsClusterClientAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId);
 751
 752 /** @brief Groups Cluster Client Manufacturer Specific Attribute Changed
 753  *
 754  * Client Manufacturer Specific Attribute Changed
 755  *
 756  * @param endpoint          Endpoint that is being initialized
 757  * @param attributeId       Attribute that changed
 758  * @param manufacturerCode  Manufacturer Code of the attribute that changed
 759  */
 760 void emberAfGroupsClusterClientManufacturerSpecificAttributeChangedCallback(chip::EndpointId endpoint,
 761                                                                             chip::AttributeId attributeId,
 762                                                                             uint16_t manufacturerCode);
 763
 764 /** @brief Groups Cluster Client Message Sent
 765  *
 766  * Client Message Sent
 767  *
 768  * @param type               The type of message sent
 769  * @param indexOrDestination The destination or address to which the message was sent
 770  * @param apsFrame           The APS frame for the message
 771  * @param msgLen             The length of the message
 772  * @param message            The message that was sent
 773  * @param status             The status of the sent message
 774  */
 775 void emberAfGroupsClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint64_t indexOrDestination,
 776                                                    EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message,
 777                                                    EmberStatus status);
 778
 779 /** @brief Groups Cluster Client Pre Attribute Changed
 780  *
 781  * client Pre Attribute Changed
 782  *
 783  * @param endpoint      Endpoint that is being initialized
 784  * @param attributeId   Attribute to be changed
 785  * @param attributeType Attribute type
 786  * @param size          Attribute size
 787  * @param value         Attribute value
 788  */
 789 EmberAfStatus emberAfGroupsClusterClientPreAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId,
 790                                                                     EmberAfAttributeType attributeType, uint8_t size,
 791                                                                     uint8_t * value);
 792
 793 /** @brief Groups Cluster Client Tick
 794  *
 795  * client Tick
 796  *
 797  * @param endpoint  Endpoint that is being served
 798  */
 799 void emberAfGroupsClusterClientTickCallback(chip::EndpointId endpoint);
 800
 801 //
 802 // Identify Cluster client
 803 //
 804
 805 /** @brief Identify Cluster Client Init
 806  *
 807  * Client Init
 808  *
 809  * @param endpoint    Endpoint that is being initialized
 810  */
 811 void emberAfIdentifyClusterClientInitCallback(chip::EndpointId endpoint);
 812
 813 /** @brief Identify Cluster Client Attribute Changed
 814  *
 815  * Client Attribute Changed
 816  *
 817  * @param endpoint    Endpoint that is being initialized
 818  * @param attributeId Attribute that changed
 819  */
 820 void emberAfIdentifyClusterClientAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId);
 821
 822 /** @brief Identify Cluster Client Manufacturer Specific Attribute Changed
 823  *
 824  * Client Manufacturer Specific Attribute Changed
 825  *
 826  * @param endpoint          Endpoint that is being initialized
 827  * @param attributeId       Attribute that changed
 828  * @param manufacturerCode  Manufacturer Code of the attribute that changed
 829  */
 830 void emberAfIdentifyClusterClientManufacturerSpecificAttributeChangedCallback(chip::EndpointId endpoint,
 831                                                                               chip::AttributeId attributeId,
 832                                                                               uint16_t manufacturerCode);
 833
 834 /** @brief Identify Cluster Client Message Sent
 835  *
 836  * Client Message Sent
 837  *
 838  * @param type               The type of message sent
 839  * @param indexOrDestination The destination or address to which the message was sent
 840  * @param apsFrame           The APS frame for the message
 841  * @param msgLen             The length of the message
 842  * @param message            The message that was sent
 843  * @param status             The status of the sent message
 844  */
 845 void emberAfIdentifyClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint64_t indexOrDestination,
 846                                                      EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message,
 847                                                      EmberStatus status);
 848
 849 /** @brief Identify Cluster Client Pre Attribute Changed
 850  *
 851  * client Pre Attribute Changed
 852  *
 853  * @param endpoint      Endpoint that is being initialized
 854  * @param attributeId   Attribute to be changed
 855  * @param attributeType Attribute type
 856  * @param size          Attribute size
 857  * @param value         Attribute value
 858  */
 859 EmberAfStatus emberAfIdentifyClusterClientPreAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId,
 860                                                                       EmberAfAttributeType attributeType, uint8_t size,
 861                                                                       uint8_t * value);
 862
 863 /** @brief Identify Cluster Client Tick
 864  *
 865  * client Tick
 866  *
 867  * @param endpoint  Endpoint that is being served
 868  */
 869 void emberAfIdentifyClusterClientTickCallback(chip::EndpointId endpoint);
 870
 871 //
 872 // Level Control Cluster client
 873 //
 874
 875 /** @brief Level Control Cluster Client Init
 876  *
 877  * Client Init
 878  *
 879  * @param endpoint    Endpoint that is being initialized
 880  */
 881 void emberAfLevelControlClusterClientInitCallback(chip::EndpointId endpoint);
 882
 883 /** @brief Level Control Cluster Client Attribute Changed
 884  *
 885  * Client Attribute Changed
 886  *
 887  * @param endpoint    Endpoint that is being initialized
 888  * @param attributeId Attribute that changed
 889  */
 890 void emberAfLevelControlClusterClientAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId);
 891
 892 /** @brief Level Control Cluster Client Manufacturer Specific Attribute Changed
 893  *
 894  * Client Manufacturer Specific Attribute Changed
 895  *
 896  * @param endpoint          Endpoint that is being initialized
 897  * @param attributeId       Attribute that changed
 898  * @param manufacturerCode  Manufacturer Code of the attribute that changed
 899  */
 900 void emberAfLevelControlClusterClientManufacturerSpecificAttributeChangedCallback(chip::EndpointId endpoint,
 901                                                                                   chip::AttributeId attributeId,
 902                                                                                   uint16_t manufacturerCode);
 903
 904 /** @brief Level Control Cluster Client Message Sent
 905  *
 906  * Client Message Sent
 907  *
 908  * @param type               The type of message sent
 909  * @param indexOrDestination The destination or address to which the message was sent
 910  * @param apsFrame           The APS frame for the message
 911  * @param msgLen             The length of the message
 912  * @param message            The message that was sent
 913  * @param status             The status of the sent message
 914  */
 915 void emberAfLevelControlClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint64_t indexOrDestination,
 916                                                          EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message,
 917                                                          EmberStatus status);
 918
 919 /** @brief Level Control Cluster Client Pre Attribute Changed
 920  *
 921  * client Pre Attribute Changed
 922  *
 923  * @param endpoint      Endpoint that is being initialized
 924  * @param attributeId   Attribute to be changed
 925  * @param attributeType Attribute type
 926  * @param size          Attribute size
 927  * @param value         Attribute value
 928  */
 929 EmberAfStatus emberAfLevelControlClusterClientPreAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId,
 930                                                                           EmberAfAttributeType attributeType, uint8_t size,
 931                                                                           uint8_t * value);
 932
 933 /** @brief Level Control Cluster Client Tick
 934  *
 935  * client Tick
 936  *
 937  * @param endpoint  Endpoint that is being served
 938  */
 939 void emberAfLevelControlClusterClientTickCallback(chip::EndpointId endpoint);
 940
 941 //
 942 // Low Power Cluster client
 943 //
 944
 945 /** @brief Low Power Cluster Client Init
 946  *
 947  * Client Init
 948  *
 949  * @param endpoint    Endpoint that is being initialized
 950  */
 951 void emberAfLowPowerClusterClientInitCallback(chip::EndpointId endpoint);
 952
 953 /** @brief Low Power Cluster Client Attribute Changed
 954  *
 955  * Client Attribute Changed
 956  *
 957  * @param endpoint    Endpoint that is being initialized
 958  * @param attributeId Attribute that changed
 959  */
 960 void emberAfLowPowerClusterClientAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId);
 961
 962 /** @brief Low Power Cluster Client Manufacturer Specific Attribute Changed
 963  *
 964  * Client Manufacturer Specific Attribute Changed
 965  *
 966  * @param endpoint          Endpoint that is being initialized
 967  * @param attributeId       Attribute that changed
 968  * @param manufacturerCode  Manufacturer Code of the attribute that changed
 969  */
 970 void emberAfLowPowerClusterClientManufacturerSpecificAttributeChangedCallback(chip::EndpointId endpoint,
 971                                                                               chip::AttributeId attributeId,
 972                                                                               uint16_t manufacturerCode);
 973
 974 /** @brief Low Power Cluster Client Message Sent
 975  *
 976  * Client Message Sent
 977  *
 978  * @param type               The type of message sent
 979  * @param indexOrDestination The destination or address to which the message was sent
 980  * @param apsFrame           The APS frame for the message
 981  * @param msgLen             The length of the message
 982  * @param message            The message that was sent
 983  * @param status             The status of the sent message
 984  */
 985 void emberAfLowPowerClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint64_t indexOrDestination,
 986                                                      EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message,
 987                                                      EmberStatus status);
 988
 989 /** @brief Low Power Cluster Client Pre Attribute Changed
 990  *
 991  * client Pre Attribute Changed
 992  *
 993  * @param endpoint      Endpoint that is being initialized
 994  * @param attributeId   Attribute to be changed
 995  * @param attributeType Attribute type
 996  * @param size          Attribute size
 997  * @param value         Attribute value
 998  */
 999 EmberAfStatus emberAfLowPowerClusterClientPreAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId,
1000                                                                       EmberAfAttributeType attributeType, uint8_t size,
1001                                                                       uint8_t * value);
1002
1003 /** @brief Low Power Cluster Client Tick
1004  *
1005  * client Tick
1006  *
1007  * @param endpoint  Endpoint that is being served
1008  */
1009 void emberAfLowPowerClusterClientTickCallback(chip::EndpointId endpoint);
1010
1011 //
1012 // Media Playback Cluster client
1013 //
1014
1015 /** @brief Media Playback Cluster Client Init
1016  *
1017  * Client Init
1018  *
1019  * @param endpoint    Endpoint that is being initialized
1020  */
1021 void emberAfMediaPlaybackClusterClientInitCallback(chip::EndpointId endpoint);
1022
1023 /** @brief Media Playback Cluster Client Attribute Changed
1024  *
1025  * Client Attribute Changed
1026  *
1027  * @param endpoint    Endpoint that is being initialized
1028  * @param attributeId Attribute that changed
1029  */
1030 void emberAfMediaPlaybackClusterClientAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId);
1031
1032 /** @brief Media Playback Cluster Client Manufacturer Specific Attribute Changed
1033  *
1034  * Client Manufacturer Specific Attribute Changed
1035  *
1036  * @param endpoint          Endpoint that is being initialized
1037  * @param attributeId       Attribute that changed
1038  * @param manufacturerCode  Manufacturer Code of the attribute that changed
1039  */
1040 void emberAfMediaPlaybackClusterClientManufacturerSpecificAttributeChangedCallback(chip::EndpointId endpoint,
1041                                                                                    chip::AttributeId attributeId,
1042                                                                                    uint16_t manufacturerCode);
1043
1044 /** @brief Media Playback Cluster Client Message Sent
1045  *
1046  * Client Message Sent
1047  *
1048  * @param type               The type of message sent
1049  * @param indexOrDestination The destination or address to which the message was sent
1050  * @param apsFrame           The APS frame for the message
1051  * @param msgLen             The length of the message
1052  * @param message            The message that was sent
1053  * @param status             The status of the sent message
1054  */
1055 void emberAfMediaPlaybackClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint64_t indexOrDestination,
1056                                                           EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message,
1057                                                           EmberStatus status);
1058
1059 /** @brief Media Playback Cluster Client Pre Attribute Changed
1060  *
1061  * client Pre Attribute Changed
1062  *
1063  * @param endpoint      Endpoint that is being initialized
1064  * @param attributeId   Attribute to be changed
1065  * @param attributeType Attribute type
1066  * @param size          Attribute size
1067  * @param value         Attribute value
1068  */
1069 EmberAfStatus emberAfMediaPlaybackClusterClientPreAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId,
1070                                                                            EmberAfAttributeType attributeType, uint8_t size,
1071                                                                            uint8_t * value);
1072
1073 /** @brief Media Playback Cluster Client Tick
1074  *
1075  * client Tick
1076  *
1077  * @param endpoint  Endpoint that is being served
1078  */
1079 void emberAfMediaPlaybackClusterClientTickCallback(chip::EndpointId endpoint);
1080
1081 //
1082 // On/off Cluster client
1083 //
1084
1085 /** @brief On/off Cluster Client Init
1086  *
1087  * Client Init
1088  *
1089  * @param endpoint    Endpoint that is being initialized
1090  */
1091 void emberAfOnOffClusterClientInitCallback(chip::EndpointId endpoint);
1092
1093 /** @brief On/off Cluster Client Attribute Changed
1094  *
1095  * Client Attribute Changed
1096  *
1097  * @param endpoint    Endpoint that is being initialized
1098  * @param attributeId Attribute that changed
1099  */
1100 void emberAfOnOffClusterClientAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId);
1101
1102 /** @brief On/off Cluster Client Manufacturer Specific Attribute Changed
1103  *
1104  * Client Manufacturer Specific Attribute Changed
1105  *
1106  * @param endpoint          Endpoint that is being initialized
1107  * @param attributeId       Attribute that changed
1108  * @param manufacturerCode  Manufacturer Code of the attribute that changed
1109  */
1110 void emberAfOnOffClusterClientManufacturerSpecificAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId,
1111                                                                            uint16_t manufacturerCode);
1112
1113 /** @brief On/off Cluster Client Message Sent
1114  *
1115  * Client Message Sent
1116  *
1117  * @param type               The type of message sent
1118  * @param indexOrDestination The destination or address to which the message was sent
1119  * @param apsFrame           The APS frame for the message
1120  * @param msgLen             The length of the message
1121  * @param message            The message that was sent
1122  * @param status             The status of the sent message
1123  */
1124 void emberAfOnOffClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint64_t indexOrDestination,
1125                                                   EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status);
1126
1127 /** @brief On/off Cluster Client Pre Attribute Changed
1128  *
1129  * client Pre Attribute Changed
1130  *
1131  * @param endpoint      Endpoint that is being initialized
1132  * @param attributeId   Attribute to be changed
1133  * @param attributeType Attribute type
1134  * @param size          Attribute size
1135  * @param value         Attribute value
1136  */
1137 EmberAfStatus emberAfOnOffClusterClientPreAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId,
1138                                                                    EmberAfAttributeType attributeType, uint8_t size,
1139                                                                    uint8_t * value);
1140
1141 /** @brief On/off Cluster Client Tick
1142  *
1143  * client Tick
1144  *
1145  * @param endpoint  Endpoint that is being served
1146  */
1147 void emberAfOnOffClusterClientTickCallback(chip::EndpointId endpoint);
1148
1149 //
1150 // Scenes Cluster client
1151 //
1152
1153 /** @brief Scenes Cluster Client Init
1154  *
1155  * Client Init
1156  *
1157  * @param endpoint    Endpoint that is being initialized
1158  */
1159 void emberAfScenesClusterClientInitCallback(chip::EndpointId endpoint);
1160
1161 /** @brief Scenes Cluster Client Attribute Changed
1162  *
1163  * Client Attribute Changed
1164  *
1165  * @param endpoint    Endpoint that is being initialized
1166  * @param attributeId Attribute that changed
1167  */
1168 void emberAfScenesClusterClientAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId);
1169
1170 /** @brief Scenes Cluster Client Manufacturer Specific Attribute Changed
1171  *
1172  * Client Manufacturer Specific Attribute Changed
1173  *
1174  * @param endpoint          Endpoint that is being initialized
1175  * @param attributeId       Attribute that changed
1176  * @param manufacturerCode  Manufacturer Code of the attribute that changed
1177  */
1178 void emberAfScenesClusterClientManufacturerSpecificAttributeChangedCallback(chip::EndpointId endpoint,
1179                                                                             chip::AttributeId attributeId,
1180                                                                             uint16_t manufacturerCode);
1181
1182 /** @brief Scenes Cluster Client Message Sent
1183  *
1184  * Client Message Sent
1185  *
1186  * @param type               The type of message sent
1187  * @param indexOrDestination The destination or address to which the message was sent
1188  * @param apsFrame           The APS frame for the message
1189  * @param msgLen             The length of the message
1190  * @param message            The message that was sent
1191  * @param status             The status of the sent message
1192  */
1193 void emberAfScenesClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint64_t indexOrDestination,
1194                                                    EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message,
1195                                                    EmberStatus status);
1196
1197 /** @brief Scenes Cluster Client Pre Attribute Changed
1198  *
1199  * client Pre Attribute Changed
1200  *
1201  * @param endpoint      Endpoint that is being initialized
1202  * @param attributeId   Attribute to be changed
1203  * @param attributeType Attribute type
1204  * @param size          Attribute size
1205  * @param value         Attribute value
1206  */
1207 EmberAfStatus emberAfScenesClusterClientPreAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId,
1208                                                                     EmberAfAttributeType attributeType, uint8_t size,
1209                                                                     uint8_t * value);
1210
1211 /** @brief Scenes Cluster Client Tick
1212  *
1213  * client Tick
1214  *
1215  * @param endpoint  Endpoint that is being served
1216  */
1217 void emberAfScenesClusterClientTickCallback(chip::EndpointId endpoint);
1218
1219 //
1220 // Temperature Measurement Cluster client
1221 //
1222
1223 /** @brief Temperature Measurement Cluster Client Init
1224  *
1225  * Client Init
1226  *
1227  * @param endpoint    Endpoint that is being initialized
1228  */
1229 void emberAfTemperatureMeasurementClusterClientInitCallback(chip::EndpointId endpoint);
1230
1231 /** @brief Temperature Measurement Cluster Client Attribute Changed
1232  *
1233  * Client Attribute Changed
1234  *
1235  * @param endpoint    Endpoint that is being initialized
1236  * @param attributeId Attribute that changed
1237  */
1238 void emberAfTemperatureMeasurementClusterClientAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId);
1239
1240 /** @brief Temperature Measurement Cluster Client Manufacturer Specific Attribute Changed
1241  *
1242  * Client Manufacturer Specific Attribute Changed
1243  *
1244  * @param endpoint          Endpoint that is being initialized
1245  * @param attributeId       Attribute that changed
1246  * @param manufacturerCode  Manufacturer Code of the attribute that changed
1247  */
1248 void emberAfTemperatureMeasurementClusterClientManufacturerSpecificAttributeChangedCallback(chip::EndpointId endpoint,
1249                                                                                             chip::AttributeId attributeId,
1250                                                                                             uint16_t manufacturerCode);
1251
1252 /** @brief Temperature Measurement Cluster Client Message Sent
1253  *
1254  * Client Message Sent
1255  *
1256  * @param type               The type of message sent
1257  * @param indexOrDestination The destination or address to which the message was sent
1258  * @param apsFrame           The APS frame for the message
1259  * @param msgLen             The length of the message
1260  * @param message            The message that was sent
1261  * @param status             The status of the sent message
1262  */
1263 void emberAfTemperatureMeasurementClusterClientMessageSentCallback(EmberOutgoingMessageType type, uint64_t indexOrDestination,
1264                                                                    EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message,
1265                                                                    EmberStatus status);
1266
1267 /** @brief Temperature Measurement Cluster Client Pre Attribute Changed
1268  *
1269  * client Pre Attribute Changed
1270  *
1271  * @param endpoint      Endpoint that is being initialized
1272  * @param attributeId   Attribute to be changed
1273  * @param attributeType Attribute type
1274  * @param size          Attribute size
1275  * @param value         Attribute value
1276  */
1277 EmberAfStatus emberAfTemperatureMeasurementClusterClientPreAttributeChangedCallback(chip::EndpointId endpoint,
1278                                                                                     chip::AttributeId attributeId,
1279                                                                                     EmberAfAttributeType attributeType,
1280                                                                                     uint8_t size, uint8_t * value);
1281
1282 /** @brief Temperature Measurement Cluster Client Tick
1283  *
1284  * client Tick
1285  *
1286  * @param endpoint  Endpoint that is being served
1287  */
1288 void emberAfTemperatureMeasurementClusterClientTickCallback(chip::EndpointId endpoint);
1289
1290 // Cluster Commands Callback
1291
1292 /**
1293  * @brief Content Launch Cluster LaunchContentResponse Command callback
1294  * @param contentLaunchStatus
1295  */
1296
1297 bool emberAfContentLaunchClusterLaunchContentResponseCallback(uint8_t contentLaunchStatus);
1298
1299 /**
1300  * @brief Content Launch Cluster LaunchURLResponse Command callback
1301  * @param contentLaunchStatus
1302  */
1303
1304 bool emberAfContentLaunchClusterLaunchURLResponseCallback(uint8_t contentLaunchStatus);
1305
1306 /**
1307  * @brief Door Lock Cluster ClearAllPinsResponse Command callback
1308  * @param status
1309  */
1310
1311 bool emberAfDoorLockClusterClearAllPinsResponseCallback(uint8_t status);
1312
1313 /**
1314  * @brief Door Lock Cluster ClearAllRfidsResponse Command callback
1315  * @param status
1316  */
1317
1318 bool emberAfDoorLockClusterClearAllRfidsResponseCallback(uint8_t status);
1319
1320 /**
1321  * @brief Door Lock Cluster ClearHolidayScheduleResponse Command callback
1322  * @param status
1323  */
1324
1325 bool emberAfDoorLockClusterClearHolidayScheduleResponseCallback(uint8_t status);
1326
1327 /**
1328  * @brief Door Lock Cluster ClearPinResponse Command callback
1329  * @param status
1330  */
1331
1332 bool emberAfDoorLockClusterClearPinResponseCallback(uint8_t status);
1333
1334 /**
1335  * @brief Door Lock Cluster ClearRfidResponse Command callback
1336  * @param status
1337  */
1338
1339 bool emberAfDoorLockClusterClearRfidResponseCallback(uint8_t status);
1340
1341 /**
1342  * @brief Door Lock Cluster ClearWeekdayScheduleResponse Command callback
1343  * @param status
1344  */
1345
1346 bool emberAfDoorLockClusterClearWeekdayScheduleResponseCallback(uint8_t status);
1347
1348 /**
1349  * @brief Door Lock Cluster ClearYeardayScheduleResponse Command callback
1350  * @param status
1351  */
1352
1353 bool emberAfDoorLockClusterClearYeardayScheduleResponseCallback(uint8_t status);
1354
1355 /**
1356  * @brief Door Lock Cluster GetHolidayScheduleResponse Command callback
1357  * @param scheduleId
1358  * @param status
1359  * @param localStartTime
1360  * @param localEndTime
1361  * @param operatingModeDuringHoliday
1362  */
1363
1364 bool emberAfDoorLockClusterGetHolidayScheduleResponseCallback(uint8_t scheduleId, uint8_t status, uint32_t localStartTime,
1365                                                               uint32_t localEndTime, uint8_t operatingModeDuringHoliday);
1366
1367 /**
1368  * @brief Door Lock Cluster GetLogRecordResponse Command callback
1369  * @param logEntryId
1370  * @param timestamp
1371  * @param eventType
1372  * @param source
1373  * @param eventIdOrAlarmCode
1374  * @param userId
1375  * @param pin
1376  */
1377
1378 bool emberAfDoorLockClusterGetLogRecordResponseCallback(uint16_t logEntryId, uint32_t timestamp, uint8_t eventType, uint8_t source,
1379                                                         uint8_t eventIdOrAlarmCode, uint16_t userId, uint8_t * pin);
1380
1381 /**
1382  * @brief Door Lock Cluster GetPinResponse Command callback
1383  * @param userId
1384  * @param userStatus
1385  * @param userType
1386  * @param pin
1387  */
1388
1389 bool emberAfDoorLockClusterGetPinResponseCallback(uint16_t userId, uint8_t userStatus, uint8_t userType, uint8_t * pin);
1390
1391 /**
1392  * @brief Door Lock Cluster GetRfidResponse Command callback
1393  * @param userId
1394  * @param userStatus
1395  * @param userType
1396  * @param rfid
1397  */
1398
1399 bool emberAfDoorLockClusterGetRfidResponseCallback(uint16_t userId, uint8_t userStatus, uint8_t userType, uint8_t * rfid);
1400
1401 /**
1402  * @brief Door Lock Cluster GetUserTypeResponse Command callback
1403  * @param userId
1404  * @param userType
1405  */
1406
1407 bool emberAfDoorLockClusterGetUserTypeResponseCallback(uint16_t userId, uint8_t userType);
1408
1409 /**
1410  * @brief Door Lock Cluster GetWeekdayScheduleResponse Command callback
1411  * @param scheduleId
1412  * @param userId
1413  * @param status
1414  * @param daysMask
1415  * @param startHour
1416  * @param startMinute
1417  * @param endHour
1418  * @param endMinute
1419  */
1420
1421 bool emberAfDoorLockClusterGetWeekdayScheduleResponseCallback(uint8_t scheduleId, uint16_t userId, uint8_t status, uint8_t daysMask,
1422                                                               uint8_t startHour, uint8_t startMinute, uint8_t endHour,
1423                                                               uint8_t endMinute);
1424
1425 /**
1426  * @brief Door Lock Cluster GetYeardayScheduleResponse Command callback
1427  * @param scheduleId
1428  * @param userId
1429  * @param status
1430  * @param localStartTime
1431  * @param localEndTime
1432  */
1433
1434 bool emberAfDoorLockClusterGetYeardayScheduleResponseCallback(uint8_t scheduleId, uint16_t userId, uint8_t status,
1435                                                               uint32_t localStartTime, uint32_t localEndTime);
1436
1437 /**
1438  * @brief Door Lock Cluster LockDoorResponse Command callback
1439  * @param status
1440  */
1441
1442 bool emberAfDoorLockClusterLockDoorResponseCallback(uint8_t status);
1443
1444 /**
1445  * @brief Door Lock Cluster SetHolidayScheduleResponse Command callback
1446  * @param status
1447  */
1448
1449 bool emberAfDoorLockClusterSetHolidayScheduleResponseCallback(uint8_t status);
1450
1451 /**
1452  * @brief Door Lock Cluster SetPinResponse Command callback
1453  * @param status
1454  */
1455
1456 bool emberAfDoorLockClusterSetPinResponseCallback(uint8_t status);
1457
1458 /**
1459  * @brief Door Lock Cluster SetRfidResponse Command callback
1460  * @param status
1461  */
1462
1463 bool emberAfDoorLockClusterSetRfidResponseCallback(uint8_t status);
1464
1465 /**
1466  * @brief Door Lock Cluster SetUserTypeResponse Command callback
1467  * @param status
1468  */
1469
1470 bool emberAfDoorLockClusterSetUserTypeResponseCallback(uint8_t status);
1471
1472 /**
1473  * @brief Door Lock Cluster SetWeekdayScheduleResponse Command callback
1474  * @param status
1475  */
1476
1477 bool emberAfDoorLockClusterSetWeekdayScheduleResponseCallback(uint8_t status);
1478
1479 /**
1480  * @brief Door Lock Cluster SetYeardayScheduleResponse Command callback
1481  * @param status
1482  */
1483
1484 bool emberAfDoorLockClusterSetYeardayScheduleResponseCallback(uint8_t status);
1485
1486 /**
1487  * @brief Door Lock Cluster UnlockDoorResponse Command callback
1488  * @param status
1489  */
1490
1491 bool emberAfDoorLockClusterUnlockDoorResponseCallback(uint8_t status);
1492
1493 /**
1494  * @brief Door Lock Cluster UnlockWithTimeoutResponse Command callback
1495  * @param status
1496  */
1497
1498 bool emberAfDoorLockClusterUnlockWithTimeoutResponseCallback(uint8_t status);
1499
1500 /**
1501  * @brief General Commissioning Cluster ArmFailSafeResponse Command callback
1502  * @param errorCode
1503  * @param debugText
1504  */
1505
1506 bool emberAfGeneralCommissioningClusterArmFailSafeResponseCallback(uint8_t errorCode, uint8_t * debugText);
1507
1508 /**
1509  * @brief General Commissioning Cluster CommissioningCompleteResponse Command callback
1510  * @param errorCode
1511  * @param debugText
1512  */
1513
1514 bool emberAfGeneralCommissioningClusterCommissioningCompleteResponseCallback(uint8_t errorCode, uint8_t * debugText);
1515
1516 /**
1517  * @brief General Commissioning Cluster SetFabricResponse Command callback
1518  * @param errorCode
1519  * @param debugText
1520  */
1521
1522 bool emberAfGeneralCommissioningClusterSetFabricResponseCallback(uint8_t errorCode, uint8_t * debugText);
1523
1524 /**
1525  * @brief Groups Cluster AddGroupResponse Command callback
1526  * @param status
1527  * @param groupId
1528  */
1529
1530 bool emberAfGroupsClusterAddGroupResponseCallback(uint8_t status, uint16_t groupId);
1531
1532 /**
1533  * @brief Groups Cluster GetGroupMembershipResponse Command callback
1534  * @param capacity
1535  * @param groupCount
1536  * @param groupList
1537  */
1538
1539 bool emberAfGroupsClusterGetGroupMembershipResponseCallback(uint8_t capacity, uint8_t groupCount,
1540                                                             /* TYPE WARNING: array array defaults to */ uint8_t * groupList);
1541
1542 /**
1543  * @brief Groups Cluster RemoveGroupResponse Command callback
1544  * @param status
1545  * @param groupId
1546  */
1547
1548 bool emberAfGroupsClusterRemoveGroupResponseCallback(uint8_t status, uint16_t groupId);
1549
1550 /**
1551  * @brief Groups Cluster ViewGroupResponse Command callback
1552  * @param status
1553  * @param groupId
1554  * @param groupName
1555  */
1556
1557 bool emberAfGroupsClusterViewGroupResponseCallback(uint8_t status, uint16_t groupId, uint8_t * groupName);
1558
1559 /**
1560  * @brief Identify Cluster IdentifyQueryResponse Command callback
1561  * @param timeout
1562  */
1563
1564 bool emberAfIdentifyClusterIdentifyQueryResponseCallback(uint16_t timeout);
1565
1566 /**
1567  * @brief Media Playback Cluster Playback Command callback
1568  */
1569
1570 bool emberAfMediaPlaybackClusterPlaybackCallback();
1571
1572 /**
1573  * @brief Scenes Cluster AddSceneResponse Command callback
1574  * @param status
1575  * @param groupId
1576  * @param sceneId
1577  */
1578
1579 bool emberAfScenesClusterAddSceneResponseCallback(uint8_t status, uint16_t groupId, uint8_t sceneId);
1580
1581 /**
1582  * @brief Scenes Cluster GetSceneMembershipResponse Command callback
1583  * @param status
1584  * @param capacity
1585  * @param groupId
1586  * @param sceneCount
1587  * @param sceneList
1588  */
1589
1590 bool emberAfScenesClusterGetSceneMembershipResponseCallback(uint8_t status, uint8_t capacity, uint16_t groupId, uint8_t sceneCount,
1591                                                             /* TYPE WARNING: array array defaults to */ uint8_t * sceneList);
1592
1593 /**
1594  * @brief Scenes Cluster RemoveAllScenesResponse Command callback
1595  * @param status
1596  * @param groupId
1597  */
1598
1599 bool emberAfScenesClusterRemoveAllScenesResponseCallback(uint8_t status, uint16_t groupId);
1600
1601 /**
1602  * @brief Scenes Cluster RemoveSceneResponse Command callback
1603  * @param status
1604  * @param groupId
1605  * @param sceneId
1606  */
1607
1608 bool emberAfScenesClusterRemoveSceneResponseCallback(uint8_t status, uint16_t groupId, uint8_t sceneId);
1609
1610 /**
1611  * @brief Scenes Cluster StoreSceneResponse Command callback
1612  * @param status
1613  * @param groupId
1614  * @param sceneId
1615  */
1616
1617 bool emberAfScenesClusterStoreSceneResponseCallback(uint8_t status, uint16_t groupId, uint8_t sceneId);
1618
1619 /**
1620  * @brief Scenes Cluster ViewSceneResponse Command callback
1621  * @param status
1622  * @param groupId
1623  * @param sceneId
1624  * @param transitionTime
1625  * @param sceneName
1626  * @param extensionFieldSets
1627  */
1628
1629 bool emberAfScenesClusterViewSceneResponseCallback(uint8_t status, uint16_t groupId, uint8_t sceneId, uint16_t transitionTime,
1630                                                    uint8_t * sceneName,
1631                                                    /* TYPE WARNING: array array defaults to */ uint8_t * extensionFieldSets);
1632
1633 //
1634 // Non-Cluster Related Callbacks
1635 //
1636
1637 /** @brief Add To Current App Tasks
1638  *
1639  * This function is only useful to sleepy end devices.  This function will note
1640  * the passed item as part of a set of tasks the application has outstanding
1641  * (e.g. message sent requiring APS acknwoledgement).  This will affect how the
1642  * application behaves with regard to sleeping and polling.  Until the
1643  * outstanding task is completed, the device may poll more frequently and sleep
1644  * less often.
1645  *
1646  * @param tasks   Ver.: always
1647  */
1648 void emberAfAddToCurrentAppTasksCallback(EmberAfApplicationTask tasks);
1649
1650 /** @brief Remove From Current App Tasks
1651  *
1652  * This function is only useful to sleepy end devices.  This function will
1653  * remove the passed item from the set of tasks the application has outstanding
1654  * (e.g. message sent requiring APS acknwoledgement).  This will affect how the
1655  * application behaves with regard to sleeping and polling.  Removing the item
1656  * from the list of outstanding tasks may allow the device to sleep longer and
1657  * poll less frequently.  If there are other outstanding tasks the system may
1658  * still have to stay away and poll more often.
1659  *
1660  * @param tasks   Ver.: always
1661  */
1662 void emberAfRemoveFromCurrentAppTasksCallback(EmberAfApplicationTask tasks);
1663
1664 /** @brief Allow Network Write Attribute
1665  *
1666  * This function is called by the application framework before it writes an
1667  * attribute in response to a write attribute request from an external device.
1668  * The value passed into this callback is the value to which the attribute is to
1669  * be set by the framework.
1670         Example:        In mirroring simple metering data
1671  * on an Energy Services Interface (ESI) (formerly called Energy Service Portal
1672  * (ESP) in SE 1.0).), a mirrored simple meter needs to write read-only
1673  * attributes on its mirror. The-meter-mirror sample application, located in
1674  * app/framework/sample-apps, uses this callback to allow the mirrored device to
1675  * write simple metering attributes on the mirror regardless of the fact that
1676  * most simple metering attributes are defined as read-only by the ZigBee
1677  * specification.
1678         Note:   The ZCL specification does not (as of this
1679  * writing) specify any permission-level security for writing writeable
1680  * attributes. As far as the ZCL specification is concerned, if an attribute is
1681  * writeable, any device that has a link key for the device should be able to
1682  * write that attribute. Furthermore if an attribute is read only, it should not
1683  * be written over the air. Thus, if you implement permissions for writing
1684  * attributes as a feature, you MAY be operating outside the specification. This
1685  * is unlikely to be a problem for writing read-only attributes, but it may be a
1686  * problem for attributes that are writeable according to the specification but
1687  * restricted by the application implementing this callback.
1688  *
1689  * @param endpoint   Ver.: always
1690  * @param clusterId   Ver.: always
1691  * @param attributeId   Ver.: always
1692  * @param mask   Ver.: always
1693  * @param manufacturerCode   Ver.: always
1694  * @param value   Ver.: always
1695  * @param type   Ver.: always
1696  */
1697 EmberAfAttributeWritePermission emberAfAllowNetworkWriteAttributeCallback(chip::EndpointId endpoint, chip::ClusterId clusterId,
1698                                                                           chip::AttributeId attributeId, uint8_t mask,
1699                                                                           uint16_t manufacturerCode, uint8_t * value, uint8_t type);
1700
1701 /** @brief Attribute Read Access
1702  *
1703  * This function is called whenever the Application Framework needs to check
1704  * access permission for an attribute read.
1705  *
1706  * @param endpoint   Ver.: always
1707  * @param clusterId   Ver.: always
1708  * @param manufacturerCode   Ver.: always
1709  * @param attributeId   Ver.: always
1710  */
1711 bool emberAfAttributeReadAccessCallback(chip::EndpointId endpoint, chip::ClusterId clusterId, uint16_t manufacturerCode,
1712                                         chip::AttributeId attributeId);
1713
1714 /** @brief Attribute Write Access
1715  *
1716  * This function is called whenever the Application Framework needs to check
1717  * access permission for an attribute write.
1718  *
1719  * @param endpoint   Ver.: always
1720  * @param clusterId   Ver.: always
1721  * @param manufacturerCode   Ver.: always
1722  * @param attributeId   Ver.: always
1723  */
1724 bool emberAfAttributeWriteAccessCallback(chip::EndpointId endpoint, chip::ClusterId clusterId, uint16_t manufacturerCode,
1725                                          chip::AttributeId attributeId);
1726
1727 /** @brief Default Response
1728  *
1729  * This function is called by the application framework when a Default Response
1730  * command is received from an external device.  The application should return
1731  * true if the message was processed or false if it was not.
1732  *
1733  * @param clusterId The cluster identifier of this response.  Ver.: always
1734  * @param commandId The command identifier to which this is a response.  Ver.:
1735  * always
1736  * @param status Specifies either SUCCESS or the nature of the error that was
1737  * detected in the received command.  Ver.: always
1738  */
1739 bool emberAfDefaultResponseCallback(chip::ClusterId clusterId, chip::CommandId commandId, EmberAfStatus status);
1740
1741 /** @brief Configure Reporting Response
1742  *
1743  * This function is called by the application framework when a Configure
1744  * Reporting Response command is received from an external device.  The
1745  * application should return true if the message was processed or false if it
1746  * was not.
1747  *
1748  * @param clusterId The cluster identifier of this response.  Ver.: always
1749  * @param buffer Buffer containing the list of attribute status records.  Ver.:
1750  * always
1751  * @param bufLen The length in bytes of the list.  Ver.: always
1752  */
1753 bool emberAfConfigureReportingResponseCallback(chip::ClusterId clusterId, uint8_t * buffer, uint16_t bufLen);
1754
1755 /** @brief Read Reporting Configuration Response
1756  *
1757  * This function is called by the application framework when a Read Reporting
1758  * Configuration Response command is received from an external device.  The
1759  * application should return true if the message was processed or false if it
1760  * was not.
1761  *
1762  * @param clusterId The cluster identifier of this response.  Ver.: always
1763  * @param buffer Buffer containing the list of attribute reporting configuration
1764  * records.  Ver.: always
1765  * @param bufLen The length in bytes of the list.  Ver.: always
1766  */
1767 bool emberAfReadReportingConfigurationResponseCallback(chip::ClusterId clusterId, uint8_t * buffer, uint16_t bufLen);
1768
1769 /** @brief Discover Attributes Response
1770  *
1771  * This function is called by the application framework when a Discover
1772  * Attributes Response or Discover Attributes Extended Response command is
1773  * received from an external device.  The Discover Attributes Response command
1774  * contains a bool indicating if discovery is complete and a list of zero or
1775  * more attribute identifier/type records. The final argument indicates whether
1776  * the response is in the extended format or not.  The application should return
1777  * true if the message was processed or false if it was not.
1778  *
1779  * @param clusterId The cluster identifier of this response.  Ver.: always
1780  * @param discoveryComplete Indicates whether there are more attributes to be
1781  * discovered.  true if there are no more attributes to be discovered.  Ver.:
1782  * always
1783  * @param buffer Buffer containing the list of attribute identifier/type
1784  * records.  Ver.: always
1785  * @param bufLen The length in bytes of the list.  Ver.: always
1786  * @param extended Indicates whether the response is in the extended format or
1787  * not.  Ver.: always
1788  */
1789 bool emberAfDiscoverAttributesResponseCallback(chip::ClusterId clusterId, bool discoveryComplete, uint8_t * buffer, uint16_t bufLen,
1790                                                bool extended);
1791
1792 /** @brief Discover Commands Generated Response
1793  *
1794  * This function is called by the framework when Discover Commands Generated
1795  * Response is received.
1796  *
1797  * @param clusterId The cluster identifier of this response.  Ver.: always
1798  * @param manufacturerCode Manufacturer code  Ver.: always
1799  * @param discoveryComplete Indicates whether there are more commands to be
1800  * discovered.  Ver.: always
1801  * @param commandIds Buffer containing the list of command identifiers.  Ver.:
1802  * always
1803  * @param commandIdCount The length of bytes of the list, whish is the same as
1804  * the number of identifiers.  Ver.: always
1805  */
1806 bool emberAfDiscoverCommandsGeneratedResponseCallback(chip::ClusterId clusterId, uint16_t manufacturerCode, bool discoveryComplete,
1807                                                       chip::CommandId * commandIds, uint16_t commandIdCount);
1808
1809 /** @brief Discover Commands Received Response
1810  *
1811  * This function is called by the framework when Discover Commands Received
1812  * Response is received.
1813  *
1814  * @param clusterId The cluster identifier of this response.  Ver.: always
1815  * @param manufacturerCode Manufacturer code  Ver.: always
1816  * @param discoveryComplete Indicates whether there are more commands to be
1817  * discovered.  Ver.: always
1818  * @param commandIds Buffer containing the list of command identifiers.  Ver.:
1819  * always
1820  * @param commandIdCount The length of bytes of the list, whish is the same as
1821  * the number of identifiers.  Ver.: always
1822  */
1823 bool emberAfDiscoverCommandsReceivedResponseCallback(chip::ClusterId clusterId, uint16_t manufacturerCode, bool discoveryComplete,
1824                                                      chip::CommandId * commandIds, uint16_t commandIdCount);
1825
1826 /** @brief Pre Command Received
1827  *
1828  * This callback is the second in the Application Framework's message processing
1829  * chain. At this point in the processing of incoming over-the-air messages, the
1830  * application has determined that the incoming message is a ZCL command. It
1831  * parses enough of the message to populate an EmberAfClusterCommand struct. The
1832  * Application Framework defines this struct value in a local scope to the
1833  * command processing but also makes it available through a global pointer
1834  * called emberAfCurrentCommand, in app/framework/util/util.c. When command
1835  * processing is complete, this pointer is cleared.
1836  *
1837  * @param cmd   Ver.: always
1838  */
1839 bool emberAfPreCommandReceivedCallback(EmberAfClusterCommand * cmd);
1840
1841 /** @brief Pre Message Send
1842  *
1843  * This function is called by the framework when it is about to pass a message
1844  * to the stack primitives for sending.   This message may or may not be ZCL,
1845  * ZDO, or some other protocol.  This is called prior to
1846         any ZigBee
1847  * fragmentation that may be done.  If the function returns true it is assumed
1848  * the callback has consumed and processed the message.  The callback must also
1849  * set the EmberStatus status code to be passed back to the caller.  The
1850  * framework will do no further processing on the message.
1851         If the
1852  * function returns false then it is assumed that the callback has not processed
1853  * the mesasge and the framework will continue to process accordingly.
1854  *
1855  * @param messageStruct The structure containing the parameters of the APS
1856  * message to be sent.  Ver.: always
1857  * @param status A pointer to the status code value that will be returned to the
1858  * caller.  Ver.: always
1859  */
1860 bool emberAfPreMessageSendCallback(EmberAfMessageStruct * messageStruct, EmberStatus * status);
1861
1862 /** @brief Message Sent
1863  *
1864  * This function is called by the application framework from the message sent
1865  * handler, when it is informed by the stack regarding the message sent status.
1866  * All of the values passed to the emberMessageSentHandler are passed on to this
1867  * callback. This provides an opportunity for the application to verify that its
1868  * message has been sent successfully and take the appropriate action. This
1869  * callback should return a bool value of true or false. A value of true
1870  * indicates that the message sent notification has been handled and should not
1871  * be handled by the application framework.
1872  *
1873  * @param type   Ver.: always
1874  * @param indexOrDestination   Ver.: always
1875  * @param apsFrame   Ver.: always
1876  * @param msgLen   Ver.: always
1877  * @param message   Ver.: always
1878  * @param status   Ver.: always
1879  */
1880 bool emberAfMessageSentCallback(EmberOutgoingMessageType type, uint64_t indexOrDestination, EmberApsFrame * apsFrame,
1881                                 uint16_t msgLen, uint8_t * message, EmberStatus status);
1882
1883 /** @brief Pre Attribute Change
1884  *
1885  * This function is called by the application framework before it changes an
1886  * attribute value.  The value passed into this callback is the value to which
1887  * the attribute is to be set by the framework.  The application should return
1888  * ::EMBER_ZCL_STATUS_SUCCESS to permit the change or any other ::EmberAfStatus
1889  * to reject it.
1890  *
1891  * @param endpoint   Ver.: always
1892  * @param clusterId   Ver.: always
1893  * @param attributeId   Ver.: always
1894  * @param mask   Ver.: always
1895  * @param manufacturerCode   Ver.: always
1896  * @param type   Ver.: always
1897  * @param size   Ver.: always
1898  * @param value   Ver.: always
1899  */
1900 EmberAfStatus emberAfPreAttributeChangeCallback(chip::EndpointId endpoint, chip::ClusterId clusterId, chip::AttributeId attributeId,
1901                                                 uint8_t mask, uint16_t manufacturerCode, uint8_t type, uint8_t size,
1902                                                 uint8_t * value);
1903
1904 /** @brief Post Attribute Change
1905  *
1906  * This function is called by the application framework after it changes an
1907  * attribute value. The value passed into this callback is the value to which
1908  * the attribute was set by the framework.
1909  *
1910  * @param endpoint   Ver.: always
1911  * @param clusterId   Ver.: always
1912  * @param attributeId   Ver.: always
1913  * @param mask   Ver.: always
1914  * @param manufacturerCode   Ver.: always
1915  * @param type   Ver.: always
1916  * @param size   Ver.: always
1917  * @param value   Ver.: always
1918  */
1919 void emberAfPostAttributeChangeCallback(chip::EndpointId endpoint, chip::ClusterId clusterId, chip::AttributeId attributeId,
1920                                         uint8_t mask, uint16_t manufacturerCode, uint8_t type, uint8_t size, uint8_t * value);
1921
1922 /** @brief Read Attributes Response
1923  *
1924  * This function is called by the application framework when a Read Attributes
1925  * Response command is received from an external device.  The application should
1926  * return true if the message was processed or false if it was not.
1927  *
1928  * @param clusterId The cluster identifier of this response.  Ver.: always
1929  * @param buffer Buffer containing the list of read attribute status records.
1930  * Ver.: always
1931  * @param bufLen The length in bytes of the list.  Ver.: always
1932  */
1933 bool emberAfReadAttributesResponseCallback(chip::ClusterId clusterId, uint8_t * buffer, uint16_t bufLen);
1934
1935 /** @brief External Attribute Read
1936  *
1937  * Like emberAfExternalAttributeWriteCallback above, this function is called
1938  * when the framework needs to read an attribute that is not stored within the
1939  * Application Framework's data structures.
1940         All of the important
1941  * information about the attribute itself is passed as a pointer to an
1942  * EmberAfAttributeMetadata struct, which is stored within the application and
1943  * used to manage the attribute. A complete description of the
1944  * EmberAfAttributeMetadata struct is provided in
1945  * app/framework/include/af-types.h
1946         This function assumes that the
1947  * application is able to read the attribute, write it into the passed buffer,
1948  * and return immediately. Any attributes that require a state machine for
1949  * reading and writing are not really candidates for externalization at the
1950  * present time. The Application Framework does not currently include a state
1951  * machine for reading or writing attributes that must take place across a
1952  * series of application ticks. Attributes that cannot be read in a timely
1953  * manner should be stored within the Application Framework and updated
1954  * occasionally by the application code from within the
1955  * emberAfMainTickCallback.
1956         If the application was successfully able to
1957  * read the attribute and write it into the passed buffer, it should return a
1958  * value of EMBER_ZCL_STATUS_SUCCESS. Ensure that the size of the externally
1959  * managed attribute value is smaller than what the buffer can hold. In the case
1960  * of a buffer overflow throw an appropriate error such as
1961  * EMBER_ZCL_STATUS_INSUFFICIENT_SPACE. Any other return value indicates the
1962  * application was not able to read the attribute.
1963  *
1964  * @param endpoint   Ver.: always
1965  * @param clusterId   Ver.: always
1966  * @param attributeMetadata   Ver.: always
1967  * @param manufacturerCode   Ver.: always
1968  * @param buffer   Ver.: always
1969  * @param maxReadLength   Ver.: always
1970  */
1971 EmberAfStatus emberAfExternalAttributeReadCallback(chip::EndpointId endpoint, chip::ClusterId clusterId,
1972                                                    EmberAfAttributeMetadata * attributeMetadata, uint16_t manufacturerCode,
1973                                                    uint8_t * buffer, uint16_t maxReadLength);
1974
1975 /** @brief Write Attributes Response
1976  *
1977  * This function is called by the application framework when a Write Attributes
1978  * Response command is received from an external device.  The application should
1979  * return true if the message was processed or false if it was not.
1980  *
1981  * @param clusterId The cluster identifier of this response.  Ver.: always
1982  * @param buffer Buffer containing the list of write attribute status records.
1983  * Ver.: always
1984  * @param bufLen The length in bytes of the list.  Ver.: always
1985  */
1986 bool emberAfWriteAttributesResponseCallback(chip::ClusterId clusterId, uint8_t * buffer, uint16_t bufLen);
1987
1988 /** @brief External Attribute Write
1989  *
1990  * This function is called whenever the Application Framework needs to write an
1991  * attribute which is not stored within the data structures of the Application
1992  * Framework itself. One of the new features in Version 2 is the ability to
1993  * store attributes outside the Framework. This is particularly useful for
1994  * attributes that do not need to be stored because they can be read off the
1995  * hardware when they are needed, or are stored in some central location used by
1996  * many modules within the system. In this case, you can indicate that the
1997  * attribute is stored externally. When the framework needs to write an external
1998  * attribute, it makes a call to this callback.
1999         This callback is very
2000  * useful for host micros which need to store attributes in persistent memory.
2001  * Because each host micro (used with an Ember NCP) has its own type of
2002  * persistent memory storage, the Application Framework does not include the
2003  * ability to mark attributes as stored in flash the way that it does for Ember
2004  * SoCs like the EM35x. On a host micro, any attributes that need to be stored
2005  * in persistent memory should be marked as external and accessed through the
2006  * external read and write callbacks. Any host code associated with the
2007  * persistent storage should be implemented within this callback.
2008         All of
2009  * the important information about the attribute itself is passed as a pointer
2010  * to an EmberAfAttributeMetadata struct, which is stored within the application
2011  * and used to manage the attribute. A complete description of the
2012  * EmberAfAttributeMetadata struct is provided in
2013  * app/framework/include/af-types.h.
2014         This function assumes that the
2015  * application is able to write the attribute and return immediately. Any
2016  * attributes that require a state machine for reading and writing are not
2017  * candidates for externalization at the present time. The Application Framework
2018  * does not currently include a state machine for reading or writing attributes
2019  * that must take place across a series of application ticks. Attributes that
2020  * cannot be written immediately should be stored within the Application
2021  * Framework and updated occasionally by the application code from within the
2022  * emberAfMainTickCallback.
2023         If the application was successfully able to
2024  * write the attribute, it returns a value of EMBER_ZCL_STATUS_SUCCESS. Any
2025  * other return value indicates the application was not able to write the
2026  * attribute.
2027  *
2028  * @param endpoint   Ver.: always
2029  * @param clusterId   Ver.: always
2030  * @param attributeMetadata   Ver.: always
2031  * @param manufacturerCode   Ver.: always
2032  * @param buffer   Ver.: always
2033  */
2034 EmberAfStatus emberAfExternalAttributeWriteCallback(chip::EndpointId endpoint, chip::ClusterId clusterId,
2035                                                     EmberAfAttributeMetadata * attributeMetadata, uint16_t manufacturerCode,
2036                                                     uint8_t * buffer);
2037
2038 /** @brief Report Attributes
2039  *
2040  * This function is called by the application framework when a Report Attributes
2041  * command is received from an external device.  The application should return
2042  * true if the message was processed or false if it was not.
2043  *
2044  * @param clusterId The cluster identifier of this command.  Ver.: always
2045  * @param buffer Buffer containing the list of attribute report records.  Ver.:
2046  * always
2047  * @param bufLen The length in bytes of the list.  Ver.: always
2048  */
2049 bool emberAfReportAttributesCallback(chip::ClusterId clusterId, uint8_t * buffer, uint16_t bufLen);
2050
2051 /** @brief Get Current Time
2052  *
2053  * This callback is called when device attempts to get current time from the
2054  * hardware. If this device has means to retrieve exact time, then this method
2055  * should implement it. If the callback can't provide the exact time it should
2056  * return 0 to indicate failure. Default action is to return 0, which indicates
2057  * that device does not have access to real time.
2058  *
2059  */
2060 uint32_t emberAfGetCurrentTimeCallback();
2061
2062 /** @brief Get Endpoint Info
2063  *
2064  * This function is a callback to an application implemented endpoint that
2065  * operates outside the normal application framework.  When the framework wishes
2066  * to perform operations with that endpoint it uses this callback to retrieve
2067  * the endpoint's information.  If the endpoint exists and the application can
2068  * provide data then true shall be returned.  Otherwise the callback must return
2069  * false.
2070  *
2071  * @param endpoint The endpoint to retrieve data for.  Ver.: always
2072  * @param returnNetworkIndex The index corresponding to the ZigBee network the
2073  * endpoint belongs to.  If not using a multi-network device, 0 must be
2074  * returned.  Otherwise on a multi-network device the stack will switch to this
2075  * network before sending the message.  Ver.: always
2076  * @param returnEndpointInfo A pointer to a data struct that will be written
2077  * with information about the endpoint.  Ver.: always
2078  */
2079 bool emberAfGetEndpointInfoCallback(chip::EndpointId endpoint, uint8_t * returnNetworkIndex,
2080                                     EmberAfEndpointInfoStruct * returnEndpointInfo);
2081
2082 /** @brief Get Source Route Overhead
2083  *
2084  * This function is called by the framework to determine the overhead required
2085  * in the network frame for source routing to a particular destination.
2086  *
2087  * @param destination The node id of the destination  Ver.: always
2088  */
2089 uint8_t emberAfGetSourceRouteOverheadCallback(chip::NodeId destination);
2090
2091 /** @brief Registration Abort
2092  *
2093  * This callback is called when the device should abort the registration
2094  * process.
2095  *
2096  */
2097 void emberAfRegistrationAbortCallback();
2098
2099 /** @brief Interpan Send Message
2100  *
2101  * This function will send a raw MAC message with interpan frame format using
2102  * the passed parameters.
2103  *
2104  * @param header Interpan header info  Ver.: always
2105  * @param messageLength The length of the message received or to send  Ver.:
2106  * always
2107  * @param message The message data received or to send.  Ver.: always
2108  */
2109 EmberStatus emberAfInterpanSendMessageCallback(EmberAfInterpanHeader * header, uint16_t messageLength, uint8_t * message);
2110
2111 /** @brief Start Move
2112  *
2113  * This function is called to initiate the process for a device to move (rejoin)
2114  * to a new parent.
2115  *
2116  */
2117 bool emberAfStartMoveCallback();