examples/tv-app/tv-common/gen/callback.h

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