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 Binding Cluster Bind Command callback
1391  * @param nodeId
1392  * @param groupId
1393  * @param endpointId
1394  * @param clusterId
1395  */
1396
1397 bool emberAfBindingClusterBindCallback(chip::NodeId nodeId, chip::GroupId groupId, chip::EndpointId endpointId,
1398                                        chip::ClusterId clusterId);
1399
1400 /**
1401  * @brief Binding Cluster Unbind Command callback
1402  * @param nodeId
1403  * @param groupId
1404  * @param endpointId
1405  * @param clusterId
1406  */
1407
1408 bool emberAfBindingClusterUnbindCallback(chip::NodeId nodeId, chip::GroupId groupId, chip::EndpointId endpointId,
1409                                          chip::ClusterId clusterId);
1410
1411 /**
1412  * @brief Color Control Cluster MoveColor Command callback
1413  * @param rateX
1414  * @param rateY
1415  * @param optionsMask
1416  * @param optionsOverride
1417  */
1418
1419 bool emberAfColorControlClusterMoveColorCallback(int16_t rateX, int16_t rateY, uint8_t optionsMask, uint8_t optionsOverride);
1420
1421 /**
1422  * @brief Color Control Cluster MoveColorTemperature Command callback
1423  * @param moveMode
1424  * @param rate
1425  * @param colorTemperatureMinimum
1426  * @param colorTemperatureMaximum
1427  * @param optionsMask
1428  * @param optionsOverride
1429  */
1430
1431 bool emberAfColorControlClusterMoveColorTemperatureCallback(uint8_t moveMode, uint16_t rate, uint16_t colorTemperatureMinimum,
1432                                                             uint16_t colorTemperatureMaximum, uint8_t optionsMask,
1433                                                             uint8_t optionsOverride);
1434
1435 /**
1436  * @brief Color Control Cluster MoveHue Command callback
1437  * @param moveMode
1438  * @param rate
1439  * @param optionsMask
1440  * @param optionsOverride
1441  */
1442
1443 bool emberAfColorControlClusterMoveHueCallback(uint8_t moveMode, uint8_t rate, uint8_t optionsMask, uint8_t optionsOverride);
1444
1445 /**
1446  * @brief Color Control Cluster MoveSaturation Command callback
1447  * @param moveMode
1448  * @param rate
1449  * @param optionsMask
1450  * @param optionsOverride
1451  */
1452
1453 bool emberAfColorControlClusterMoveSaturationCallback(uint8_t moveMode, uint8_t rate, uint8_t optionsMask, uint8_t optionsOverride);
1454
1455 /**
1456  * @brief Color Control Cluster MoveToColor Command callback
1457  * @param colorX
1458  * @param colorY
1459  * @param transitionTime
1460  * @param optionsMask
1461  * @param optionsOverride
1462  */
1463
1464 bool emberAfColorControlClusterMoveToColorCallback(uint16_t colorX, uint16_t colorY, uint16_t transitionTime, uint8_t optionsMask,
1465                                                    uint8_t optionsOverride);
1466
1467 /**
1468  * @brief Color Control Cluster MoveToColorTemperature Command callback
1469  * @param colorTemperature
1470  * @param transitionTime
1471  * @param optionsMask
1472  * @param optionsOverride
1473  */
1474
1475 bool emberAfColorControlClusterMoveToColorTemperatureCallback(uint16_t colorTemperature, uint16_t transitionTime,
1476                                                               uint8_t optionsMask, uint8_t optionsOverride);
1477
1478 /**
1479  * @brief Color Control Cluster MoveToHue Command callback
1480  * @param hue
1481  * @param direction
1482  * @param transitionTime
1483  * @param optionsMask
1484  * @param optionsOverride
1485  */
1486
1487 bool emberAfColorControlClusterMoveToHueCallback(uint8_t hue, uint8_t direction, uint16_t transitionTime, uint8_t optionsMask,
1488                                                  uint8_t optionsOverride);
1489
1490 /**
1491  * @brief Color Control Cluster MoveToHueAndSaturation Command callback
1492  * @param hue
1493  * @param saturation
1494  * @param transitionTime
1495  * @param optionsMask
1496  * @param optionsOverride
1497  */
1498
1499 bool emberAfColorControlClusterMoveToHueAndSaturationCallback(uint8_t hue, uint8_t saturation, uint16_t transitionTime,
1500                                                               uint8_t optionsMask, uint8_t optionsOverride);
1501
1502 /**
1503  * @brief Color Control Cluster MoveToSaturation Command callback
1504  * @param saturation
1505  * @param transitionTime
1506  * @param optionsMask
1507  * @param optionsOverride
1508  */
1509
1510 bool emberAfColorControlClusterMoveToSaturationCallback(uint8_t saturation, uint16_t transitionTime, uint8_t optionsMask,
1511                                                         uint8_t optionsOverride);
1512
1513 /**
1514  * @brief Color Control Cluster StepColor Command callback
1515  * @param stepX
1516  * @param stepY
1517  * @param transitionTime
1518  * @param optionsMask
1519  * @param optionsOverride
1520  */
1521
1522 bool emberAfColorControlClusterStepColorCallback(int16_t stepX, int16_t stepY, uint16_t transitionTime, uint8_t optionsMask,
1523                                                  uint8_t optionsOverride);
1524
1525 /**
1526  * @brief Color Control Cluster StepColorTemperature Command callback
1527  * @param stepMode
1528  * @param stepSize
1529  * @param transitionTime
1530  * @param colorTemperatureMinimum
1531  * @param colorTemperatureMaximum
1532  * @param optionsMask
1533  * @param optionsOverride
1534  */
1535
1536 bool emberAfColorControlClusterStepColorTemperatureCallback(uint8_t stepMode, uint16_t stepSize, uint16_t transitionTime,
1537                                                             uint16_t colorTemperatureMinimum, uint16_t colorTemperatureMaximum,
1538                                                             uint8_t optionsMask, uint8_t optionsOverride);
1539
1540 /**
1541  * @brief Color Control Cluster StepHue Command callback
1542  * @param stepMode
1543  * @param stepSize
1544  * @param transitionTime
1545  * @param optionsMask
1546  * @param optionsOverride
1547  */
1548
1549 bool emberAfColorControlClusterStepHueCallback(uint8_t stepMode, uint8_t stepSize, uint8_t transitionTime, uint8_t optionsMask,
1550                                                uint8_t optionsOverride);
1551
1552 /**
1553  * @brief Color Control Cluster StepSaturation Command callback
1554  * @param stepMode
1555  * @param stepSize
1556  * @param transitionTime
1557  * @param optionsMask
1558  * @param optionsOverride
1559  */
1560
1561 bool emberAfColorControlClusterStepSaturationCallback(uint8_t stepMode, uint8_t stepSize, uint8_t transitionTime,
1562                                                       uint8_t optionsMask, uint8_t optionsOverride);
1563
1564 /**
1565  * @brief Color Control Cluster StopMoveStep Command callback
1566  * @param optionsMask
1567  * @param optionsOverride
1568  */
1569
1570 bool emberAfColorControlClusterStopMoveStepCallback(uint8_t optionsMask, uint8_t optionsOverride);
1571
1572 /**
1573  * @brief Content Launch Cluster LaunchContent Command callback
1574  */
1575
1576 bool emberAfContentLaunchClusterLaunchContentCallback();
1577
1578 /**
1579  * @brief Content Launch Cluster LaunchURL Command callback
1580  */
1581
1582 bool emberAfContentLaunchClusterLaunchURLCallback();
1583
1584 /**
1585  * @brief Door Lock Cluster ClearAllPins Command callback
1586  */
1587
1588 bool emberAfDoorLockClusterClearAllPinsCallback();
1589
1590 /**
1591  * @brief Door Lock Cluster ClearAllRfids Command callback
1592  */
1593
1594 bool emberAfDoorLockClusterClearAllRfidsCallback();
1595
1596 /**
1597  * @brief Door Lock Cluster ClearHolidaySchedule Command callback
1598  * @param scheduleId
1599  */
1600
1601 bool emberAfDoorLockClusterClearHolidayScheduleCallback(uint8_t scheduleId);
1602
1603 /**
1604  * @brief Door Lock Cluster ClearPin Command callback
1605  * @param userId
1606  */
1607
1608 bool emberAfDoorLockClusterClearPinCallback(uint16_t userId);
1609
1610 /**
1611  * @brief Door Lock Cluster ClearRfid Command callback
1612  * @param userId
1613  */
1614
1615 bool emberAfDoorLockClusterClearRfidCallback(uint16_t userId);
1616
1617 /**
1618  * @brief Door Lock Cluster ClearWeekdaySchedule Command callback
1619  * @param scheduleId
1620  * @param userId
1621  */
1622
1623 bool emberAfDoorLockClusterClearWeekdayScheduleCallback(uint8_t scheduleId, uint16_t userId);
1624
1625 /**
1626  * @brief Door Lock Cluster ClearYeardaySchedule Command callback
1627  * @param scheduleId
1628  * @param userId
1629  */
1630
1631 bool emberAfDoorLockClusterClearYeardayScheduleCallback(uint8_t scheduleId, uint16_t userId);
1632
1633 /**
1634  * @brief Door Lock Cluster GetHolidaySchedule Command callback
1635  * @param scheduleId
1636  */
1637
1638 bool emberAfDoorLockClusterGetHolidayScheduleCallback(uint8_t scheduleId);
1639
1640 /**
1641  * @brief Door Lock Cluster GetLogRecord Command callback
1642  * @param logIndex
1643  */
1644
1645 bool emberAfDoorLockClusterGetLogRecordCallback(uint16_t logIndex);
1646
1647 /**
1648  * @brief Door Lock Cluster GetPin Command callback
1649  * @param userId
1650  */
1651
1652 bool emberAfDoorLockClusterGetPinCallback(uint16_t userId);
1653
1654 /**
1655  * @brief Door Lock Cluster GetRfid Command callback
1656  * @param userId
1657  */
1658
1659 bool emberAfDoorLockClusterGetRfidCallback(uint16_t userId);
1660
1661 /**
1662  * @brief Door Lock Cluster GetUserType Command callback
1663  * @param userId
1664  */
1665
1666 bool emberAfDoorLockClusterGetUserTypeCallback(uint16_t userId);
1667
1668 /**
1669  * @brief Door Lock Cluster GetWeekdaySchedule Command callback
1670  * @param scheduleId
1671  * @param userId
1672  */
1673
1674 bool emberAfDoorLockClusterGetWeekdayScheduleCallback(uint8_t scheduleId, uint16_t userId);
1675
1676 /**
1677  * @brief Door Lock Cluster GetYeardaySchedule Command callback
1678  * @param scheduleId
1679  * @param userId
1680  */
1681
1682 bool emberAfDoorLockClusterGetYeardayScheduleCallback(uint8_t scheduleId, uint16_t userId);
1683
1684 /**
1685  * @brief Door Lock Cluster LockDoor Command callback
1686  * @param pin
1687  */
1688
1689 bool emberAfDoorLockClusterLockDoorCallback(uint8_t * PIN);
1690
1691 /**
1692  * @brief Door Lock Cluster SetHolidaySchedule Command callback
1693  * @param scheduleId
1694  * @param localStartTime
1695  * @param localEndTime
1696  * @param operatingModeDuringHoliday
1697  */
1698
1699 bool emberAfDoorLockClusterSetHolidayScheduleCallback(uint8_t scheduleId, uint32_t localStartTime, uint32_t localEndTime,
1700                                                       uint8_t operatingModeDuringHoliday);
1701
1702 /**
1703  * @brief Door Lock Cluster SetPin Command callback
1704  * @param userId
1705  * @param userStatus
1706  * @param userType
1707  * @param pin
1708  */
1709
1710 bool emberAfDoorLockClusterSetPinCallback(uint16_t userId, uint8_t userStatus, uint8_t userType, uint8_t * pin);
1711
1712 /**
1713  * @brief Door Lock Cluster SetRfid Command callback
1714  * @param userId
1715  * @param userStatus
1716  * @param userType
1717  * @param id
1718  */
1719
1720 bool emberAfDoorLockClusterSetRfidCallback(uint16_t userId, uint8_t userStatus, uint8_t userType, uint8_t * id);
1721
1722 /**
1723  * @brief Door Lock Cluster SetUserType Command callback
1724  * @param userId
1725  * @param userType
1726  */
1727
1728 bool emberAfDoorLockClusterSetUserTypeCallback(uint16_t userId, uint8_t userType);
1729
1730 /**
1731  * @brief Door Lock Cluster SetWeekdaySchedule Command callback
1732  * @param scheduleId
1733  * @param userId
1734  * @param daysMask
1735  * @param startHour
1736  * @param startMinute
1737  * @param endHour
1738  * @param endMinute
1739  */
1740
1741 bool emberAfDoorLockClusterSetWeekdayScheduleCallback(uint8_t scheduleId, uint16_t userId, uint8_t daysMask, uint8_t startHour,
1742                                                       uint8_t startMinute, uint8_t endHour, uint8_t endMinute);
1743
1744 /**
1745  * @brief Door Lock Cluster SetYeardaySchedule Command callback
1746  * @param scheduleId
1747  * @param userId
1748  * @param localStartTime
1749  * @param localEndTime
1750  */
1751
1752 bool emberAfDoorLockClusterSetYeardayScheduleCallback(uint8_t scheduleId, uint16_t userId, uint32_t localStartTime,
1753                                                       uint32_t localEndTime);
1754
1755 /**
1756  * @brief Door Lock Cluster UnlockDoor Command callback
1757  * @param pin
1758  */
1759
1760 bool emberAfDoorLockClusterUnlockDoorCallback(uint8_t * PIN);
1761
1762 /**
1763  * @brief Door Lock Cluster UnlockWithTimeout Command callback
1764  * @param timeoutInSeconds
1765  * @param pin
1766  */
1767
1768 bool emberAfDoorLockClusterUnlockWithTimeoutCallback(uint16_t timeoutInSeconds, uint8_t * pin);
1769
1770 /**
1771  * @brief General Commissioning Cluster ArmFailSafe Command callback
1772  * @param expiryLengthSeconds
1773  * @param breadcrumb
1774  * @param timeoutMs
1775  */
1776
1777 bool emberAfGeneralCommissioningClusterArmFailSafeCallback(uint16_t expiryLengthSeconds, uint64_t breadcrumb, uint32_t timeoutMs);
1778
1779 /**
1780  * @brief General Commissioning Cluster CommissioningComplete Command callback
1781  */
1782
1783 bool emberAfGeneralCommissioningClusterCommissioningCompleteCallback();
1784
1785 /**
1786  * @brief General Commissioning Cluster SetFabric Command callback
1787  * @param fabricId
1788  * @param fabricSecret
1789  * @param breadcrumb
1790  * @param timeoutMs
1791  */
1792
1793 bool emberAfGeneralCommissioningClusterSetFabricCallback(uint8_t * fabricId, uint8_t * fabricSecret, uint64_t breadcrumb,
1794                                                          uint32_t timeoutMs);
1795
1796 /**
1797  * @brief Groups Cluster AddGroup Command callback
1798  * @param groupId
1799  * @param groupName
1800  */
1801
1802 bool emberAfGroupsClusterAddGroupCallback(uint16_t groupId, uint8_t * groupName);
1803
1804 /**
1805  * @brief Groups Cluster AddGroupIfIdentifying Command callback
1806  * @param groupId
1807  * @param groupName
1808  */
1809
1810 bool emberAfGroupsClusterAddGroupIfIdentifyingCallback(uint16_t groupId, uint8_t * groupName);
1811
1812 /**
1813  * @brief Groups Cluster GetGroupMembership Command callback
1814  * @param groupCount
1815  * @param groupList
1816  */
1817
1818 bool emberAfGroupsClusterGetGroupMembershipCallback(uint8_t groupCount,
1819                                                     /* TYPE WARNING: array array defaults to */ uint8_t * groupList);
1820
1821 /**
1822  * @brief Groups Cluster RemoveAllGroups Command callback
1823  */
1824
1825 bool emberAfGroupsClusterRemoveAllGroupsCallback();
1826
1827 /**
1828  * @brief Groups Cluster RemoveGroup Command callback
1829  * @param groupId
1830  */
1831
1832 bool emberAfGroupsClusterRemoveGroupCallback(uint16_t groupId);
1833
1834 /**
1835  * @brief Groups Cluster ViewGroup Command callback
1836  * @param groupId
1837  */
1838
1839 bool emberAfGroupsClusterViewGroupCallback(uint16_t groupId);
1840
1841 /**
1842  * @brief IAS Zone Cluster ZoneEnrollResponse Command callback
1843  * @param enrollResponseCode
1844  * @param zoneId
1845  */
1846
1847 bool emberAfIasZoneClusterZoneEnrollResponseCallback(uint8_t enrollResponseCode, uint8_t zoneId);
1848
1849 /**
1850  * @brief Identify Cluster Identify Command callback
1851  * @param identifyTime
1852  */
1853
1854 bool emberAfIdentifyClusterIdentifyCallback(uint16_t identifyTime);
1855
1856 /**
1857  * @brief Identify Cluster IdentifyQuery Command callback
1858  */
1859
1860 bool emberAfIdentifyClusterIdentifyQueryCallback();
1861
1862 /**
1863  * @brief Level Control Cluster Move Command callback
1864  * @param moveMode
1865  * @param rate
1866  * @param optionMask
1867  * @param optionOverride
1868  */
1869
1870 bool emberAfLevelControlClusterMoveCallback(uint8_t moveMode, uint8_t rate, uint8_t optionMask, uint8_t optionOverride);
1871
1872 /**
1873  * @brief Level Control Cluster MoveToLevel Command callback
1874  * @param level
1875  * @param transitionTime
1876  * @param optionMask
1877  * @param optionOverride
1878  */
1879
1880 bool emberAfLevelControlClusterMoveToLevelCallback(uint8_t level, uint16_t transitionTime, uint8_t optionMask,
1881                                                    uint8_t optionOverride);
1882
1883 /**
1884  * @brief Level Control Cluster MoveToLevelWithOnOff Command callback
1885  * @param level
1886  * @param transitionTime
1887  */
1888
1889 bool emberAfLevelControlClusterMoveToLevelWithOnOffCallback(uint8_t level, uint16_t transitionTime);
1890
1891 /**
1892  * @brief Level Control Cluster MoveWithOnOff Command callback
1893  * @param moveMode
1894  * @param rate
1895  */
1896
1897 bool emberAfLevelControlClusterMoveWithOnOffCallback(uint8_t moveMode, uint8_t rate);
1898
1899 /**
1900  * @brief Level Control Cluster Step Command callback
1901  * @param stepMode
1902  * @param stepSize
1903  * @param transitionTime
1904  * @param optionMask
1905  * @param optionOverride
1906  */
1907
1908 bool emberAfLevelControlClusterStepCallback(uint8_t stepMode, uint8_t stepSize, uint16_t transitionTime, uint8_t optionMask,
1909                                             uint8_t optionOverride);
1910
1911 /**
1912  * @brief Level Control Cluster StepWithOnOff Command callback
1913  * @param stepMode
1914  * @param stepSize
1915  * @param transitionTime
1916  */
1917
1918 bool emberAfLevelControlClusterStepWithOnOffCallback(uint8_t stepMode, uint8_t stepSize, uint16_t transitionTime);
1919
1920 /**
1921  * @brief Level Control Cluster Stop Command callback
1922  * @param optionMask
1923  * @param optionOverride
1924  */
1925
1926 bool emberAfLevelControlClusterStopCallback(uint8_t optionMask, uint8_t optionOverride);
1927
1928 /**
1929  * @brief Level Control Cluster StopWithOnOff Command callback
1930  */
1931
1932 bool emberAfLevelControlClusterStopWithOnOffCallback();
1933
1934 /**
1935  * @brief Low Power Cluster Sleep Command callback
1936  */
1937
1938 bool emberAfLowPowerClusterSleepCallback();
1939
1940 /**
1941  * @brief Media Playback Cluster FastForwardRequest Command callback
1942  */
1943
1944 bool emberAfMediaPlaybackClusterFastForwardRequestCallback();
1945
1946 /**
1947  * @brief Media Playback Cluster NextRequest Command callback
1948  */
1949
1950 bool emberAfMediaPlaybackClusterNextRequestCallback();
1951
1952 /**
1953  * @brief Media Playback Cluster PauseRequest Command callback
1954  */
1955
1956 bool emberAfMediaPlaybackClusterPauseRequestCallback();
1957
1958 /**
1959  * @brief Media Playback Cluster PlayRequest Command callback
1960  */
1961
1962 bool emberAfMediaPlaybackClusterPlayRequestCallback();
1963
1964 /**
1965  * @brief Media Playback Cluster PreviousRequest Command callback
1966  */
1967
1968 bool emberAfMediaPlaybackClusterPreviousRequestCallback();
1969
1970 /**
1971  * @brief Media Playback Cluster RewindRequest Command callback
1972  */
1973
1974 bool emberAfMediaPlaybackClusterRewindRequestCallback();
1975
1976 /**
1977  * @brief Media Playback Cluster SkipBackwardRequest Command callback
1978  */
1979
1980 bool emberAfMediaPlaybackClusterSkipBackwardRequestCallback();
1981
1982 /**
1983  * @brief Media Playback Cluster SkipForwardRequest Command callback
1984  */
1985
1986 bool emberAfMediaPlaybackClusterSkipForwardRequestCallback();
1987
1988 /**
1989  * @brief Media Playback Cluster StartOverRequest Command callback
1990  */
1991
1992 bool emberAfMediaPlaybackClusterStartOverRequestCallback();
1993
1994 /**
1995  * @brief Media Playback Cluster StopRequest Command callback
1996  */
1997
1998 bool emberAfMediaPlaybackClusterStopRequestCallback();
1999
2000 /**
2001  * @brief On/off Cluster Off Command callback
2002  */
2003
2004 bool emberAfOnOffClusterOffCallback();
2005
2006 /**
2007  * @brief On/off Cluster On Command callback
2008  */
2009
2010 bool emberAfOnOffClusterOnCallback();
2011
2012 /**
2013  * @brief On/off Cluster Toggle Command callback
2014  */
2015
2016 bool emberAfOnOffClusterToggleCallback();
2017
2018 /**
2019  * @brief Scenes Cluster AddScene Command callback
2020  * @param groupId
2021  * @param sceneId
2022  * @param transitionTime
2023  * @param sceneName
2024  * @param extensionFieldSets
2025  */
2026
2027 bool emberAfScenesClusterAddSceneCallback(uint16_t groupId, uint8_t sceneId, uint16_t transitionTime, uint8_t * sceneName,
2028                                           /* TYPE WARNING: array array defaults to */ uint8_t * extensionFieldSets);
2029
2030 /**
2031  * @brief Scenes Cluster GetSceneMembership Command callback
2032  * @param groupId
2033  */
2034
2035 bool emberAfScenesClusterGetSceneMembershipCallback(uint16_t groupId);
2036
2037 /**
2038  * @brief Scenes Cluster RecallScene Command callback
2039  * @param groupId
2040  * @param sceneId
2041  * @param transitionTime
2042  */
2043
2044 bool emberAfScenesClusterRecallSceneCallback(uint16_t groupId, uint8_t sceneId, uint16_t transitionTime);
2045
2046 /**
2047  * @brief Scenes Cluster RemoveAllScenes Command callback
2048  * @param groupId
2049  */
2050
2051 bool emberAfScenesClusterRemoveAllScenesCallback(uint16_t groupId);
2052
2053 /**
2054  * @brief Scenes Cluster RemoveScene Command callback
2055  * @param groupId
2056  * @param sceneId
2057  */
2058
2059 bool emberAfScenesClusterRemoveSceneCallback(uint16_t groupId, uint8_t sceneId);
2060
2061 /**
2062  * @brief Scenes Cluster StoreScene Command callback
2063  * @param groupId
2064  * @param sceneId
2065  */
2066
2067 bool emberAfScenesClusterStoreSceneCallback(uint16_t groupId, uint8_t sceneId);
2068
2069 /**
2070  * @brief Scenes Cluster ViewScene Command callback
2071  * @param groupId
2072  * @param sceneId
2073  */
2074
2075 bool emberAfScenesClusterViewSceneCallback(uint16_t groupId, uint8_t sceneId);
2076
2077 //
2078 // Non-Cluster Related Callbacks
2079 //
2080
2081 /** @brief Add To Current App Tasks
2082  *
2083  * This function is only useful to sleepy end devices.  This function will note
2084  * the passed item as part of a set of tasks the application has outstanding
2085  * (e.g. message sent requiring APS acknwoledgement).  This will affect how the
2086  * application behaves with regard to sleeping and polling.  Until the
2087  * outstanding task is completed, the device may poll more frequently and sleep
2088  * less often.
2089  *
2090  * @param tasks   Ver.: always
2091  */
2092 void emberAfAddToCurrentAppTasksCallback(EmberAfApplicationTask tasks);
2093
2094 /** @brief Remove From Current App Tasks
2095  *
2096  * This function is only useful to sleepy end devices.  This function will
2097  * remove the passed item from the set of tasks the application has outstanding
2098  * (e.g. message sent requiring APS acknwoledgement).  This will affect how the
2099  * application behaves with regard to sleeping and polling.  Removing the item
2100  * from the list of outstanding tasks may allow the device to sleep longer and
2101  * poll less frequently.  If there are other outstanding tasks the system may
2102  * still have to stay away and poll more often.
2103  *
2104  * @param tasks   Ver.: always
2105  */
2106 void emberAfRemoveFromCurrentAppTasksCallback(EmberAfApplicationTask tasks);
2107
2108 /** @brief Allow Network Write Attribute
2109  *
2110  * This function is called by the application framework before it writes an
2111  * attribute in response to a write attribute request from an external device.
2112  * The value passed into this callback is the value to which the attribute is to
2113  * be set by the framework.
2114         Example:        In mirroring simple metering data
2115  * on an Energy Services Interface (ESI) (formerly called Energy Service Portal
2116  * (ESP) in SE 1.0).), a mirrored simple meter needs to write read-only
2117  * attributes on its mirror. The-meter-mirror sample application, located in
2118  * app/framework/sample-apps, uses this callback to allow the mirrored device to
2119  * write simple metering attributes on the mirror regardless of the fact that
2120  * most simple metering attributes are defined as read-only by the ZigBee
2121  * specification.
2122         Note:   The ZCL specification does not (as of this
2123  * writing) specify any permission-level security for writing writeable
2124  * attributes. As far as the ZCL specification is concerned, if an attribute is
2125  * writeable, any device that has a link key for the device should be able to
2126  * write that attribute. Furthermore if an attribute is read only, it should not
2127  * be written over the air. Thus, if you implement permissions for writing
2128  * attributes as a feature, you MAY be operating outside the specification. This
2129  * is unlikely to be a problem for writing read-only attributes, but it may be a
2130  * problem for attributes that are writeable according to the specification but
2131  * restricted by the application implementing this callback.
2132  *
2133  * @param endpoint   Ver.: always
2134  * @param clusterId   Ver.: always
2135  * @param attributeId   Ver.: always
2136  * @param mask   Ver.: always
2137  * @param manufacturerCode   Ver.: always
2138  * @param value   Ver.: always
2139  * @param type   Ver.: always
2140  */
2141 EmberAfAttributeWritePermission emberAfAllowNetworkWriteAttributeCallback(chip::EndpointId endpoint, chip::ClusterId clusterId,
2142                                                                           chip::AttributeId attributeId, uint8_t mask,
2143                                                                           uint16_t manufacturerCode, uint8_t * value, uint8_t type);
2144
2145 /** @brief Attribute Read Access
2146  *
2147  * This function is called whenever the Application Framework needs to check
2148  * access permission for an attribute read.
2149  *
2150  * @param endpoint   Ver.: always
2151  * @param clusterId   Ver.: always
2152  * @param manufacturerCode   Ver.: always
2153  * @param attributeId   Ver.: always
2154  */
2155 bool emberAfAttributeReadAccessCallback(chip::EndpointId endpoint, chip::ClusterId clusterId, uint16_t manufacturerCode,
2156                                         chip::AttributeId attributeId);
2157
2158 /** @brief Attribute Write Access
2159  *
2160  * This function is called whenever the Application Framework needs to check
2161  * access permission for an attribute write.
2162  *
2163  * @param endpoint   Ver.: always
2164  * @param clusterId   Ver.: always
2165  * @param manufacturerCode   Ver.: always
2166  * @param attributeId   Ver.: always
2167  */
2168 bool emberAfAttributeWriteAccessCallback(chip::EndpointId endpoint, chip::ClusterId clusterId, uint16_t manufacturerCode,
2169                                          chip::AttributeId attributeId);
2170
2171 /** @brief Default Response
2172  *
2173  * This function is called by the application framework when a Default Response
2174  * command is received from an external device.  The application should return
2175  * true if the message was processed or false if it was not.
2176  *
2177  * @param clusterId The cluster identifier of this response.  Ver.: always
2178  * @param commandId The command identifier to which this is a response.  Ver.:
2179  * always
2180  * @param status Specifies either SUCCESS or the nature of the error that was
2181  * detected in the received command.  Ver.: always
2182  */
2183 bool emberAfDefaultResponseCallback(chip::ClusterId clusterId, chip::CommandId commandId, EmberAfStatus status);
2184
2185 /** @brief Configure Reporting Response
2186  *
2187  * This function is called by the application framework when a Configure
2188  * Reporting Response command is received from an external device.  The
2189  * application should return true if the message was processed or false if it
2190  * was not.
2191  *
2192  * @param clusterId The cluster identifier of this response.  Ver.: always
2193  * @param buffer Buffer containing the list of attribute status records.  Ver.:
2194  * always
2195  * @param bufLen The length in bytes of the list.  Ver.: always
2196  */
2197 bool emberAfConfigureReportingResponseCallback(chip::ClusterId clusterId, uint8_t * buffer, uint16_t bufLen);
2198
2199 /** @brief Read Reporting Configuration Response
2200  *
2201  * This function is called by the application framework when a Read Reporting
2202  * Configuration Response command is received from an external device.  The
2203  * application should return true if the message was processed or false if it
2204  * was not.
2205  *
2206  * @param clusterId The cluster identifier of this response.  Ver.: always
2207  * @param buffer Buffer containing the list of attribute reporting configuration
2208  * records.  Ver.: always
2209  * @param bufLen The length in bytes of the list.  Ver.: always
2210  */
2211 bool emberAfReadReportingConfigurationResponseCallback(chip::ClusterId clusterId, uint8_t * buffer, uint16_t bufLen);
2212
2213 /** @brief Discover Attributes Response
2214  *
2215  * This function is called by the application framework when a Discover
2216  * Attributes Response or Discover Attributes Extended Response command is
2217  * received from an external device.  The Discover Attributes Response command
2218  * contains a bool indicating if discovery is complete and a list of zero or
2219  * more attribute identifier/type records. The final argument indicates whether
2220  * the response is in the extended format or not.  The application should return
2221  * true if the message was processed or false if it was not.
2222  *
2223  * @param clusterId The cluster identifier of this response.  Ver.: always
2224  * @param discoveryComplete Indicates whether there are more attributes to be
2225  * discovered.  true if there are no more attributes to be discovered.  Ver.:
2226  * always
2227  * @param buffer Buffer containing the list of attribute identifier/type
2228  * records.  Ver.: always
2229  * @param bufLen The length in bytes of the list.  Ver.: always
2230  * @param extended Indicates whether the response is in the extended format or
2231  * not.  Ver.: always
2232  */
2233 bool emberAfDiscoverAttributesResponseCallback(chip::ClusterId clusterId, bool discoveryComplete, uint8_t * buffer, uint16_t bufLen,
2234                                                bool extended);
2235
2236 /** @brief Discover Commands Generated Response
2237  *
2238  * This function is called by the framework when Discover Commands Generated
2239  * Response is received.
2240  *
2241  * @param clusterId The cluster identifier of this response.  Ver.: always
2242  * @param manufacturerCode Manufacturer code  Ver.: always
2243  * @param discoveryComplete Indicates whether there are more commands to be
2244  * discovered.  Ver.: always
2245  * @param commandIds Buffer containing the list of command identifiers.  Ver.:
2246  * always
2247  * @param commandIdCount The length of bytes of the list, whish is the same as
2248  * the number of identifiers.  Ver.: always
2249  */
2250 bool emberAfDiscoverCommandsGeneratedResponseCallback(chip::ClusterId clusterId, uint16_t manufacturerCode, bool discoveryComplete,
2251                                                       chip::CommandId * commandIds, uint16_t commandIdCount);
2252
2253 /** @brief Discover Commands Received Response
2254  *
2255  * This function is called by the framework when Discover Commands Received
2256  * Response is received.
2257  *
2258  * @param clusterId The cluster identifier of this response.  Ver.: always
2259  * @param manufacturerCode Manufacturer code  Ver.: always
2260  * @param discoveryComplete Indicates whether there are more commands to be
2261  * discovered.  Ver.: always
2262  * @param commandIds Buffer containing the list of command identifiers.  Ver.:
2263  * always
2264  * @param commandIdCount The length of bytes of the list, whish is the same as
2265  * the number of identifiers.  Ver.: always
2266  */
2267 bool emberAfDiscoverCommandsReceivedResponseCallback(chip::ClusterId clusterId, uint16_t manufacturerCode, bool discoveryComplete,
2268                                                      chip::CommandId * commandIds, uint16_t commandIdCount);
2269
2270 /** @brief Pre Command Received
2271  *
2272  * This callback is the second in the Application Framework's message processing
2273  * chain. At this point in the processing of incoming over-the-air messages, the
2274  * application has determined that the incoming message is a ZCL command. It
2275  * parses enough of the message to populate an EmberAfClusterCommand struct. The
2276  * Application Framework defines this struct value in a local scope to the
2277  * command processing but also makes it available through a global pointer
2278  * called emberAfCurrentCommand, in app/framework/util/util.c. When command
2279  * processing is complete, this pointer is cleared.
2280  *
2281  * @param cmd   Ver.: always
2282  */
2283 bool emberAfPreCommandReceivedCallback(EmberAfClusterCommand * cmd);
2284
2285 /** @brief Pre Message Send
2286  *
2287  * This function is called by the framework when it is about to pass a message
2288  * to the stack primitives for sending.   This message may or may not be ZCL,
2289  * ZDO, or some other protocol.  This is called prior to
2290         any ZigBee
2291  * fragmentation that may be done.  If the function returns true it is assumed
2292  * the callback has consumed and processed the message.  The callback must also
2293  * set the EmberStatus status code to be passed back to the caller.  The
2294  * framework will do no further processing on the message.
2295         If the
2296  * function returns false then it is assumed that the callback has not processed
2297  * the mesasge and the framework will continue to process accordingly.
2298  *
2299  * @param messageStruct The structure containing the parameters of the APS
2300  * message to be sent.  Ver.: always
2301  * @param status A pointer to the status code value that will be returned to the
2302  * caller.  Ver.: always
2303  */
2304 bool emberAfPreMessageSendCallback(EmberAfMessageStruct * messageStruct, EmberStatus * status);
2305
2306 /** @brief Message Sent
2307  *
2308  * This function is called by the application framework from the message sent
2309  * handler, when it is informed by the stack regarding the message sent status.
2310  * All of the values passed to the emberMessageSentHandler are passed on to this
2311  * callback. This provides an opportunity for the application to verify that its
2312  * message has been sent successfully and take the appropriate action. This
2313  * callback should return a bool value of true or false. A value of true
2314  * indicates that the message sent notification has been handled and should not
2315  * be handled by the application framework.
2316  *
2317  * @param type   Ver.: always
2318  * @param indexOrDestination   Ver.: always
2319  * @param apsFrame   Ver.: always
2320  * @param msgLen   Ver.: always
2321  * @param message   Ver.: always
2322  * @param status   Ver.: always
2323  */
2324 bool emberAfMessageSentCallback(EmberOutgoingMessageType type, uint64_t indexOrDestination, EmberApsFrame * apsFrame,
2325                                 uint16_t msgLen, uint8_t * message, EmberStatus status);
2326
2327 /** @brief Pre Attribute Change
2328  *
2329  * This function is called by the application framework before it changes an
2330  * attribute value.  The value passed into this callback is the value to which
2331  * the attribute is to be set by the framework.  The application should return
2332  * ::EMBER_ZCL_STATUS_SUCCESS to permit the change or any other ::EmberAfStatus
2333  * to reject it.
2334  *
2335  * @param endpoint   Ver.: always
2336  * @param clusterId   Ver.: always
2337  * @param attributeId   Ver.: always
2338  * @param mask   Ver.: always
2339  * @param manufacturerCode   Ver.: always
2340  * @param type   Ver.: always
2341  * @param size   Ver.: always
2342  * @param value   Ver.: always
2343  */
2344 EmberAfStatus emberAfPreAttributeChangeCallback(chip::EndpointId endpoint, chip::ClusterId clusterId, chip::AttributeId attributeId,
2345                                                 uint8_t mask, uint16_t manufacturerCode, uint8_t type, uint8_t size,
2346                                                 uint8_t * value);
2347
2348 /** @brief Post Attribute Change
2349  *
2350  * This function is called by the application framework after it changes an
2351  * attribute value. The value passed into this callback is the value to which
2352  * the attribute was set by the framework.
2353  *
2354  * @param endpoint   Ver.: always
2355  * @param clusterId   Ver.: always
2356  * @param attributeId   Ver.: always
2357  * @param mask   Ver.: always
2358  * @param manufacturerCode   Ver.: always
2359  * @param type   Ver.: always
2360  * @param size   Ver.: always
2361  * @param value   Ver.: always
2362  */
2363 void emberAfPostAttributeChangeCallback(chip::EndpointId endpoint, chip::ClusterId clusterId, chip::AttributeId attributeId,
2364                                         uint8_t mask, uint16_t manufacturerCode, uint8_t type, uint8_t size, uint8_t * value);
2365
2366 /** @brief Read Attributes Response
2367  *
2368  * This function is called by the application framework when a Read Attributes
2369  * Response command is received from an external device.  The application should
2370  * return true if the message was processed or false if it was not.
2371  *
2372  * @param clusterId The cluster identifier of this response.  Ver.: always
2373  * @param buffer Buffer containing the list of read attribute status records.
2374  * Ver.: always
2375  * @param bufLen The length in bytes of the list.  Ver.: always
2376  */
2377 bool emberAfReadAttributesResponseCallback(chip::ClusterId clusterId, uint8_t * buffer, uint16_t bufLen);
2378
2379 /** @brief External Attribute Read
2380  *
2381  * Like emberAfExternalAttributeWriteCallback above, this function is called
2382  * when the framework needs to read an attribute that is not stored within the
2383  * Application Framework's data structures.
2384         All of the important
2385  * information about the attribute itself is passed as a pointer to an
2386  * EmberAfAttributeMetadata struct, which is stored within the application and
2387  * used to manage the attribute. A complete description of the
2388  * EmberAfAttributeMetadata struct is provided in
2389  * app/framework/include/af-types.h
2390         This function assumes that the
2391  * application is able to read the attribute, write it into the passed buffer,
2392  * and return immediately. Any attributes that require a state machine for
2393  * reading and writing are not really candidates for externalization at the
2394  * present time. The Application Framework does not currently include a state
2395  * machine for reading or writing attributes that must take place across a
2396  * series of application ticks. Attributes that cannot be read in a timely
2397  * manner should be stored within the Application Framework and updated
2398  * occasionally by the application code from within the
2399  * emberAfMainTickCallback.
2400         If the application was successfully able to
2401  * read the attribute and write it into the passed buffer, it should return a
2402  * value of EMBER_ZCL_STATUS_SUCCESS. Ensure that the size of the externally
2403  * managed attribute value is smaller than what the buffer can hold. In the case
2404  * of a buffer overflow throw an appropriate error such as
2405  * EMBER_ZCL_STATUS_INSUFFICIENT_SPACE. Any other return value indicates the
2406  * application was not able to read the attribute.
2407  *
2408  * @param endpoint   Ver.: always
2409  * @param clusterId   Ver.: always
2410  * @param attributeMetadata   Ver.: always
2411  * @param manufacturerCode   Ver.: always
2412  * @param buffer   Ver.: always
2413  * @param maxReadLength   Ver.: always
2414  */
2415 EmberAfStatus emberAfExternalAttributeReadCallback(chip::EndpointId endpoint, chip::ClusterId clusterId,
2416                                                    EmberAfAttributeMetadata * attributeMetadata, uint16_t manufacturerCode,
2417                                                    uint8_t * buffer, uint16_t maxReadLength);
2418
2419 /** @brief Write Attributes Response
2420  *
2421  * This function is called by the application framework when a Write Attributes
2422  * Response command is received from an external device.  The application should
2423  * return true if the message was processed or false if it was not.
2424  *
2425  * @param clusterId The cluster identifier of this response.  Ver.: always
2426  * @param buffer Buffer containing the list of write attribute status records.
2427  * Ver.: always
2428  * @param bufLen The length in bytes of the list.  Ver.: always
2429  */
2430 bool emberAfWriteAttributesResponseCallback(chip::ClusterId clusterId, uint8_t * buffer, uint16_t bufLen);
2431
2432 /** @brief External Attribute Write
2433  *
2434  * This function is called whenever the Application Framework needs to write an
2435  * attribute which is not stored within the data structures of the Application
2436  * Framework itself. One of the new features in Version 2 is the ability to
2437  * store attributes outside the Framework. This is particularly useful for
2438  * attributes that do not need to be stored because they can be read off the
2439  * hardware when they are needed, or are stored in some central location used by
2440  * many modules within the system. In this case, you can indicate that the
2441  * attribute is stored externally. When the framework needs to write an external
2442  * attribute, it makes a call to this callback.
2443         This callback is very
2444  * useful for host micros which need to store attributes in persistent memory.
2445  * Because each host micro (used with an Ember NCP) has its own type of
2446  * persistent memory storage, the Application Framework does not include the
2447  * ability to mark attributes as stored in flash the way that it does for Ember
2448  * SoCs like the EM35x. On a host micro, any attributes that need to be stored
2449  * in persistent memory should be marked as external and accessed through the
2450  * external read and write callbacks. Any host code associated with the
2451  * persistent storage should be implemented within this callback.
2452         All of
2453  * the important information about the attribute itself is passed as a pointer
2454  * to an EmberAfAttributeMetadata struct, which is stored within the application
2455  * and used to manage the attribute. A complete description of the
2456  * EmberAfAttributeMetadata struct is provided in
2457  * app/framework/include/af-types.h.
2458         This function assumes that the
2459  * application is able to write the attribute and return immediately. Any
2460  * attributes that require a state machine for reading and writing are not
2461  * candidates for externalization at the present time. The Application Framework
2462  * does not currently include a state machine for reading or writing attributes
2463  * that must take place across a series of application ticks. Attributes that
2464  * cannot be written immediately should be stored within the Application
2465  * Framework and updated occasionally by the application code from within the
2466  * emberAfMainTickCallback.
2467         If the application was successfully able to
2468  * write the attribute, it returns a value of EMBER_ZCL_STATUS_SUCCESS. Any
2469  * other return value indicates the application was not able to write the
2470  * attribute.
2471  *
2472  * @param endpoint   Ver.: always
2473  * @param clusterId   Ver.: always
2474  * @param attributeMetadata   Ver.: always
2475  * @param manufacturerCode   Ver.: always
2476  * @param buffer   Ver.: always
2477  */
2478 EmberAfStatus emberAfExternalAttributeWriteCallback(chip::EndpointId endpoint, chip::ClusterId clusterId,
2479                                                     EmberAfAttributeMetadata * attributeMetadata, uint16_t manufacturerCode,
2480                                                     uint8_t * buffer);
2481
2482 /** @brief Report Attributes
2483  *
2484  * This function is called by the application framework when a Report Attributes
2485  * command is received from an external device.  The application should return
2486  * true if the message was processed or false if it was not.
2487  *
2488  * @param clusterId The cluster identifier of this command.  Ver.: always
2489  * @param buffer Buffer containing the list of attribute report records.  Ver.:
2490  * always
2491  * @param bufLen The length in bytes of the list.  Ver.: always
2492  */
2493 bool emberAfReportAttributesCallback(chip::ClusterId clusterId, uint8_t * buffer, uint16_t bufLen);
2494
2495 /** @brief Get Current Time
2496  *
2497  * This callback is called when device attempts to get current time from the
2498  * hardware. If this device has means to retrieve exact time, then this method
2499  * should implement it. If the callback can't provide the exact time it should
2500  * return 0 to indicate failure. Default action is to return 0, which indicates
2501  * that device does not have access to real time.
2502  *
2503  */
2504 uint32_t emberAfGetCurrentTimeCallback();
2505
2506 /** @brief Get Endpoint Info
2507  *
2508  * This function is a callback to an application implemented endpoint that
2509  * operates outside the normal application framework.  When the framework wishes
2510  * to perform operations with that endpoint it uses this callback to retrieve
2511  * the endpoint's information.  If the endpoint exists and the application can
2512  * provide data then true shall be returned.  Otherwise the callback must return
2513  * false.
2514  *
2515  * @param endpoint The endpoint to retrieve data for.  Ver.: always
2516  * @param returnNetworkIndex The index corresponding to the ZigBee network the
2517  * endpoint belongs to.  If not using a multi-network device, 0 must be
2518  * returned.  Otherwise on a multi-network device the stack will switch to this
2519  * network before sending the message.  Ver.: always
2520  * @param returnEndpointInfo A pointer to a data struct that will be written
2521  * with information about the endpoint.  Ver.: always
2522  */
2523 bool emberAfGetEndpointInfoCallback(chip::EndpointId endpoint, uint8_t * returnNetworkIndex,
2524                                     EmberAfEndpointInfoStruct * returnEndpointInfo);
2525
2526 /** @brief Get Source Route Overhead
2527  *
2528  * This function is called by the framework to determine the overhead required
2529  * in the network frame for source routing to a particular destination.
2530  *
2531  * @param destination The node id of the destination  Ver.: always
2532  */
2533 uint8_t emberAfGetSourceRouteOverheadCallback(chip::NodeId destination);
2534
2535 /** @brief Registration Abort
2536  *
2537  * This callback is called when the device should abort the registration
2538  * process.
2539  *
2540  */
2541 void emberAfRegistrationAbortCallback();
2542
2543 /** @brief Interpan Send Message
2544  *
2545  * This function will send a raw MAC message with interpan frame format using
2546  * the passed parameters.
2547  *
2548  * @param header Interpan header info  Ver.: always
2549  * @param messageLength The length of the message received or to send  Ver.:
2550  * always
2551  * @param message The message data received or to send.  Ver.: always
2552  */
2553 EmberStatus emberAfInterpanSendMessageCallback(EmberAfInterpanHeader * header, uint16_t messageLength, uint8_t * message);
2554
2555 /** @brief Start Move
2556  *
2557  * This function is called to initiate the process for a device to move (rejoin)
2558  * to a new parent.
2559  *
2560  */
2561 bool emberAfStartMoveCallback();