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