examples/all-clusters-app/all-clusters-common/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 IAS Zone Cluster Init
 113  *
 114  * Cluster Init
 115  *
 116  * @param endpoint    Endpoint that is being initialized
 117  */
 118 void emberAfIasZoneClusterInitCallback(chip::EndpointId endpoint);
 119
 120 /** @brief Identify Cluster Init
 121  *
 122  * Cluster Init
 123  *
 124  * @param endpoint    Endpoint that is being initialized
 125  */
 126 void emberAfIdentifyClusterInitCallback(chip::EndpointId endpoint);
 127
 128 /** @brief Level Control Cluster Init
 129  *
 130  * Cluster Init
 131  *
 132  * @param endpoint    Endpoint that is being initialized
 133  */
 134 void emberAfLevelControlClusterInitCallback(chip::EndpointId endpoint);
 135
 136 /** @brief Low Power Cluster Init
 137  *
 138  * Cluster Init
 139  *
 140  * @param endpoint    Endpoint that is being initialized
 141  */
 142 void emberAfLowPowerClusterInitCallback(chip::EndpointId endpoint);
 143
 144 /** @brief Media Playback Cluster Init
 145  *
 146  * Cluster Init
 147  *
 148  * @param endpoint    Endpoint that is being initialized
 149  */
 150 void emberAfMediaPlaybackClusterInitCallback(chip::EndpointId endpoint);
 151
 152 /** @brief On/off Cluster Init
 153  *
 154  * Cluster Init
 155  *
 156  * @param endpoint    Endpoint that is being initialized
 157  */
 158 void emberAfOnOffClusterInitCallback(chip::EndpointId endpoint);
 159
 160 /** @brief Scenes Cluster Init
 161  *
 162  * Cluster Init
 163  *
 164  * @param endpoint    Endpoint that is being initialized
 165  */
 166 void emberAfScenesClusterInitCallback(chip::EndpointId endpoint);
 167
 168 /** @brief Temperature Measurement Cluster Init
 169  *
 170  * Cluster Init
 171  *
 172  * @param endpoint    Endpoint that is being initialized
 173  */
 174 void emberAfTemperatureMeasurementClusterInitCallback(chip::EndpointId endpoint);
 175
 176 // Cluster Server/Client Init Functions
 177
 178 //
 179 // Application Basic Cluster server
 180 //
 181
 182 /** @brief Application Basic Cluster Server Init
 183  *
 184  * Server Init
 185  *
 186  * @param endpoint    Endpoint that is being initialized
 187  */
 188 void emberAfApplicationBasicClusterServerInitCallback(chip::EndpointId endpoint);
 189
 190 /** @brief Application Basic Cluster Server Attribute Changed
 191  *
 192  * Server Attribute Changed
 193  *
 194  * @param endpoint    Endpoint that is being initialized
 195  * @param attributeId Attribute that changed
 196  */
 197 void emberAfApplicationBasicClusterServerAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId);
 198
 199 /** @brief Application Basic Cluster Server Manufacturer Specific Attribute Changed
 200  *
 201  * Server Manufacturer Specific Attribute Changed
 202  *
 203  * @param endpoint          Endpoint that is being initialized
 204  * @param attributeId       Attribute that changed
 205  * @param manufacturerCode  Manufacturer Code of the attribute that changed
 206  */
 207 void emberAfApplicationBasicClusterServerManufacturerSpecificAttributeChangedCallback(chip::EndpointId endpoint,
 208                                                                                       chip::AttributeId attributeId,
 209                                                                                       uint16_t manufacturerCode);
 210
 211 /** @brief Application Basic Cluster Server Message Sent
 212  *
 213  * Server Message Sent
 214  *
 215  * @param type               The type of message sent
 216  * @param indexOrDestination The destination or address to which the message was sent
 217  * @param apsFrame           The APS frame for the message
 218  * @param msgLen             The length of the message
 219  * @param message            The message that was sent
 220  * @param status             The status of the sent message
 221  */
 222 void emberAfApplicationBasicClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint64_t indexOrDestination,
 223                                                              EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message,
 224                                                              EmberStatus status);
 225
 226 /** @brief Application Basic Cluster Server Pre Attribute Changed
 227  *
 228  * server Pre Attribute Changed
 229  *
 230  * @param endpoint      Endpoint that is being initialized
 231  * @param attributeId   Attribute to be changed
 232  * @param attributeType Attribute type
 233  * @param size          Attribute size
 234  * @param value         Attribute value
 235  */
 236 EmberAfStatus emberAfApplicationBasicClusterServerPreAttributeChangedCallback(chip::EndpointId endpoint,
 237                                                                               chip::AttributeId attributeId,
 238                                                                               EmberAfAttributeType attributeType, uint8_t size,
 239                                                                               uint8_t * value);
 240
 241 /** @brief Application Basic Cluster Server Tick
 242  *
 243  * server Tick
 244  *
 245  * @param endpoint  Endpoint that is being served
 246  */
 247 void emberAfApplicationBasicClusterServerTickCallback(chip::EndpointId endpoint);
 248
 249 //
 250 // Barrier Control Cluster server
 251 //
 252
 253 /** @brief Barrier Control Cluster Server Init
 254  *
 255  * Server Init
 256  *
 257  * @param endpoint    Endpoint that is being initialized
 258  */
 259 void emberAfBarrierControlClusterServerInitCallback(chip::EndpointId endpoint);
 260
 261 /** @brief Barrier Control Cluster Server Attribute Changed
 262  *
 263  * Server Attribute Changed
 264  *
 265  * @param endpoint    Endpoint that is being initialized
 266  * @param attributeId Attribute that changed
 267  */
 268 void emberAfBarrierControlClusterServerAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId);
 269
 270 /** @brief Barrier Control Cluster Server Manufacturer Specific Attribute Changed
 271  *
 272  * Server Manufacturer Specific Attribute Changed
 273  *
 274  * @param endpoint          Endpoint that is being initialized
 275  * @param attributeId       Attribute that changed
 276  * @param manufacturerCode  Manufacturer Code of the attribute that changed
 277  */
 278 void emberAfBarrierControlClusterServerManufacturerSpecificAttributeChangedCallback(chip::EndpointId endpoint,
 279                                                                                     chip::AttributeId attributeId,
 280                                                                                     uint16_t manufacturerCode);
 281
 282 /** @brief Barrier Control Cluster Server Message Sent
 283  *
 284  * Server Message Sent
 285  *
 286  * @param type               The type of message sent
 287  * @param indexOrDestination The destination or address to which the message was sent
 288  * @param apsFrame           The APS frame for the message
 289  * @param msgLen             The length of the message
 290  * @param message            The message that was sent
 291  * @param status             The status of the sent message
 292  */
 293 void emberAfBarrierControlClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint64_t indexOrDestination,
 294                                                            EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message,
 295                                                            EmberStatus status);
 296
 297 /** @brief Barrier Control Cluster Server Pre Attribute Changed
 298  *
 299  * server Pre Attribute Changed
 300  *
 301  * @param endpoint      Endpoint that is being initialized
 302  * @param attributeId   Attribute to be changed
 303  * @param attributeType Attribute type
 304  * @param size          Attribute size
 305  * @param value         Attribute value
 306  */
 307 EmberAfStatus emberAfBarrierControlClusterServerPreAttributeChangedCallback(chip::EndpointId endpoint,
 308                                                                             chip::AttributeId attributeId,
 309                                                                             EmberAfAttributeType attributeType, uint8_t size,
 310                                                                             uint8_t * value);
 311
 312 /** @brief Barrier Control Cluster Server Tick
 313  *
 314  * server Tick
 315  *
 316  * @param endpoint  Endpoint that is being served
 317  */
 318 void emberAfBarrierControlClusterServerTickCallback(chip::EndpointId endpoint);
 319
 320 //
 321 // Basic Cluster server
 322 //
 323
 324 /** @brief Basic Cluster Server Init
 325  *
 326  * Server Init
 327  *
 328  * @param endpoint    Endpoint that is being initialized
 329  */
 330 void emberAfBasicClusterServerInitCallback(chip::EndpointId endpoint);
 331
 332 /** @brief Basic Cluster Server Attribute Changed
 333  *
 334  * Server Attribute Changed
 335  *
 336  * @param endpoint    Endpoint that is being initialized
 337  * @param attributeId Attribute that changed
 338  */
 339 void emberAfBasicClusterServerAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId);
 340
 341 /** @brief Basic Cluster Server Manufacturer Specific Attribute Changed
 342  *
 343  * Server Manufacturer Specific Attribute Changed
 344  *
 345  * @param endpoint          Endpoint that is being initialized
 346  * @param attributeId       Attribute that changed
 347  * @param manufacturerCode  Manufacturer Code of the attribute that changed
 348  */
 349 void emberAfBasicClusterServerManufacturerSpecificAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId,
 350                                                                            uint16_t manufacturerCode);
 351
 352 /** @brief Basic Cluster Server Message Sent
 353  *
 354  * Server Message Sent
 355  *
 356  * @param type               The type of message sent
 357  * @param indexOrDestination The destination or address to which the message was sent
 358  * @param apsFrame           The APS frame for the message
 359  * @param msgLen             The length of the message
 360  * @param message            The message that was sent
 361  * @param status             The status of the sent message
 362  */
 363 void emberAfBasicClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint64_t indexOrDestination,
 364                                                   EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status);
 365
 366 /** @brief Basic Cluster Server Pre Attribute Changed
 367  *
 368  * server Pre Attribute Changed
 369  *
 370  * @param endpoint      Endpoint that is being initialized
 371  * @param attributeId   Attribute to be changed
 372  * @param attributeType Attribute type
 373  * @param size          Attribute size
 374  * @param value         Attribute value
 375  */
 376 EmberAfStatus emberAfBasicClusterServerPreAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId,
 377                                                                    EmberAfAttributeType attributeType, uint8_t size,
 378                                                                    uint8_t * value);
 379
 380 /** @brief Basic Cluster Server Tick
 381  *
 382  * server Tick
 383  *
 384  * @param endpoint  Endpoint that is being served
 385  */
 386 void emberAfBasicClusterServerTickCallback(chip::EndpointId endpoint);
 387
 388 //
 389 // Binding Cluster server
 390 //
 391
 392 /** @brief Binding Cluster Server Init
 393  *
 394  * Server Init
 395  *
 396  * @param endpoint    Endpoint that is being initialized
 397  */
 398 void emberAfBindingClusterServerInitCallback(chip::EndpointId endpoint);
 399
 400 /** @brief Binding Cluster Server Attribute Changed
 401  *
 402  * Server Attribute Changed
 403  *
 404  * @param endpoint    Endpoint that is being initialized
 405  * @param attributeId Attribute that changed
 406  */
 407 void emberAfBindingClusterServerAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId);
 408
 409 /** @brief Binding Cluster Server Manufacturer Specific Attribute Changed
 410  *
 411  * Server Manufacturer Specific Attribute Changed
 412  *
 413  * @param endpoint          Endpoint that is being initialized
 414  * @param attributeId       Attribute that changed
 415  * @param manufacturerCode  Manufacturer Code of the attribute that changed
 416  */
 417 void emberAfBindingClusterServerManufacturerSpecificAttributeChangedCallback(chip::EndpointId endpoint,
 418                                                                              chip::AttributeId attributeId,
 419                                                                              uint16_t manufacturerCode);
 420
 421 /** @brief Binding Cluster Server Message Sent
 422  *
 423  * Server Message Sent
 424  *
 425  * @param type               The type of message sent
 426  * @param indexOrDestination The destination or address to which the message was sent
 427  * @param apsFrame           The APS frame for the message
 428  * @param msgLen             The length of the message
 429  * @param message            The message that was sent
 430  * @param status             The status of the sent message
 431  */
 432 void emberAfBindingClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint64_t indexOrDestination,
 433                                                     EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message,
 434                                                     EmberStatus status);
 435
 436 /** @brief Binding Cluster Server Pre Attribute Changed
 437  *
 438  * server Pre Attribute Changed
 439  *
 440  * @param endpoint      Endpoint that is being initialized
 441  * @param attributeId   Attribute to be changed
 442  * @param attributeType Attribute type
 443  * @param size          Attribute size
 444  * @param value         Attribute value
 445  */
 446 EmberAfStatus emberAfBindingClusterServerPreAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId,
 447                                                                      EmberAfAttributeType attributeType, uint8_t size,
 448                                                                      uint8_t * value);
 449
 450 /** @brief Binding Cluster Server Tick
 451  *
 452  * server Tick
 453  *
 454  * @param endpoint  Endpoint that is being served
 455  */
 456 void emberAfBindingClusterServerTickCallback(chip::EndpointId endpoint);
 457
 458 //
 459 // Color Control Cluster server
 460 //
 461
 462 /** @brief Color Control Cluster Server Init
 463  *
 464  * Server Init
 465  *
 466  * @param endpoint    Endpoint that is being initialized
 467  */
 468 void emberAfColorControlClusterServerInitCallback(chip::EndpointId endpoint);
 469
 470 /** @brief Color Control Cluster Server Attribute Changed
 471  *
 472  * Server Attribute Changed
 473  *
 474  * @param endpoint    Endpoint that is being initialized
 475  * @param attributeId Attribute that changed
 476  */
 477 void emberAfColorControlClusterServerAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId);
 478
 479 /** @brief Color Control Cluster Server Manufacturer Specific Attribute Changed
 480  *
 481  * Server Manufacturer Specific Attribute Changed
 482  *
 483  * @param endpoint          Endpoint that is being initialized
 484  * @param attributeId       Attribute that changed
 485  * @param manufacturerCode  Manufacturer Code of the attribute that changed
 486  */
 487 void emberAfColorControlClusterServerManufacturerSpecificAttributeChangedCallback(chip::EndpointId endpoint,
 488                                                                                   chip::AttributeId attributeId,
 489                                                                                   uint16_t manufacturerCode);
 490
 491 /** @brief Color Control Cluster Server Message Sent
 492  *
 493  * Server Message Sent
 494  *
 495  * @param type               The type of message sent
 496  * @param indexOrDestination The destination or address to which the message was sent
 497  * @param apsFrame           The APS frame for the message
 498  * @param msgLen             The length of the message
 499  * @param message            The message that was sent
 500  * @param status             The status of the sent message
 501  */
 502 void emberAfColorControlClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint64_t indexOrDestination,
 503                                                          EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message,
 504                                                          EmberStatus status);
 505
 506 /** @brief Color Control Cluster Server Pre Attribute Changed
 507  *
 508  * server Pre Attribute Changed
 509  *
 510  * @param endpoint      Endpoint that is being initialized
 511  * @param attributeId   Attribute to be changed
 512  * @param attributeType Attribute type
 513  * @param size          Attribute size
 514  * @param value         Attribute value
 515  */
 516 EmberAfStatus emberAfColorControlClusterServerPreAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId,
 517                                                                           EmberAfAttributeType attributeType, uint8_t size,
 518                                                                           uint8_t * value);
 519
 520 /** @brief Color Control Cluster Server Tick
 521  *
 522  * server Tick
 523  *
 524  * @param endpoint  Endpoint that is being served
 525  */
 526 void emberAfColorControlClusterServerTickCallback(chip::EndpointId endpoint);
 527
 528 //
 529 // Content Launch Cluster server
 530 //
 531
 532 /** @brief Content Launch Cluster Server Init
 533  *
 534  * Server Init
 535  *
 536  * @param endpoint    Endpoint that is being initialized
 537  */
 538 void emberAfContentLaunchClusterServerInitCallback(chip::EndpointId endpoint);
 539
 540 /** @brief Content Launch Cluster Server Attribute Changed
 541  *
 542  * Server Attribute Changed
 543  *
 544  * @param endpoint    Endpoint that is being initialized
 545  * @param attributeId Attribute that changed
 546  */
 547 void emberAfContentLaunchClusterServerAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId);
 548
 549 /** @brief Content Launch Cluster Server Manufacturer Specific Attribute Changed
 550  *
 551  * Server Manufacturer Specific Attribute Changed
 552  *
 553  * @param endpoint          Endpoint that is being initialized
 554  * @param attributeId       Attribute that changed
 555  * @param manufacturerCode  Manufacturer Code of the attribute that changed
 556  */
 557 void emberAfContentLaunchClusterServerManufacturerSpecificAttributeChangedCallback(chip::EndpointId endpoint,
 558                                                                                    chip::AttributeId attributeId,
 559                                                                                    uint16_t manufacturerCode);
 560
 561 /** @brief Content Launch Cluster Server Message Sent
 562  *
 563  * Server Message Sent
 564  *
 565  * @param type               The type of message sent
 566  * @param indexOrDestination The destination or address to which the message was sent
 567  * @param apsFrame           The APS frame for the message
 568  * @param msgLen             The length of the message
 569  * @param message            The message that was sent
 570  * @param status             The status of the sent message
 571  */
 572 void emberAfContentLaunchClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint64_t indexOrDestination,
 573                                                           EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message,
 574                                                           EmberStatus status);
 575
 576 /** @brief Content Launch Cluster Server Pre Attribute Changed
 577  *
 578  * server Pre Attribute Changed
 579  *
 580  * @param endpoint      Endpoint that is being initialized
 581  * @param attributeId   Attribute to be changed
 582  * @param attributeType Attribute type
 583  * @param size          Attribute size
 584  * @param value         Attribute value
 585  */
 586 EmberAfStatus emberAfContentLaunchClusterServerPreAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId,
 587                                                                            EmberAfAttributeType attributeType, uint8_t size,
 588                                                                            uint8_t * value);
 589
 590 /** @brief Content Launch Cluster Server Tick
 591  *
 592  * server Tick
 593  *
 594  * @param endpoint  Endpoint that is being served
 595  */
 596 void emberAfContentLaunchClusterServerTickCallback(chip::EndpointId endpoint);
 597
 598 //
 599 // Door Lock Cluster server
 600 //
 601
 602 /** @brief Door Lock Cluster Server Init
 603  *
 604  * Server Init
 605  *
 606  * @param endpoint    Endpoint that is being initialized
 607  */
 608 void emberAfDoorLockClusterServerInitCallback(chip::EndpointId endpoint);
 609
 610 /** @brief Door Lock Cluster Server Attribute Changed
 611  *
 612  * Server Attribute Changed
 613  *
 614  * @param endpoint    Endpoint that is being initialized
 615  * @param attributeId Attribute that changed
 616  */
 617 void emberAfDoorLockClusterServerAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId);
 618
 619 /** @brief Door Lock Cluster Server Manufacturer Specific Attribute Changed
 620  *
 621  * Server Manufacturer Specific Attribute Changed
 622  *
 623  * @param endpoint          Endpoint that is being initialized
 624  * @param attributeId       Attribute that changed
 625  * @param manufacturerCode  Manufacturer Code of the attribute that changed
 626  */
 627 void emberAfDoorLockClusterServerManufacturerSpecificAttributeChangedCallback(chip::EndpointId endpoint,
 628                                                                               chip::AttributeId attributeId,
 629                                                                               uint16_t manufacturerCode);
 630
 631 /** @brief Door Lock Cluster Server Message Sent
 632  *
 633  * Server Message Sent
 634  *
 635  * @param type               The type of message sent
 636  * @param indexOrDestination The destination or address to which the message was sent
 637  * @param apsFrame           The APS frame for the message
 638  * @param msgLen             The length of the message
 639  * @param message            The message that was sent
 640  * @param status             The status of the sent message
 641  */
 642 void emberAfDoorLockClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint64_t indexOrDestination,
 643                                                      EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message,
 644                                                      EmberStatus status);
 645
 646 /** @brief Door Lock Cluster Server Pre Attribute Changed
 647  *
 648  * server Pre Attribute Changed
 649  *
 650  * @param endpoint      Endpoint that is being initialized
 651  * @param attributeId   Attribute to be changed
 652  * @param attributeType Attribute type
 653  * @param size          Attribute size
 654  * @param value         Attribute value
 655  */
 656 EmberAfStatus emberAfDoorLockClusterServerPreAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId,
 657                                                                       EmberAfAttributeType attributeType, uint8_t size,
 658                                                                       uint8_t * value);
 659
 660 /** @brief Door Lock Cluster Server Tick
 661  *
 662  * server Tick
 663  *
 664  * @param endpoint  Endpoint that is being served
 665  */
 666 void emberAfDoorLockClusterServerTickCallback(chip::EndpointId endpoint);
 667
 668 //
 669 // General Commissioning Cluster server
 670 //
 671
 672 /** @brief General Commissioning Cluster Server Init
 673  *
 674  * Server Init
 675  *
 676  * @param endpoint    Endpoint that is being initialized
 677  */
 678 void emberAfGeneralCommissioningClusterServerInitCallback(chip::EndpointId endpoint);
 679
 680 /** @brief General Commissioning Cluster Server Attribute Changed
 681  *
 682  * Server Attribute Changed
 683  *
 684  * @param endpoint    Endpoint that is being initialized
 685  * @param attributeId Attribute that changed
 686  */
 687 void emberAfGeneralCommissioningClusterServerAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId);
 688
 689 /** @brief General Commissioning Cluster Server Manufacturer Specific Attribute Changed
 690  *
 691  * Server Manufacturer Specific Attribute Changed
 692  *
 693  * @param endpoint          Endpoint that is being initialized
 694  * @param attributeId       Attribute that changed
 695  * @param manufacturerCode  Manufacturer Code of the attribute that changed
 696  */
 697 void emberAfGeneralCommissioningClusterServerManufacturerSpecificAttributeChangedCallback(chip::EndpointId endpoint,
 698                                                                                           chip::AttributeId attributeId,
 699                                                                                           uint16_t manufacturerCode);
 700
 701 /** @brief General Commissioning Cluster Server Message Sent
 702  *
 703  * Server Message Sent
 704  *
 705  * @param type               The type of message sent
 706  * @param indexOrDestination The destination or address to which the message was sent
 707  * @param apsFrame           The APS frame for the message
 708  * @param msgLen             The length of the message
 709  * @param message            The message that was sent
 710  * @param status             The status of the sent message
 711  */
 712 void emberAfGeneralCommissioningClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint64_t indexOrDestination,
 713                                                                  EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message,
 714                                                                  EmberStatus status);
 715
 716 /** @brief General Commissioning Cluster Server Pre Attribute Changed
 717  *
 718  * server Pre Attribute Changed
 719  *
 720  * @param endpoint      Endpoint that is being initialized
 721  * @param attributeId   Attribute to be changed
 722  * @param attributeType Attribute type
 723  * @param size          Attribute size
 724  * @param value         Attribute value
 725  */
 726 EmberAfStatus emberAfGeneralCommissioningClusterServerPreAttributeChangedCallback(chip::EndpointId endpoint,
 727                                                                                   chip::AttributeId attributeId,
 728                                                                                   EmberAfAttributeType attributeType, uint8_t size,
 729                                                                                   uint8_t * value);
 730
 731 /** @brief General Commissioning Cluster Server Tick
 732  *
 733  * server Tick
 734  *
 735  * @param endpoint  Endpoint that is being served
 736  */
 737 void emberAfGeneralCommissioningClusterServerTickCallback(chip::EndpointId endpoint);
 738
 739 //
 740 // Groups Cluster server
 741 //
 742
 743 /** @brief Groups Cluster Server Init
 744  *
 745  * Server Init
 746  *
 747  * @param endpoint    Endpoint that is being initialized
 748  */
 749 void emberAfGroupsClusterServerInitCallback(chip::EndpointId endpoint);
 750
 751 /** @brief Groups Cluster Server Attribute Changed
 752  *
 753  * Server Attribute Changed
 754  *
 755  * @param endpoint    Endpoint that is being initialized
 756  * @param attributeId Attribute that changed
 757  */
 758 void emberAfGroupsClusterServerAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId);
 759
 760 /** @brief Groups Cluster Server Manufacturer Specific Attribute Changed
 761  *
 762  * Server Manufacturer Specific Attribute Changed
 763  *
 764  * @param endpoint          Endpoint that is being initialized
 765  * @param attributeId       Attribute that changed
 766  * @param manufacturerCode  Manufacturer Code of the attribute that changed
 767  */
 768 void emberAfGroupsClusterServerManufacturerSpecificAttributeChangedCallback(chip::EndpointId endpoint,
 769                                                                             chip::AttributeId attributeId,
 770                                                                             uint16_t manufacturerCode);
 771
 772 /** @brief Groups Cluster Server Message Sent
 773  *
 774  * Server Message Sent
 775  *
 776  * @param type               The type of message sent
 777  * @param indexOrDestination The destination or address to which the message was sent
 778  * @param apsFrame           The APS frame for the message
 779  * @param msgLen             The length of the message
 780  * @param message            The message that was sent
 781  * @param status             The status of the sent message
 782  */
 783 void emberAfGroupsClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint64_t indexOrDestination,
 784                                                    EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message,
 785                                                    EmberStatus status);
 786
 787 /** @brief Groups Cluster Server Pre Attribute Changed
 788  *
 789  * server Pre Attribute Changed
 790  *
 791  * @param endpoint      Endpoint that is being initialized
 792  * @param attributeId   Attribute to be changed
 793  * @param attributeType Attribute type
 794  * @param size          Attribute size
 795  * @param value         Attribute value
 796  */
 797 EmberAfStatus emberAfGroupsClusterServerPreAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId,
 798                                                                     EmberAfAttributeType attributeType, uint8_t size,
 799                                                                     uint8_t * value);
 800
 801 /** @brief Groups Cluster Server Tick
 802  *
 803  * server Tick
 804  *
 805  * @param endpoint  Endpoint that is being served
 806  */
 807 void emberAfGroupsClusterServerTickCallback(chip::EndpointId endpoint);
 808
 809 //
 810 // IAS Zone Cluster server
 811 //
 812
 813 /** @brief IAS Zone Cluster Server Init
 814  *
 815  * Server Init
 816  *
 817  * @param endpoint    Endpoint that is being initialized
 818  */
 819 void emberAfIasZoneClusterServerInitCallback(chip::EndpointId endpoint);
 820
 821 /** @brief IAS Zone Cluster Server Attribute Changed
 822  *
 823  * Server Attribute Changed
 824  *
 825  * @param endpoint    Endpoint that is being initialized
 826  * @param attributeId Attribute that changed
 827  */
 828 void emberAfIasZoneClusterServerAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId);
 829
 830 /** @brief IAS Zone Cluster Server Manufacturer Specific Attribute Changed
 831  *
 832  * Server Manufacturer Specific Attribute Changed
 833  *
 834  * @param endpoint          Endpoint that is being initialized
 835  * @param attributeId       Attribute that changed
 836  * @param manufacturerCode  Manufacturer Code of the attribute that changed
 837  */
 838 void emberAfIasZoneClusterServerManufacturerSpecificAttributeChangedCallback(chip::EndpointId endpoint,
 839                                                                              chip::AttributeId attributeId,
 840                                                                              uint16_t manufacturerCode);
 841
 842 /** @brief IAS Zone Cluster Server Message Sent
 843  *
 844  * Server Message Sent
 845  *
 846  * @param type               The type of message sent
 847  * @param indexOrDestination The destination or address to which the message was sent
 848  * @param apsFrame           The APS frame for the message
 849  * @param msgLen             The length of the message
 850  * @param message            The message that was sent
 851  * @param status             The status of the sent message
 852  */
 853 void emberAfIasZoneClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint64_t indexOrDestination,
 854                                                     EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message,
 855                                                     EmberStatus status);
 856
 857 /** @brief IAS Zone Cluster Server Pre Attribute Changed
 858  *
 859  * server Pre Attribute Changed
 860  *
 861  * @param endpoint      Endpoint that is being initialized
 862  * @param attributeId   Attribute to be changed
 863  * @param attributeType Attribute type
 864  * @param size          Attribute size
 865  * @param value         Attribute value
 866  */
 867 EmberAfStatus emberAfIasZoneClusterServerPreAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId,
 868                                                                      EmberAfAttributeType attributeType, uint8_t size,
 869                                                                      uint8_t * value);
 870
 871 /** @brief IAS Zone Cluster Server Tick
 872  *
 873  * server Tick
 874  *
 875  * @param endpoint  Endpoint that is being served
 876  */
 877 void emberAfIasZoneClusterServerTickCallback(chip::EndpointId endpoint);
 878
 879 //
 880 // Identify Cluster server
 881 //
 882
 883 /** @brief Identify Cluster Server Init
 884  *
 885  * Server Init
 886  *
 887  * @param endpoint    Endpoint that is being initialized
 888  */
 889 void emberAfIdentifyClusterServerInitCallback(chip::EndpointId endpoint);
 890
 891 /** @brief Identify Cluster Server Attribute Changed
 892  *
 893  * Server Attribute Changed
 894  *
 895  * @param endpoint    Endpoint that is being initialized
 896  * @param attributeId Attribute that changed
 897  */
 898 void emberAfIdentifyClusterServerAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId);
 899
 900 /** @brief Identify Cluster Server Manufacturer Specific Attribute Changed
 901  *
 902  * Server Manufacturer Specific Attribute Changed
 903  *
 904  * @param endpoint          Endpoint that is being initialized
 905  * @param attributeId       Attribute that changed
 906  * @param manufacturerCode  Manufacturer Code of the attribute that changed
 907  */
 908 void emberAfIdentifyClusterServerManufacturerSpecificAttributeChangedCallback(chip::EndpointId endpoint,
 909                                                                               chip::AttributeId attributeId,
 910                                                                               uint16_t manufacturerCode);
 911
 912 /** @brief Identify Cluster Server Message Sent
 913  *
 914  * Server Message Sent
 915  *
 916  * @param type               The type of message sent
 917  * @param indexOrDestination The destination or address to which the message was sent
 918  * @param apsFrame           The APS frame for the message
 919  * @param msgLen             The length of the message
 920  * @param message            The message that was sent
 921  * @param status             The status of the sent message
 922  */
 923 void emberAfIdentifyClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint64_t indexOrDestination,
 924                                                      EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message,
 925                                                      EmberStatus status);
 926
 927 /** @brief Identify Cluster Server Pre Attribute Changed
 928  *
 929  * server Pre Attribute Changed
 930  *
 931  * @param endpoint      Endpoint that is being initialized
 932  * @param attributeId   Attribute to be changed
 933  * @param attributeType Attribute type
 934  * @param size          Attribute size
 935  * @param value         Attribute value
 936  */
 937 EmberAfStatus emberAfIdentifyClusterServerPreAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId,
 938                                                                       EmberAfAttributeType attributeType, uint8_t size,
 939                                                                       uint8_t * value);
 940
 941 /** @brief Identify Cluster Server Tick
 942  *
 943  * server Tick
 944  *
 945  * @param endpoint  Endpoint that is being served
 946  */
 947 void emberAfIdentifyClusterServerTickCallback(chip::EndpointId endpoint);
 948
 949 //
 950 // Level Control Cluster server
 951 //
 952
 953 /** @brief Level Control Cluster Server Init
 954  *
 955  * Server Init
 956  *
 957  * @param endpoint    Endpoint that is being initialized
 958  */
 959 void emberAfLevelControlClusterServerInitCallback(chip::EndpointId endpoint);
 960
 961 /** @brief Level Control Cluster Server Attribute Changed
 962  *
 963  * Server Attribute Changed
 964  *
 965  * @param endpoint    Endpoint that is being initialized
 966  * @param attributeId Attribute that changed
 967  */
 968 void emberAfLevelControlClusterServerAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId);
 969
 970 /** @brief Level Control Cluster Server Manufacturer Specific Attribute Changed
 971  *
 972  * Server Manufacturer Specific Attribute Changed
 973  *
 974  * @param endpoint          Endpoint that is being initialized
 975  * @param attributeId       Attribute that changed
 976  * @param manufacturerCode  Manufacturer Code of the attribute that changed
 977  */
 978 void emberAfLevelControlClusterServerManufacturerSpecificAttributeChangedCallback(chip::EndpointId endpoint,
 979                                                                                   chip::AttributeId attributeId,
 980                                                                                   uint16_t manufacturerCode);
 981
 982 /** @brief Level Control Cluster Server Message Sent
 983  *
 984  * Server Message Sent
 985  *
 986  * @param type               The type of message sent
 987  * @param indexOrDestination The destination or address to which the message was sent
 988  * @param apsFrame           The APS frame for the message
 989  * @param msgLen             The length of the message
 990  * @param message            The message that was sent
 991  * @param status             The status of the sent message
 992  */
 993 void emberAfLevelControlClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint64_t indexOrDestination,
 994                                                          EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message,
 995                                                          EmberStatus status);
 996
 997 /** @brief Level Control Cluster Server Pre Attribute Changed
 998  *
 999  * server Pre Attribute Changed
1000  *
1001  * @param endpoint      Endpoint that is being initialized
1002  * @param attributeId   Attribute to be changed
1003  * @param attributeType Attribute type
1004  * @param size          Attribute size
1005  * @param value         Attribute value
1006  */
1007 EmberAfStatus emberAfLevelControlClusterServerPreAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId,
1008                                                                           EmberAfAttributeType attributeType, uint8_t size,
1009                                                                           uint8_t * value);
1010
1011 /** @brief Level Control Cluster Server Tick
1012  *
1013  * server Tick
1014  *
1015  * @param endpoint  Endpoint that is being served
1016  */
1017 void emberAfLevelControlClusterServerTickCallback(chip::EndpointId endpoint);
1018
1019 //
1020 // Low Power Cluster server
1021 //
1022
1023 /** @brief Low Power Cluster Server Init
1024  *
1025  * Server Init
1026  *
1027  * @param endpoint    Endpoint that is being initialized
1028  */
1029 void emberAfLowPowerClusterServerInitCallback(chip::EndpointId endpoint);
1030
1031 /** @brief Low Power Cluster Server Attribute Changed
1032  *
1033  * Server Attribute Changed
1034  *
1035  * @param endpoint    Endpoint that is being initialized
1036  * @param attributeId Attribute that changed
1037  */
1038 void emberAfLowPowerClusterServerAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId);
1039
1040 /** @brief Low Power Cluster Server Manufacturer Specific Attribute Changed
1041  *
1042  * Server Manufacturer Specific Attribute Changed
1043  *
1044  * @param endpoint          Endpoint that is being initialized
1045  * @param attributeId       Attribute that changed
1046  * @param manufacturerCode  Manufacturer Code of the attribute that changed
1047  */
1048 void emberAfLowPowerClusterServerManufacturerSpecificAttributeChangedCallback(chip::EndpointId endpoint,
1049                                                                               chip::AttributeId attributeId,
1050                                                                               uint16_t manufacturerCode);
1051
1052 /** @brief Low Power Cluster Server Message Sent
1053  *
1054  * Server Message Sent
1055  *
1056  * @param type               The type of message sent
1057  * @param indexOrDestination The destination or address to which the message was sent
1058  * @param apsFrame           The APS frame for the message
1059  * @param msgLen             The length of the message
1060  * @param message            The message that was sent
1061  * @param status             The status of the sent message
1062  */
1063 void emberAfLowPowerClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint64_t indexOrDestination,
1064                                                      EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message,
1065                                                      EmberStatus status);
1066
1067 /** @brief Low Power Cluster Server Pre Attribute Changed
1068  *
1069  * server Pre Attribute Changed
1070  *
1071  * @param endpoint      Endpoint that is being initialized
1072  * @param attributeId   Attribute to be changed
1073  * @param attributeType Attribute type
1074  * @param size          Attribute size
1075  * @param value         Attribute value
1076  */
1077 EmberAfStatus emberAfLowPowerClusterServerPreAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId,
1078                                                                       EmberAfAttributeType attributeType, uint8_t size,
1079                                                                       uint8_t * value);
1080
1081 /** @brief Low Power Cluster Server Tick
1082  *
1083  * server Tick
1084  *
1085  * @param endpoint  Endpoint that is being served
1086  */
1087 void emberAfLowPowerClusterServerTickCallback(chip::EndpointId endpoint);
1088
1089 //
1090 // Media Playback Cluster server
1091 //
1092
1093 /** @brief Media Playback Cluster Server Init
1094  *
1095  * Server Init
1096  *
1097  * @param endpoint    Endpoint that is being initialized
1098  */
1099 void emberAfMediaPlaybackClusterServerInitCallback(chip::EndpointId endpoint);
1100
1101 /** @brief Media Playback Cluster Server Attribute Changed
1102  *
1103  * Server Attribute Changed
1104  *
1105  * @param endpoint    Endpoint that is being initialized
1106  * @param attributeId Attribute that changed
1107  */
1108 void emberAfMediaPlaybackClusterServerAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId);
1109
1110 /** @brief Media Playback Cluster Server Manufacturer Specific Attribute Changed
1111  *
1112  * Server Manufacturer Specific Attribute Changed
1113  *
1114  * @param endpoint          Endpoint that is being initialized
1115  * @param attributeId       Attribute that changed
1116  * @param manufacturerCode  Manufacturer Code of the attribute that changed
1117  */
1118 void emberAfMediaPlaybackClusterServerManufacturerSpecificAttributeChangedCallback(chip::EndpointId endpoint,
1119                                                                                    chip::AttributeId attributeId,
1120                                                                                    uint16_t manufacturerCode);
1121
1122 /** @brief Media Playback Cluster Server Message Sent
1123  *
1124  * Server Message Sent
1125  *
1126  * @param type               The type of message sent
1127  * @param indexOrDestination The destination or address to which the message was sent
1128  * @param apsFrame           The APS frame for the message
1129  * @param msgLen             The length of the message
1130  * @param message            The message that was sent
1131  * @param status             The status of the sent message
1132  */
1133 void emberAfMediaPlaybackClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint64_t indexOrDestination,
1134                                                           EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message,
1135                                                           EmberStatus status);
1136
1137 /** @brief Media Playback Cluster Server Pre Attribute Changed
1138  *
1139  * server Pre Attribute Changed
1140  *
1141  * @param endpoint      Endpoint that is being initialized
1142  * @param attributeId   Attribute to be changed
1143  * @param attributeType Attribute type
1144  * @param size          Attribute size
1145  * @param value         Attribute value
1146  */
1147 EmberAfStatus emberAfMediaPlaybackClusterServerPreAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId,
1148                                                                            EmberAfAttributeType attributeType, uint8_t size,
1149                                                                            uint8_t * value);
1150
1151 /** @brief Media Playback Cluster Server Tick
1152  *
1153  * server Tick
1154  *
1155  * @param endpoint  Endpoint that is being served
1156  */
1157 void emberAfMediaPlaybackClusterServerTickCallback(chip::EndpointId endpoint);
1158
1159 //
1160 // On/off Cluster server
1161 //
1162
1163 /** @brief On/off Cluster Server Init
1164  *
1165  * Server Init
1166  *
1167  * @param endpoint    Endpoint that is being initialized
1168  */
1169 void emberAfOnOffClusterServerInitCallback(chip::EndpointId endpoint);
1170
1171 /** @brief On/off Cluster Server Attribute Changed
1172  *
1173  * Server Attribute Changed
1174  *
1175  * @param endpoint    Endpoint that is being initialized
1176  * @param attributeId Attribute that changed
1177  */
1178 void emberAfOnOffClusterServerAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId);
1179
1180 /** @brief On/off Cluster Server Manufacturer Specific Attribute Changed
1181  *
1182  * Server Manufacturer Specific Attribute Changed
1183  *
1184  * @param endpoint          Endpoint that is being initialized
1185  * @param attributeId       Attribute that changed
1186  * @param manufacturerCode  Manufacturer Code of the attribute that changed
1187  */
1188 void emberAfOnOffClusterServerManufacturerSpecificAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId,
1189                                                                            uint16_t manufacturerCode);
1190
1191 /** @brief On/off Cluster Server Message Sent
1192  *
1193  * Server Message Sent
1194  *
1195  * @param type               The type of message sent
1196  * @param indexOrDestination The destination or address to which the message was sent
1197  * @param apsFrame           The APS frame for the message
1198  * @param msgLen             The length of the message
1199  * @param message            The message that was sent
1200  * @param status             The status of the sent message
1201  */
1202 void emberAfOnOffClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint64_t indexOrDestination,
1203                                                   EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status);
1204
1205 /** @brief On/off Cluster Server Pre Attribute Changed
1206  *
1207  * server Pre Attribute Changed
1208  *
1209  * @param endpoint      Endpoint that is being initialized
1210  * @param attributeId   Attribute to be changed
1211  * @param attributeType Attribute type
1212  * @param size          Attribute size
1213  * @param value         Attribute value
1214  */
1215 EmberAfStatus emberAfOnOffClusterServerPreAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId,
1216                                                                    EmberAfAttributeType attributeType, uint8_t size,
1217                                                                    uint8_t * value);
1218
1219 /** @brief On/off Cluster Server Tick
1220  *
1221  * server Tick
1222  *
1223  * @param endpoint  Endpoint that is being served
1224  */
1225 void emberAfOnOffClusterServerTickCallback(chip::EndpointId endpoint);
1226
1227 //
1228 // Scenes Cluster server
1229 //
1230
1231 /** @brief Scenes Cluster Server Init
1232  *
1233  * Server Init
1234  *
1235  * @param endpoint    Endpoint that is being initialized
1236  */
1237 void emberAfScenesClusterServerInitCallback(chip::EndpointId endpoint);
1238
1239 /** @brief Scenes Cluster Server Attribute Changed
1240  *
1241  * Server Attribute Changed
1242  *
1243  * @param endpoint    Endpoint that is being initialized
1244  * @param attributeId Attribute that changed
1245  */
1246 void emberAfScenesClusterServerAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId);
1247
1248 /** @brief Scenes Cluster Server Manufacturer Specific Attribute Changed
1249  *
1250  * Server Manufacturer Specific Attribute Changed
1251  *
1252  * @param endpoint          Endpoint that is being initialized
1253  * @param attributeId       Attribute that changed
1254  * @param manufacturerCode  Manufacturer Code of the attribute that changed
1255  */
1256 void emberAfScenesClusterServerManufacturerSpecificAttributeChangedCallback(chip::EndpointId endpoint,
1257                                                                             chip::AttributeId attributeId,
1258                                                                             uint16_t manufacturerCode);
1259
1260 /** @brief Scenes Cluster Server Message Sent
1261  *
1262  * Server Message Sent
1263  *
1264  * @param type               The type of message sent
1265  * @param indexOrDestination The destination or address to which the message was sent
1266  * @param apsFrame           The APS frame for the message
1267  * @param msgLen             The length of the message
1268  * @param message            The message that was sent
1269  * @param status             The status of the sent message
1270  */
1271 void emberAfScenesClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint64_t indexOrDestination,
1272                                                    EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message,
1273                                                    EmberStatus status);
1274
1275 /** @brief Scenes Cluster Server Pre Attribute Changed
1276  *
1277  * server Pre Attribute Changed
1278  *
1279  * @param endpoint      Endpoint that is being initialized
1280  * @param attributeId   Attribute to be changed
1281  * @param attributeType Attribute type
1282  * @param size          Attribute size
1283  * @param value         Attribute value
1284  */
1285 EmberAfStatus emberAfScenesClusterServerPreAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId,
1286                                                                     EmberAfAttributeType attributeType, uint8_t size,
1287                                                                     uint8_t * value);
1288
1289 /** @brief Scenes Cluster Server Tick
1290  *
1291  * server Tick
1292  *
1293  * @param endpoint  Endpoint that is being served
1294  */
1295 void emberAfScenesClusterServerTickCallback(chip::EndpointId endpoint);
1296
1297 //
1298 // Temperature Measurement Cluster server
1299 //
1300
1301 /** @brief Temperature Measurement Cluster Server Init
1302  *
1303  * Server Init
1304  *
1305  * @param endpoint    Endpoint that is being initialized
1306  */
1307 void emberAfTemperatureMeasurementClusterServerInitCallback(chip::EndpointId endpoint);
1308
1309 /** @brief Temperature Measurement Cluster Server Attribute Changed
1310  *
1311  * Server Attribute Changed
1312  *
1313  * @param endpoint    Endpoint that is being initialized
1314  * @param attributeId Attribute that changed
1315  */
1316 void emberAfTemperatureMeasurementClusterServerAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId);
1317
1318 /** @brief Temperature Measurement Cluster Server Manufacturer Specific Attribute Changed
1319  *
1320  * Server Manufacturer Specific Attribute Changed
1321  *
1322  * @param endpoint          Endpoint that is being initialized
1323  * @param attributeId       Attribute that changed
1324  * @param manufacturerCode  Manufacturer Code of the attribute that changed
1325  */
1326 void emberAfTemperatureMeasurementClusterServerManufacturerSpecificAttributeChangedCallback(chip::EndpointId endpoint,
1327                                                                                             chip::AttributeId attributeId,
1328                                                                                             uint16_t manufacturerCode);
1329
1330 /** @brief Temperature Measurement Cluster Server Message Sent
1331  *
1332  * Server Message Sent
1333  *
1334  * @param type               The type of message sent
1335  * @param indexOrDestination The destination or address to which the message was sent
1336  * @param apsFrame           The APS frame for the message
1337  * @param msgLen             The length of the message
1338  * @param message            The message that was sent
1339  * @param status             The status of the sent message
1340  */
1341 void emberAfTemperatureMeasurementClusterServerMessageSentCallback(EmberOutgoingMessageType type, uint64_t indexOrDestination,
1342                                                                    EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message,
1343                                                                    EmberStatus status);
1344
1345 /** @brief Temperature Measurement Cluster Server Pre Attribute Changed
1346  *
1347  * server Pre Attribute Changed
1348  *
1349  * @param endpoint      Endpoint that is being initialized
1350  * @param attributeId   Attribute to be changed
1351  * @param attributeType Attribute type
1352  * @param size          Attribute size
1353  * @param value         Attribute value
1354  */
1355 EmberAfStatus emberAfTemperatureMeasurementClusterServerPreAttributeChangedCallback(chip::EndpointId endpoint,
1356                                                                                     chip::AttributeId attributeId,
1357                                                                                     EmberAfAttributeType attributeType,
1358                                                                                     uint8_t size, uint8_t * value);
1359
1360 /** @brief Temperature Measurement Cluster Server Tick
1361  *
1362  * server Tick
1363  *
1364  * @param endpoint  Endpoint that is being served
1365  */
1366 void emberAfTemperatureMeasurementClusterServerTickCallback(chip::EndpointId endpoint);
1367
1368 // Cluster Commands Callback
1369
1370 /**
1371  * @brief Barrier Control Cluster BarrierControlGoToPercent Command callback
1372  * @param percentOpen
1373  */
1374
1375 bool emberAfBarrierControlClusterBarrierControlGoToPercentCallback(uint8_t percentOpen);
1376
1377 /**
1378  * @brief Barrier Control Cluster BarrierControlStop Command callback
1379  */
1380
1381 bool emberAfBarrierControlClusterBarrierControlStopCallback();
1382
1383 /**
1384  * @brief Basic Cluster MfgSpecificPing Command callback
1385  */
1386
1387 bool emberAfBasicClusterMfgSpecificPingCallback();
1388
1389 /**
1390  * @brief Basic Cluster ResetToFactoryDefaults Command callback
1391  */
1392
1393 bool emberAfBasicClusterResetToFactoryDefaultsCallback();
1394
1395 /**
1396  * @brief Binding Cluster Bind Command callback
1397  * @param nodeId
1398  * @param groupId
1399  * @param endpointId
1400  * @param clusterId
1401  */
1402
1403 bool emberAfBindingClusterBindCallback(chip::NodeId nodeId, chip::GroupId groupId, chip::EndpointId endpointId,
1404                                        chip::ClusterId clusterId);
1405
1406 /**
1407  * @brief Binding Cluster Unbind Command callback
1408  * @param nodeId
1409  * @param groupId
1410  * @param endpointId
1411  * @param clusterId
1412  */
1413
1414 bool emberAfBindingClusterUnbindCallback(chip::NodeId nodeId, chip::GroupId groupId, chip::EndpointId endpointId,
1415                                          chip::ClusterId clusterId);
1416
1417 /**
1418  * @brief Color Control Cluster MoveColor Command callback
1419  * @param rateX
1420  * @param rateY
1421  * @param optionsMask
1422  * @param optionsOverride
1423  */
1424
1425 bool emberAfColorControlClusterMoveColorCallback(int16_t rateX, int16_t rateY, uint8_t optionsMask, uint8_t optionsOverride);
1426
1427 /**
1428  * @brief Color Control Cluster MoveColorTemperature Command callback
1429  * @param moveMode
1430  * @param rate
1431  * @param colorTemperatureMinimum
1432  * @param colorTemperatureMaximum
1433  * @param optionsMask
1434  * @param optionsOverride
1435  */
1436
1437 bool emberAfColorControlClusterMoveColorTemperatureCallback(uint8_t moveMode, uint16_t rate, uint16_t colorTemperatureMinimum,
1438                                                             uint16_t colorTemperatureMaximum, uint8_t optionsMask,
1439                                                             uint8_t optionsOverride);
1440
1441 /**
1442  * @brief Color Control Cluster MoveHue Command callback
1443  * @param moveMode
1444  * @param rate
1445  * @param optionsMask
1446  * @param optionsOverride
1447  */
1448
1449 bool emberAfColorControlClusterMoveHueCallback(uint8_t moveMode, uint8_t rate, uint8_t optionsMask, uint8_t optionsOverride);
1450
1451 /**
1452  * @brief Color Control Cluster MoveSaturation Command callback
1453  * @param moveMode
1454  * @param rate
1455  * @param optionsMask
1456  * @param optionsOverride
1457  */
1458
1459 bool emberAfColorControlClusterMoveSaturationCallback(uint8_t moveMode, uint8_t rate, uint8_t optionsMask, uint8_t optionsOverride);
1460
1461 /**
1462  * @brief Color Control Cluster MoveToColor Command callback
1463  * @param colorX
1464  * @param colorY
1465  * @param transitionTime
1466  * @param optionsMask
1467  * @param optionsOverride
1468  */
1469
1470 bool emberAfColorControlClusterMoveToColorCallback(uint16_t colorX, uint16_t colorY, uint16_t transitionTime, uint8_t optionsMask,
1471                                                    uint8_t optionsOverride);
1472
1473 /**
1474  * @brief Color Control Cluster MoveToColorTemperature Command callback
1475  * @param colorTemperature
1476  * @param transitionTime
1477  * @param optionsMask
1478  * @param optionsOverride
1479  */
1480
1481 bool emberAfColorControlClusterMoveToColorTemperatureCallback(uint16_t colorTemperature, uint16_t transitionTime,
1482                                                               uint8_t optionsMask, uint8_t optionsOverride);
1483
1484 /**
1485  * @brief Color Control Cluster MoveToHue Command callback
1486  * @param hue
1487  * @param direction
1488  * @param transitionTime
1489  * @param optionsMask
1490  * @param optionsOverride
1491  */
1492
1493 bool emberAfColorControlClusterMoveToHueCallback(uint8_t hue, uint8_t direction, uint16_t transitionTime, uint8_t optionsMask,
1494                                                  uint8_t optionsOverride);
1495
1496 /**
1497  * @brief Color Control Cluster MoveToHueAndSaturation Command callback
1498  * @param hue
1499  * @param saturation
1500  * @param transitionTime
1501  * @param optionsMask
1502  * @param optionsOverride
1503  */
1504
1505 bool emberAfColorControlClusterMoveToHueAndSaturationCallback(uint8_t hue, uint8_t saturation, uint16_t transitionTime,
1506                                                               uint8_t optionsMask, uint8_t optionsOverride);
1507
1508 /**
1509  * @brief Color Control Cluster MoveToSaturation Command callback
1510  * @param saturation
1511  * @param transitionTime
1512  * @param optionsMask
1513  * @param optionsOverride
1514  */
1515
1516 bool emberAfColorControlClusterMoveToSaturationCallback(uint8_t saturation, uint16_t transitionTime, uint8_t optionsMask,
1517                                                         uint8_t optionsOverride);
1518
1519 /**
1520  * @brief Color Control Cluster StepColor Command callback
1521  * @param stepX
1522  * @param stepY
1523  * @param transitionTime
1524  * @param optionsMask
1525  * @param optionsOverride
1526  */
1527
1528 bool emberAfColorControlClusterStepColorCallback(int16_t stepX, int16_t stepY, uint16_t transitionTime, uint8_t optionsMask,
1529                                                  uint8_t optionsOverride);
1530
1531 /**
1532  * @brief Color Control Cluster StepColorTemperature Command callback
1533  * @param stepMode
1534  * @param stepSize
1535  * @param transitionTime
1536  * @param colorTemperatureMinimum
1537  * @param colorTemperatureMaximum
1538  * @param optionsMask
1539  * @param optionsOverride
1540  */
1541
1542 bool emberAfColorControlClusterStepColorTemperatureCallback(uint8_t stepMode, uint16_t stepSize, uint16_t transitionTime,
1543                                                             uint16_t colorTemperatureMinimum, uint16_t colorTemperatureMaximum,
1544                                                             uint8_t optionsMask, uint8_t optionsOverride);
1545
1546 /**
1547  * @brief Color Control Cluster StepHue Command callback
1548  * @param stepMode
1549  * @param stepSize
1550  * @param transitionTime
1551  * @param optionsMask
1552  * @param optionsOverride
1553  */
1554
1555 bool emberAfColorControlClusterStepHueCallback(uint8_t stepMode, uint8_t stepSize, uint8_t transitionTime, uint8_t optionsMask,
1556                                                uint8_t optionsOverride);
1557
1558 /**
1559  * @brief Color Control Cluster StepSaturation Command callback
1560  * @param stepMode
1561  * @param stepSize
1562  * @param transitionTime
1563  * @param optionsMask
1564  * @param optionsOverride
1565  */
1566
1567 bool emberAfColorControlClusterStepSaturationCallback(uint8_t stepMode, uint8_t stepSize, uint8_t transitionTime,
1568                                                       uint8_t optionsMask, uint8_t optionsOverride);
1569
1570 /**
1571  * @brief Color Control Cluster StopMoveStep Command callback
1572  * @param optionsMask
1573  * @param optionsOverride
1574  */
1575
1576 bool emberAfColorControlClusterStopMoveStepCallback(uint8_t optionsMask, uint8_t optionsOverride);
1577
1578 /**
1579  * @brief Content Launch Cluster LaunchContent Command callback
1580  */
1581
1582 bool emberAfContentLaunchClusterLaunchContentCallback();
1583
1584 /**
1585  * @brief Content Launch Cluster LaunchURL Command callback
1586  */
1587
1588 bool emberAfContentLaunchClusterLaunchURLCallback();
1589
1590 /**
1591  * @brief Door Lock Cluster ClearAllPins Command callback
1592  */
1593
1594 bool emberAfDoorLockClusterClearAllPinsCallback();
1595
1596 /**
1597  * @brief Door Lock Cluster ClearAllRfids Command callback
1598  */
1599
1600 bool emberAfDoorLockClusterClearAllRfidsCallback();
1601
1602 /**
1603  * @brief Door Lock Cluster ClearHolidaySchedule Command callback
1604  * @param scheduleId
1605  */
1606
1607 bool emberAfDoorLockClusterClearHolidayScheduleCallback(uint8_t scheduleId);
1608
1609 /**
1610  * @brief Door Lock Cluster ClearPin Command callback
1611  * @param userId
1612  */
1613
1614 bool emberAfDoorLockClusterClearPinCallback(uint16_t userId);
1615
1616 /**
1617  * @brief Door Lock Cluster ClearRfid Command callback
1618  * @param userId
1619  */
1620
1621 bool emberAfDoorLockClusterClearRfidCallback(uint16_t userId);
1622
1623 /**
1624  * @brief Door Lock Cluster ClearWeekdaySchedule Command callback
1625  * @param scheduleId
1626  * @param userId
1627  */
1628
1629 bool emberAfDoorLockClusterClearWeekdayScheduleCallback(uint8_t scheduleId, uint16_t userId);
1630
1631 /**
1632  * @brief Door Lock Cluster ClearYeardaySchedule Command callback
1633  * @param scheduleId
1634  * @param userId
1635  */
1636
1637 bool emberAfDoorLockClusterClearYeardayScheduleCallback(uint8_t scheduleId, uint16_t userId);
1638
1639 /**
1640  * @brief Door Lock Cluster GetHolidaySchedule Command callback
1641  * @param scheduleId
1642  */
1643
1644 bool emberAfDoorLockClusterGetHolidayScheduleCallback(uint8_t scheduleId);
1645
1646 /**
1647  * @brief Door Lock Cluster GetLogRecord Command callback
1648  * @param logIndex
1649  */
1650
1651 bool emberAfDoorLockClusterGetLogRecordCallback(uint16_t logIndex);
1652
1653 /**
1654  * @brief Door Lock Cluster GetPin Command callback
1655  * @param userId
1656  */
1657
1658 bool emberAfDoorLockClusterGetPinCallback(uint16_t userId);
1659
1660 /**
1661  * @brief Door Lock Cluster GetRfid Command callback
1662  * @param userId
1663  */
1664
1665 bool emberAfDoorLockClusterGetRfidCallback(uint16_t userId);
1666
1667 /**
1668  * @brief Door Lock Cluster GetUserType Command callback
1669  * @param userId
1670  */
1671
1672 bool emberAfDoorLockClusterGetUserTypeCallback(uint16_t userId);
1673
1674 /**
1675  * @brief Door Lock Cluster GetWeekdaySchedule Command callback
1676  * @param scheduleId
1677  * @param userId
1678  */
1679
1680 bool emberAfDoorLockClusterGetWeekdayScheduleCallback(uint8_t scheduleId, uint16_t userId);
1681
1682 /**
1683  * @brief Door Lock Cluster GetYeardaySchedule Command callback
1684  * @param scheduleId
1685  * @param userId
1686  */
1687
1688 bool emberAfDoorLockClusterGetYeardayScheduleCallback(uint8_t scheduleId, uint16_t userId);
1689
1690 /**
1691  * @brief Door Lock Cluster LockDoor Command callback
1692  * @param pin
1693  */
1694
1695 bool emberAfDoorLockClusterLockDoorCallback(uint8_t * PIN);
1696
1697 /**
1698  * @brief Door Lock Cluster SetHolidaySchedule Command callback
1699  * @param scheduleId
1700  * @param localStartTime
1701  * @param localEndTime
1702  * @param operatingModeDuringHoliday
1703  */
1704
1705 bool emberAfDoorLockClusterSetHolidayScheduleCallback(uint8_t scheduleId, uint32_t localStartTime, uint32_t localEndTime,
1706                                                       uint8_t operatingModeDuringHoliday);
1707
1708 /**
1709  * @brief Door Lock Cluster SetPin Command callback
1710  * @param userId
1711  * @param userStatus
1712  * @param userType
1713  * @param pin
1714  */
1715
1716 bool emberAfDoorLockClusterSetPinCallback(uint16_t userId, uint8_t userStatus, uint8_t userType, uint8_t * pin);
1717
1718 /**
1719  * @brief Door Lock Cluster SetRfid Command callback
1720  * @param userId
1721  * @param userStatus
1722  * @param userType
1723  * @param id
1724  */
1725
1726 bool emberAfDoorLockClusterSetRfidCallback(uint16_t userId, uint8_t userStatus, uint8_t userType, uint8_t * id);
1727
1728 /**
1729  * @brief Door Lock Cluster SetUserType Command callback
1730  * @param userId
1731  * @param userType
1732  */
1733
1734 bool emberAfDoorLockClusterSetUserTypeCallback(uint16_t userId, uint8_t userType);
1735
1736 /**
1737  * @brief Door Lock Cluster SetWeekdaySchedule Command callback
1738  * @param scheduleId
1739  * @param userId
1740  * @param daysMask
1741  * @param startHour
1742  * @param startMinute
1743  * @param endHour
1744  * @param endMinute
1745  */
1746
1747 bool emberAfDoorLockClusterSetWeekdayScheduleCallback(uint8_t scheduleId, uint16_t userId, uint8_t daysMask, uint8_t startHour,
1748                                                       uint8_t startMinute, uint8_t endHour, uint8_t endMinute);
1749
1750 /**
1751  * @brief Door Lock Cluster SetYeardaySchedule Command callback
1752  * @param scheduleId
1753  * @param userId
1754  * @param localStartTime
1755  * @param localEndTime
1756  */
1757
1758 bool emberAfDoorLockClusterSetYeardayScheduleCallback(uint8_t scheduleId, uint16_t userId, uint32_t localStartTime,
1759                                                       uint32_t localEndTime);
1760
1761 /**
1762  * @brief Door Lock Cluster UnlockDoor Command callback
1763  * @param pin
1764  */
1765
1766 bool emberAfDoorLockClusterUnlockDoorCallback(uint8_t * PIN);
1767
1768 /**
1769  * @brief Door Lock Cluster UnlockWithTimeout Command callback
1770  * @param timeoutInSeconds
1771  * @param pin
1772  */
1773
1774 bool emberAfDoorLockClusterUnlockWithTimeoutCallback(uint16_t timeoutInSeconds, uint8_t * pin);
1775
1776 /**
1777  * @brief General Commissioning Cluster ArmFailSafe Command callback
1778  * @param expiryLengthSeconds
1779  * @param breadcrumb
1780  * @param timeoutMs
1781  */
1782
1783 bool emberAfGeneralCommissioningClusterArmFailSafeCallback(uint16_t expiryLengthSeconds, uint64_t breadcrumb, uint32_t timeoutMs);
1784
1785 /**
1786  * @brief General Commissioning Cluster CommissioningComplete Command callback
1787  */
1788
1789 bool emberAfGeneralCommissioningClusterCommissioningCompleteCallback();
1790
1791 /**
1792  * @brief General Commissioning Cluster SetFabric Command callback
1793  * @param fabricId
1794  * @param fabricSecret
1795  * @param breadcrumb
1796  * @param timeoutMs
1797  */
1798
1799 bool emberAfGeneralCommissioningClusterSetFabricCallback(uint8_t * fabricId, uint8_t * fabricSecret, uint64_t breadcrumb,
1800                                                          uint32_t timeoutMs);
1801
1802 /**
1803  * @brief Groups Cluster AddGroup Command callback
1804  * @param groupId
1805  * @param groupName
1806  */
1807
1808 bool emberAfGroupsClusterAddGroupCallback(uint16_t groupId, uint8_t * groupName);
1809
1810 /**
1811  * @brief Groups Cluster AddGroupIfIdentifying Command callback
1812  * @param groupId
1813  * @param groupName
1814  */
1815
1816 bool emberAfGroupsClusterAddGroupIfIdentifyingCallback(uint16_t groupId, uint8_t * groupName);
1817
1818 /**
1819  * @brief Groups Cluster GetGroupMembership Command callback
1820  * @param groupCount
1821  * @param groupList
1822  */
1823
1824 bool emberAfGroupsClusterGetGroupMembershipCallback(uint8_t groupCount,
1825                                                     /* TYPE WARNING: array array defaults to */ uint8_t * groupList);
1826
1827 /**
1828  * @brief Groups Cluster RemoveAllGroups Command callback
1829  */
1830
1831 bool emberAfGroupsClusterRemoveAllGroupsCallback();
1832
1833 /**
1834  * @brief Groups Cluster RemoveGroup Command callback
1835  * @param groupId
1836  */
1837
1838 bool emberAfGroupsClusterRemoveGroupCallback(uint16_t groupId);
1839
1840 /**
1841  * @brief Groups Cluster ViewGroup Command callback
1842  * @param groupId
1843  */
1844
1845 bool emberAfGroupsClusterViewGroupCallback(uint16_t groupId);
1846
1847 /**
1848  * @brief IAS Zone Cluster ZoneEnrollResponse Command callback
1849  * @param enrollResponseCode
1850  * @param zoneId
1851  */
1852
1853 bool emberAfIasZoneClusterZoneEnrollResponseCallback(uint8_t enrollResponseCode, uint8_t zoneId);
1854
1855 /**
1856  * @brief Identify Cluster Identify Command callback
1857  * @param identifyTime
1858  */
1859
1860 bool emberAfIdentifyClusterIdentifyCallback(uint16_t identifyTime);
1861
1862 /**
1863  * @brief Identify Cluster IdentifyQuery Command callback
1864  */
1865
1866 bool emberAfIdentifyClusterIdentifyQueryCallback();
1867
1868 /**
1869  * @brief Level Control Cluster Move Command callback
1870  * @param moveMode
1871  * @param rate
1872  * @param optionMask
1873  * @param optionOverride
1874  */
1875
1876 bool emberAfLevelControlClusterMoveCallback(uint8_t moveMode, uint8_t rate, uint8_t optionMask, uint8_t optionOverride);
1877
1878 /**
1879  * @brief Level Control Cluster MoveToLevel Command callback
1880  * @param level
1881  * @param transitionTime
1882  * @param optionMask
1883  * @param optionOverride
1884  */
1885
1886 bool emberAfLevelControlClusterMoveToLevelCallback(uint8_t level, uint16_t transitionTime, uint8_t optionMask,
1887                                                    uint8_t optionOverride);
1888
1889 /**
1890  * @brief Level Control Cluster MoveToLevelWithOnOff Command callback
1891  * @param level
1892  * @param transitionTime
1893  */
1894
1895 bool emberAfLevelControlClusterMoveToLevelWithOnOffCallback(uint8_t level, uint16_t transitionTime);
1896
1897 /**
1898  * @brief Level Control Cluster MoveWithOnOff Command callback
1899  * @param moveMode
1900  * @param rate
1901  */
1902
1903 bool emberAfLevelControlClusterMoveWithOnOffCallback(uint8_t moveMode, uint8_t rate);
1904
1905 /**
1906  * @brief Level Control Cluster Step Command callback
1907  * @param stepMode
1908  * @param stepSize
1909  * @param transitionTime
1910  * @param optionMask
1911  * @param optionOverride
1912  */
1913
1914 bool emberAfLevelControlClusterStepCallback(uint8_t stepMode, uint8_t stepSize, uint16_t transitionTime, uint8_t optionMask,
1915                                             uint8_t optionOverride);
1916
1917 /**
1918  * @brief Level Control Cluster StepWithOnOff Command callback
1919  * @param stepMode
1920  * @param stepSize
1921  * @param transitionTime
1922  */
1923
1924 bool emberAfLevelControlClusterStepWithOnOffCallback(uint8_t stepMode, uint8_t stepSize, uint16_t transitionTime);
1925
1926 /**
1927  * @brief Level Control Cluster Stop Command callback
1928  * @param optionMask
1929  * @param optionOverride
1930  */
1931
1932 bool emberAfLevelControlClusterStopCallback(uint8_t optionMask, uint8_t optionOverride);
1933
1934 /**
1935  * @brief Level Control Cluster StopWithOnOff Command callback
1936  */
1937
1938 bool emberAfLevelControlClusterStopWithOnOffCallback();
1939
1940 /**
1941  * @brief Low Power Cluster Sleep Command callback
1942  */
1943
1944 bool emberAfLowPowerClusterSleepCallback();
1945
1946 /**
1947  * @brief Media Playback Cluster FastForwardRequest Command callback
1948  */
1949
1950 bool emberAfMediaPlaybackClusterFastForwardRequestCallback();
1951
1952 /**
1953  * @brief Media Playback Cluster NextRequest Command callback
1954  */
1955
1956 bool emberAfMediaPlaybackClusterNextRequestCallback();
1957
1958 /**
1959  * @brief Media Playback Cluster PauseRequest Command callback
1960  */
1961
1962 bool emberAfMediaPlaybackClusterPauseRequestCallback();
1963
1964 /**
1965  * @brief Media Playback Cluster PlayRequest Command callback
1966  */
1967
1968 bool emberAfMediaPlaybackClusterPlayRequestCallback();
1969
1970 /**
1971  * @brief Media Playback Cluster PreviousRequest Command callback
1972  */
1973
1974 bool emberAfMediaPlaybackClusterPreviousRequestCallback();
1975
1976 /**
1977  * @brief Media Playback Cluster RewindRequest Command callback
1978  */
1979
1980 bool emberAfMediaPlaybackClusterRewindRequestCallback();
1981
1982 /**
1983  * @brief Media Playback Cluster SkipBackwardRequest Command callback
1984  */
1985
1986 bool emberAfMediaPlaybackClusterSkipBackwardRequestCallback();
1987
1988 /**
1989  * @brief Media Playback Cluster SkipForwardRequest Command callback
1990  */
1991
1992 bool emberAfMediaPlaybackClusterSkipForwardRequestCallback();
1993
1994 /**
1995  * @brief Media Playback Cluster StartOverRequest Command callback
1996  */
1997
1998 bool emberAfMediaPlaybackClusterStartOverRequestCallback();
1999
2000 /**
2001  * @brief Media Playback Cluster StopRequest Command callback
2002  */
2003
2004 bool emberAfMediaPlaybackClusterStopRequestCallback();
2005
2006 /**
2007  * @brief On/off Cluster Off Command callback
2008  */
2009
2010 bool emberAfOnOffClusterOffCallback();
2011
2012 /**
2013  * @brief On/off Cluster On Command callback
2014  */
2015
2016 bool emberAfOnOffClusterOnCallback();
2017
2018 /**
2019  * @brief On/off Cluster Toggle Command callback
2020  */
2021
2022 bool emberAfOnOffClusterToggleCallback();
2023
2024 /**
2025  * @brief Scenes Cluster AddScene Command callback
2026  * @param groupId
2027  * @param sceneId
2028  * @param transitionTime
2029  * @param sceneName
2030  * @param extensionFieldSets
2031  */
2032
2033 bool emberAfScenesClusterAddSceneCallback(uint16_t groupId, uint8_t sceneId, uint16_t transitionTime, uint8_t * sceneName,
2034                                           /* TYPE WARNING: array array defaults to */ uint8_t * extensionFieldSets);
2035
2036 /**
2037  * @brief Scenes Cluster GetSceneMembership Command callback
2038  * @param groupId
2039  */
2040
2041 bool emberAfScenesClusterGetSceneMembershipCallback(uint16_t groupId);
2042
2043 /**
2044  * @brief Scenes Cluster RecallScene Command callback
2045  * @param groupId
2046  * @param sceneId
2047  * @param transitionTime
2048  */
2049
2050 bool emberAfScenesClusterRecallSceneCallback(uint16_t groupId, uint8_t sceneId, uint16_t transitionTime);
2051
2052 /**
2053  * @brief Scenes Cluster RemoveAllScenes Command callback
2054  * @param groupId
2055  */
2056
2057 bool emberAfScenesClusterRemoveAllScenesCallback(uint16_t groupId);
2058
2059 /**
2060  * @brief Scenes Cluster RemoveScene Command callback
2061  * @param groupId
2062  * @param sceneId
2063  */
2064
2065 bool emberAfScenesClusterRemoveSceneCallback(uint16_t groupId, uint8_t sceneId);
2066
2067 /**
2068  * @brief Scenes Cluster StoreScene Command callback
2069  * @param groupId
2070  * @param sceneId
2071  */
2072
2073 bool emberAfScenesClusterStoreSceneCallback(uint16_t groupId, uint8_t sceneId);
2074
2075 /**
2076  * @brief Scenes Cluster ViewScene Command callback
2077  * @param groupId
2078  * @param sceneId
2079  */
2080
2081 bool emberAfScenesClusterViewSceneCallback(uint16_t groupId, uint8_t sceneId);
2082
2083 //
2084 // Non-Cluster Related Callbacks
2085 //
2086
2087 /** @brief Add To Current App Tasks
2088  *
2089  * This function is only useful to sleepy end devices.  This function will note
2090  * the passed item as part of a set of tasks the application has outstanding
2091  * (e.g. message sent requiring APS acknwoledgement).  This will affect how the
2092  * application behaves with regard to sleeping and polling.  Until the
2093  * outstanding task is completed, the device may poll more frequently and sleep
2094  * less often.
2095  *
2096  * @param tasks   Ver.: always
2097  */
2098 void emberAfAddToCurrentAppTasksCallback(EmberAfApplicationTask tasks);
2099
2100 /** @brief Remove From Current App Tasks
2101  *
2102  * This function is only useful to sleepy end devices.  This function will
2103  * remove the passed item from the set of tasks the application has outstanding
2104  * (e.g. message sent requiring APS acknwoledgement).  This will affect how the
2105  * application behaves with regard to sleeping and polling.  Removing the item
2106  * from the list of outstanding tasks may allow the device to sleep longer and
2107  * poll less frequently.  If there are other outstanding tasks the system may
2108  * still have to stay away and poll more often.
2109  *
2110  * @param tasks   Ver.: always
2111  */
2112 void emberAfRemoveFromCurrentAppTasksCallback(EmberAfApplicationTask tasks);
2113
2114 /** @brief Allow Network Write Attribute
2115  *
2116  * This function is called by the application framework before it writes an
2117  * attribute in response to a write attribute request from an external device.
2118  * The value passed into this callback is the value to which the attribute is to
2119  * be set by the framework.
2120         Example:        In mirroring simple metering data
2121  * on an Energy Services Interface (ESI) (formerly called Energy Service Portal
2122  * (ESP) in SE 1.0).), a mirrored simple meter needs to write read-only
2123  * attributes on its mirror. The-meter-mirror sample application, located in
2124  * app/framework/sample-apps, uses this callback to allow the mirrored device to
2125  * write simple metering attributes on the mirror regardless of the fact that
2126  * most simple metering attributes are defined as read-only by the ZigBee
2127  * specification.
2128         Note:   The ZCL specification does not (as of this
2129  * writing) specify any permission-level security for writing writeable
2130  * attributes. As far as the ZCL specification is concerned, if an attribute is
2131  * writeable, any device that has a link key for the device should be able to
2132  * write that attribute. Furthermore if an attribute is read only, it should not
2133  * be written over the air. Thus, if you implement permissions for writing
2134  * attributes as a feature, you MAY be operating outside the specification. This
2135  * is unlikely to be a problem for writing read-only attributes, but it may be a
2136  * problem for attributes that are writeable according to the specification but
2137  * restricted by the application implementing this callback.
2138  *
2139  * @param endpoint   Ver.: always
2140  * @param clusterId   Ver.: always
2141  * @param attributeId   Ver.: always
2142  * @param mask   Ver.: always
2143  * @param manufacturerCode   Ver.: always
2144  * @param value   Ver.: always
2145  * @param type   Ver.: always
2146  */
2147 EmberAfAttributeWritePermission emberAfAllowNetworkWriteAttributeCallback(chip::EndpointId endpoint, chip::ClusterId clusterId,
2148                                                                           chip::AttributeId attributeId, uint8_t mask,
2149                                                                           uint16_t manufacturerCode, uint8_t * value, uint8_t type);
2150
2151 /** @brief Attribute Read Access
2152  *
2153  * This function is called whenever the Application Framework needs to check
2154  * access permission for an attribute read.
2155  *
2156  * @param endpoint   Ver.: always
2157  * @param clusterId   Ver.: always
2158  * @param manufacturerCode   Ver.: always
2159  * @param attributeId   Ver.: always
2160  */
2161 bool emberAfAttributeReadAccessCallback(chip::EndpointId endpoint, chip::ClusterId clusterId, uint16_t manufacturerCode,
2162                                         chip::AttributeId attributeId);
2163
2164 /** @brief Attribute Write Access
2165  *
2166  * This function is called whenever the Application Framework needs to check
2167  * access permission for an attribute write.
2168  *
2169  * @param endpoint   Ver.: always
2170  * @param clusterId   Ver.: always
2171  * @param manufacturerCode   Ver.: always
2172  * @param attributeId   Ver.: always
2173  */
2174 bool emberAfAttributeWriteAccessCallback(chip::EndpointId endpoint, chip::ClusterId clusterId, uint16_t manufacturerCode,
2175                                          chip::AttributeId attributeId);
2176
2177 /** @brief Default Response
2178  *
2179  * This function is called by the application framework when a Default Response
2180  * command is received from an external device.  The application should return
2181  * true if the message was processed or false if it was not.
2182  *
2183  * @param clusterId The cluster identifier of this response.  Ver.: always
2184  * @param commandId The command identifier to which this is a response.  Ver.:
2185  * always
2186  * @param status Specifies either SUCCESS or the nature of the error that was
2187  * detected in the received command.  Ver.: always
2188  */
2189 bool emberAfDefaultResponseCallback(chip::ClusterId clusterId, chip::CommandId commandId, EmberAfStatus status);
2190
2191 /** @brief Configure Reporting Response
2192  *
2193  * This function is called by the application framework when a Configure
2194  * Reporting Response command is received from an external device.  The
2195  * application should return true if the message was processed or false if it
2196  * was not.
2197  *
2198  * @param clusterId The cluster identifier of this response.  Ver.: always
2199  * @param buffer Buffer containing the list of attribute status records.  Ver.:
2200  * always
2201  * @param bufLen The length in bytes of the list.  Ver.: always
2202  */
2203 bool emberAfConfigureReportingResponseCallback(chip::ClusterId clusterId, uint8_t * buffer, uint16_t bufLen);
2204
2205 /** @brief Read Reporting Configuration Response
2206  *
2207  * This function is called by the application framework when a Read Reporting
2208  * Configuration Response command is received from an external device.  The
2209  * application should return true if the message was processed or false if it
2210  * was not.
2211  *
2212  * @param clusterId The cluster identifier of this response.  Ver.: always
2213  * @param buffer Buffer containing the list of attribute reporting configuration
2214  * records.  Ver.: always
2215  * @param bufLen The length in bytes of the list.  Ver.: always
2216  */
2217 bool emberAfReadReportingConfigurationResponseCallback(chip::ClusterId clusterId, uint8_t * buffer, uint16_t bufLen);
2218
2219 /** @brief Discover Attributes Response
2220  *
2221  * This function is called by the application framework when a Discover
2222  * Attributes Response or Discover Attributes Extended Response command is
2223  * received from an external device.  The Discover Attributes Response command
2224  * contains a bool indicating if discovery is complete and a list of zero or
2225  * more attribute identifier/type records. The final argument indicates whether
2226  * the response is in the extended format or not.  The application should return
2227  * true if the message was processed or false if it was not.
2228  *
2229  * @param clusterId The cluster identifier of this response.  Ver.: always
2230  * @param discoveryComplete Indicates whether there are more attributes to be
2231  * discovered.  true if there are no more attributes to be discovered.  Ver.:
2232  * always
2233  * @param buffer Buffer containing the list of attribute identifier/type
2234  * records.  Ver.: always
2235  * @param bufLen The length in bytes of the list.  Ver.: always
2236  * @param extended Indicates whether the response is in the extended format or
2237  * not.  Ver.: always
2238  */
2239 bool emberAfDiscoverAttributesResponseCallback(chip::ClusterId clusterId, bool discoveryComplete, uint8_t * buffer, uint16_t bufLen,
2240                                                bool extended);
2241
2242 /** @brief Discover Commands Generated Response
2243  *
2244  * This function is called by the framework when Discover Commands Generated
2245  * Response is received.
2246  *
2247  * @param clusterId The cluster identifier of this response.  Ver.: always
2248  * @param manufacturerCode Manufacturer code  Ver.: always
2249  * @param discoveryComplete Indicates whether there are more commands to be
2250  * discovered.  Ver.: always
2251  * @param commandIds Buffer containing the list of command identifiers.  Ver.:
2252  * always
2253  * @param commandIdCount The length of bytes of the list, whish is the same as
2254  * the number of identifiers.  Ver.: always
2255  */
2256 bool emberAfDiscoverCommandsGeneratedResponseCallback(chip::ClusterId clusterId, uint16_t manufacturerCode, bool discoveryComplete,
2257                                                       chip::CommandId * commandIds, uint16_t commandIdCount);
2258
2259 /** @brief Discover Commands Received Response
2260  *
2261  * This function is called by the framework when Discover Commands Received
2262  * Response is received.
2263  *
2264  * @param clusterId The cluster identifier of this response.  Ver.: always
2265  * @param manufacturerCode Manufacturer code  Ver.: always
2266  * @param discoveryComplete Indicates whether there are more commands to be
2267  * discovered.  Ver.: always
2268  * @param commandIds Buffer containing the list of command identifiers.  Ver.:
2269  * always
2270  * @param commandIdCount The length of bytes of the list, whish is the same as
2271  * the number of identifiers.  Ver.: always
2272  */
2273 bool emberAfDiscoverCommandsReceivedResponseCallback(chip::ClusterId clusterId, uint16_t manufacturerCode, bool discoveryComplete,
2274                                                      chip::CommandId * commandIds, uint16_t commandIdCount);
2275
2276 /** @brief Pre Command Received
2277  *
2278  * This callback is the second in the Application Framework's message processing
2279  * chain. At this point in the processing of incoming over-the-air messages, the
2280  * application has determined that the incoming message is a ZCL command. It
2281  * parses enough of the message to populate an EmberAfClusterCommand struct. The
2282  * Application Framework defines this struct value in a local scope to the
2283  * command processing but also makes it available through a global pointer
2284  * called emberAfCurrentCommand, in app/framework/util/util.c. When command
2285  * processing is complete, this pointer is cleared.
2286  *
2287  * @param cmd   Ver.: always
2288  */
2289 bool emberAfPreCommandReceivedCallback(EmberAfClusterCommand * cmd);
2290
2291 /** @brief Pre Message Send
2292  *
2293  * This function is called by the framework when it is about to pass a message
2294  * to the stack primitives for sending.   This message may or may not be ZCL,
2295  * ZDO, or some other protocol.  This is called prior to
2296         any ZigBee
2297  * fragmentation that may be done.  If the function returns true it is assumed
2298  * the callback has consumed and processed the message.  The callback must also
2299  * set the EmberStatus status code to be passed back to the caller.  The
2300  * framework will do no further processing on the message.
2301         If the
2302  * function returns false then it is assumed that the callback has not processed
2303  * the mesasge and the framework will continue to process accordingly.
2304  *
2305  * @param messageStruct The structure containing the parameters of the APS
2306  * message to be sent.  Ver.: always
2307  * @param status A pointer to the status code value that will be returned to the
2308  * caller.  Ver.: always
2309  */
2310 bool emberAfPreMessageSendCallback(EmberAfMessageStruct * messageStruct, EmberStatus * status);
2311
2312 /** @brief Message Sent
2313  *
2314  * This function is called by the application framework from the message sent
2315  * handler, when it is informed by the stack regarding the message sent status.
2316  * All of the values passed to the emberMessageSentHandler are passed on to this
2317  * callback. This provides an opportunity for the application to verify that its
2318  * message has been sent successfully and take the appropriate action. This
2319  * callback should return a bool value of true or false. A value of true
2320  * indicates that the message sent notification has been handled and should not
2321  * be handled by the application framework.
2322  *
2323  * @param type   Ver.: always
2324  * @param indexOrDestination   Ver.: always
2325  * @param apsFrame   Ver.: always
2326  * @param msgLen   Ver.: always
2327  * @param message   Ver.: always
2328  * @param status   Ver.: always
2329  */
2330 bool emberAfMessageSentCallback(EmberOutgoingMessageType type, uint64_t indexOrDestination, EmberApsFrame * apsFrame,
2331                                 uint16_t msgLen, uint8_t * message, EmberStatus status);
2332
2333 /** @brief Pre Attribute Change
2334  *
2335  * This function is called by the application framework before it changes an
2336  * attribute value.  The value passed into this callback is the value to which
2337  * the attribute is to be set by the framework.  The application should return
2338  * ::EMBER_ZCL_STATUS_SUCCESS to permit the change or any other ::EmberAfStatus
2339  * to reject it.
2340  *
2341  * @param endpoint   Ver.: always
2342  * @param clusterId   Ver.: always
2343  * @param attributeId   Ver.: always
2344  * @param mask   Ver.: always
2345  * @param manufacturerCode   Ver.: always
2346  * @param type   Ver.: always
2347  * @param size   Ver.: always
2348  * @param value   Ver.: always
2349  */
2350 EmberAfStatus emberAfPreAttributeChangeCallback(chip::EndpointId endpoint, chip::ClusterId clusterId, chip::AttributeId attributeId,
2351                                                 uint8_t mask, uint16_t manufacturerCode, uint8_t type, uint8_t size,
2352                                                 uint8_t * value);
2353
2354 /** @brief Post Attribute Change
2355  *
2356  * This function is called by the application framework after it changes an
2357  * attribute value. The value passed into this callback is the value to which
2358  * the attribute was set by the framework.
2359  *
2360  * @param endpoint   Ver.: always
2361  * @param clusterId   Ver.: always
2362  * @param attributeId   Ver.: always
2363  * @param mask   Ver.: always
2364  * @param manufacturerCode   Ver.: always
2365  * @param type   Ver.: always
2366  * @param size   Ver.: always
2367  * @param value   Ver.: always
2368  */
2369 void emberAfPostAttributeChangeCallback(chip::EndpointId endpoint, chip::ClusterId clusterId, chip::AttributeId attributeId,
2370                                         uint8_t mask, uint16_t manufacturerCode, uint8_t type, uint8_t size, uint8_t * value);
2371
2372 /** @brief Read Attributes Response
2373  *
2374  * This function is called by the application framework when a Read Attributes
2375  * Response command is received from an external device.  The application should
2376  * return true if the message was processed or false if it was not.
2377  *
2378  * @param clusterId The cluster identifier of this response.  Ver.: always
2379  * @param buffer Buffer containing the list of read attribute status records.
2380  * Ver.: always
2381  * @param bufLen The length in bytes of the list.  Ver.: always
2382  */
2383 bool emberAfReadAttributesResponseCallback(chip::ClusterId clusterId, uint8_t * buffer, uint16_t bufLen);
2384
2385 /** @brief External Attribute Read
2386  *
2387  * Like emberAfExternalAttributeWriteCallback above, this function is called
2388  * when the framework needs to read an attribute that is not stored within the
2389  * Application Framework's data structures.
2390         All of the important
2391  * information about the attribute itself is passed as a pointer to an
2392  * EmberAfAttributeMetadata struct, which is stored within the application and
2393  * used to manage the attribute. A complete description of the
2394  * EmberAfAttributeMetadata struct is provided in
2395  * app/framework/include/af-types.h
2396         This function assumes that the
2397  * application is able to read the attribute, write it into the passed buffer,
2398  * and return immediately. Any attributes that require a state machine for
2399  * reading and writing are not really candidates for externalization at the
2400  * present time. The Application Framework does not currently include a state
2401  * machine for reading or writing attributes that must take place across a
2402  * series of application ticks. Attributes that cannot be read in a timely
2403  * manner should be stored within the Application Framework and updated
2404  * occasionally by the application code from within the
2405  * emberAfMainTickCallback.
2406         If the application was successfully able to
2407  * read the attribute and write it into the passed buffer, it should return a
2408  * value of EMBER_ZCL_STATUS_SUCCESS. Ensure that the size of the externally
2409  * managed attribute value is smaller than what the buffer can hold. In the case
2410  * of a buffer overflow throw an appropriate error such as
2411  * EMBER_ZCL_STATUS_INSUFFICIENT_SPACE. Any other return value indicates the
2412  * application was not able to read the attribute.
2413  *
2414  * @param endpoint   Ver.: always
2415  * @param clusterId   Ver.: always
2416  * @param attributeMetadata   Ver.: always
2417  * @param manufacturerCode   Ver.: always
2418  * @param buffer   Ver.: always
2419  * @param maxReadLength   Ver.: always
2420  */
2421 EmberAfStatus emberAfExternalAttributeReadCallback(chip::EndpointId endpoint, chip::ClusterId clusterId,
2422                                                    EmberAfAttributeMetadata * attributeMetadata, uint16_t manufacturerCode,
2423                                                    uint8_t * buffer, uint16_t maxReadLength);
2424
2425 /** @brief Write Attributes Response
2426  *
2427  * This function is called by the application framework when a Write Attributes
2428  * Response command is received from an external device.  The application should
2429  * return true if the message was processed or false if it was not.
2430  *
2431  * @param clusterId The cluster identifier of this response.  Ver.: always
2432  * @param buffer Buffer containing the list of write attribute status records.
2433  * Ver.: always
2434  * @param bufLen The length in bytes of the list.  Ver.: always
2435  */
2436 bool emberAfWriteAttributesResponseCallback(chip::ClusterId clusterId, uint8_t * buffer, uint16_t bufLen);
2437
2438 /** @brief External Attribute Write
2439  *
2440  * This function is called whenever the Application Framework needs to write an
2441  * attribute which is not stored within the data structures of the Application
2442  * Framework itself. One of the new features in Version 2 is the ability to
2443  * store attributes outside the Framework. This is particularly useful for
2444  * attributes that do not need to be stored because they can be read off the
2445  * hardware when they are needed, or are stored in some central location used by
2446  * many modules within the system. In this case, you can indicate that the
2447  * attribute is stored externally. When the framework needs to write an external
2448  * attribute, it makes a call to this callback.
2449         This callback is very
2450  * useful for host micros which need to store attributes in persistent memory.
2451  * Because each host micro (used with an Ember NCP) has its own type of
2452  * persistent memory storage, the Application Framework does not include the
2453  * ability to mark attributes as stored in flash the way that it does for Ember
2454  * SoCs like the EM35x. On a host micro, any attributes that need to be stored
2455  * in persistent memory should be marked as external and accessed through the
2456  * external read and write callbacks. Any host code associated with the
2457  * persistent storage should be implemented within this callback.
2458         All of
2459  * the important information about the attribute itself is passed as a pointer
2460  * to an EmberAfAttributeMetadata struct, which is stored within the application
2461  * and used to manage the attribute. A complete description of the
2462  * EmberAfAttributeMetadata struct is provided in
2463  * app/framework/include/af-types.h.
2464         This function assumes that the
2465  * application is able to write the attribute and return immediately. Any
2466  * attributes that require a state machine for reading and writing are not
2467  * candidates for externalization at the present time. The Application Framework
2468  * does not currently include a state machine for reading or writing attributes
2469  * that must take place across a series of application ticks. Attributes that
2470  * cannot be written immediately should be stored within the Application
2471  * Framework and updated occasionally by the application code from within the
2472  * emberAfMainTickCallback.
2473         If the application was successfully able to
2474  * write the attribute, it returns a value of EMBER_ZCL_STATUS_SUCCESS. Any
2475  * other return value indicates the application was not able to write the
2476  * attribute.
2477  *
2478  * @param endpoint   Ver.: always
2479  * @param clusterId   Ver.: always
2480  * @param attributeMetadata   Ver.: always
2481  * @param manufacturerCode   Ver.: always
2482  * @param buffer   Ver.: always
2483  */
2484 EmberAfStatus emberAfExternalAttributeWriteCallback(chip::EndpointId endpoint, chip::ClusterId clusterId,
2485                                                     EmberAfAttributeMetadata * attributeMetadata, uint16_t manufacturerCode,
2486                                                     uint8_t * buffer);
2487
2488 /** @brief Report Attributes
2489  *
2490  * This function is called by the application framework when a Report Attributes
2491  * command is received from an external device.  The application should return
2492  * true if the message was processed or false if it was not.
2493  *
2494  * @param clusterId The cluster identifier of this command.  Ver.: always
2495  * @param buffer Buffer containing the list of attribute report records.  Ver.:
2496  * always
2497  * @param bufLen The length in bytes of the list.  Ver.: always
2498  */
2499 bool emberAfReportAttributesCallback(chip::ClusterId clusterId, uint8_t * buffer, uint16_t bufLen);
2500
2501 /** @brief Get Current Time
2502  *
2503  * This callback is called when device attempts to get current time from the
2504  * hardware. If this device has means to retrieve exact time, then this method
2505  * should implement it. If the callback can't provide the exact time it should
2506  * return 0 to indicate failure. Default action is to return 0, which indicates
2507  * that device does not have access to real time.
2508  *
2509  */
2510 uint32_t emberAfGetCurrentTimeCallback();
2511
2512 /** @brief Get Endpoint Info
2513  *
2514  * This function is a callback to an application implemented endpoint that
2515  * operates outside the normal application framework.  When the framework wishes
2516  * to perform operations with that endpoint it uses this callback to retrieve
2517  * the endpoint's information.  If the endpoint exists and the application can
2518  * provide data then true shall be returned.  Otherwise the callback must return
2519  * false.
2520  *
2521  * @param endpoint The endpoint to retrieve data for.  Ver.: always
2522  * @param returnNetworkIndex The index corresponding to the ZigBee network the
2523  * endpoint belongs to.  If not using a multi-network device, 0 must be
2524  * returned.  Otherwise on a multi-network device the stack will switch to this
2525  * network before sending the message.  Ver.: always
2526  * @param returnEndpointInfo A pointer to a data struct that will be written
2527  * with information about the endpoint.  Ver.: always
2528  */
2529 bool emberAfGetEndpointInfoCallback(chip::EndpointId endpoint, uint8_t * returnNetworkIndex,
2530                                     EmberAfEndpointInfoStruct * returnEndpointInfo);
2531
2532 /** @brief Get Source Route Overhead
2533  *
2534  * This function is called by the framework to determine the overhead required
2535  * in the network frame for source routing to a particular destination.
2536  *
2537  * @param destination The node id of the destination  Ver.: always
2538  */
2539 uint8_t emberAfGetSourceRouteOverheadCallback(chip::NodeId destination);
2540
2541 /** @brief Registration Abort
2542  *
2543  * This callback is called when the device should abort the registration
2544  * process.
2545  *
2546  */
2547 void emberAfRegistrationAbortCallback();
2548
2549 /** @brief Interpan Send Message
2550  *
2551  * This function will send a raw MAC message with interpan frame format using
2552  * the passed parameters.
2553  *
2554  * @param header Interpan header info  Ver.: always
2555  * @param messageLength The length of the message received or to send  Ver.:
2556  * always
2557  * @param message The message data received or to send.  Ver.: always
2558  */
2559 EmberStatus emberAfInterpanSendMessageCallback(EmberAfInterpanHeader * header, uint16_t messageLength, uint8_t * message);
2560
2561 /** @brief Start Move
2562  *
2563  * This function is called to initiate the process for a device to move (rejoin)
2564  * to a new parent.
2565  *
2566  */
2567 bool emberAfStartMoveCallback();