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