examples/bridge-app/bridge-common/gen/call-command-handler.cpp

   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 #include <stdint.h>
  21
  22 #include "af-structs.h"
  23 #include "call-command-handler.h"
  24 #include "callback.h"
  25 #include "cluster-id.h"
  26 #include "command-id.h"
  27 #include "util.h"
  28
  29 using namespace chip;
  30
  31 EmberAfStatus emberAfBasicClusterServerCommandParse(EmberAfClusterCommand * cmd);
  32 EmberAfStatus emberAfLevelControlClusterServerCommandParse(EmberAfClusterCommand * cmd);
  33 EmberAfStatus emberAfOnOffClusterServerCommandParse(EmberAfClusterCommand * cmd);
  34
  35 static EmberAfStatus status(bool wasHandled, bool clusterExists, bool mfgSpecific)
  36 {
  37     if (wasHandled)
  38     {
  39         return EMBER_ZCL_STATUS_SUCCESS;
  40     }
  41     else if (mfgSpecific)
  42     {
  43         return EMBER_ZCL_STATUS_UNSUP_MANUF_CLUSTER_COMMAND;
  44     }
  45     else if (clusterExists)
  46     {
  47         return EMBER_ZCL_STATUS_UNSUP_COMMAND;
  48     }
  49     else
  50     {
  51         return EMBER_ZCL_STATUS_UNSUPPORTED_CLUSTER;
  52     }
  53 }
  54
  55 // Main command parsing controller.
  56 EmberAfStatus emberAfClusterSpecificCommandParse(EmberAfClusterCommand * cmd)
  57 {
  58     EmberAfStatus result = status(false, false, cmd->mfgSpecific);
  59     if (cmd->direction == (uint8_t) ZCL_DIRECTION_SERVER_TO_CLIENT &&
  60         emberAfContainsClientWithMfgCode(cmd->apsFrame->destinationEndpoint, cmd->apsFrame->clusterId, cmd->mfgCode))
  61     {
  62         switch (cmd->apsFrame->clusterId)
  63         {
  64         default:
  65             // Unrecognized cluster ID, error status will apply.
  66             break;
  67         }
  68     }
  69     else if (cmd->direction == (uint8_t) ZCL_DIRECTION_CLIENT_TO_SERVER &&
  70              emberAfContainsServerWithMfgCode(cmd->apsFrame->destinationEndpoint, cmd->apsFrame->clusterId, cmd->mfgCode))
  71     {
  72         switch (cmd->apsFrame->clusterId)
  73         {
  74         case ZCL_BASIC_CLUSTER_ID:
  75             result = emberAfBasicClusterServerCommandParse(cmd);
  76             break;
  77         case ZCL_LEVEL_CONTROL_CLUSTER_ID:
  78             result = emberAfLevelControlClusterServerCommandParse(cmd);
  79             break;
  80         case ZCL_ON_OFF_CLUSTER_ID:
  81             result = emberAfOnOffClusterServerCommandParse(cmd);
  82             break;
  83         default:
  84             // Unrecognized cluster ID, error status will apply.
  85             break;
  86         }
  87     }
  88     return result;
  89 }
  90
  91 // Cluster specific command parsing
  92
  93 EmberAfStatus emberAfBasicClusterServerCommandParse(EmberAfClusterCommand * cmd)
  94 {
  95     bool wasHandled = false;
  96
  97     if (!cmd->mfgSpecific)
  98     {
  99         switch (cmd->commandId)
 100         {
 101         case ZCL_RESET_TO_FACTORY_DEFAULTS_COMMAND_ID: {
 102             wasHandled = emberAfBasicClusterResetToFactoryDefaultsCallback();
 103             break;
 104         }
 105         default: {
 106             // Unrecognized command ID, error status will apply.
 107             break;
 108         }
 109         }
 110     }
 111     return status(wasHandled, true, cmd->mfgSpecific);
 112 }
 113 EmberAfStatus emberAfLevelControlClusterServerCommandParse(EmberAfClusterCommand * cmd)
 114 {
 115     bool wasHandled = false;
 116
 117     if (!cmd->mfgSpecific)
 118     {
 119         switch (cmd->commandId)
 120         {
 121         case ZCL_MOVE_COMMAND_ID: {
 122             uint16_t payloadOffset = cmd->payloadStartIndex;
 123             uint8_t moveMode;
 124             uint8_t rate;
 125             uint8_t optionMask;
 126             uint8_t optionOverride;
 127
 128             if (cmd->bufLen < payloadOffset + 1)
 129             {
 130                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 131             }
 132             moveMode      = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 133             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
 134             if (cmd->bufLen < payloadOffset + 1)
 135             {
 136                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 137             }
 138             rate          = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 139             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
 140             if (cmd->bufLen < payloadOffset + 1)
 141             {
 142                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 143             }
 144             optionMask    = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 145             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
 146             if (cmd->bufLen < payloadOffset + 1)
 147             {
 148                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 149             }
 150             optionOverride = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 151
 152             wasHandled = emberAfLevelControlClusterMoveCallback(moveMode, rate, optionMask, optionOverride);
 153             break;
 154         }
 155         case ZCL_MOVE_TO_LEVEL_COMMAND_ID: {
 156             uint16_t payloadOffset = cmd->payloadStartIndex;
 157             uint8_t level;
 158             uint16_t transitionTime;
 159             uint8_t optionMask;
 160             uint8_t optionOverride;
 161
 162             if (cmd->bufLen < payloadOffset + 1)
 163             {
 164                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 165             }
 166             level         = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 167             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
 168             if (cmd->bufLen < payloadOffset + 2)
 169             {
 170                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 171             }
 172             transitionTime = emberAfGetInt16u(cmd->buffer, payloadOffset, cmd->bufLen);
 173             payloadOffset  = static_cast<uint16_t>(payloadOffset + 2);
 174             if (cmd->bufLen < payloadOffset + 1)
 175             {
 176                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 177             }
 178             optionMask    = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 179             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
 180             if (cmd->bufLen < payloadOffset + 1)
 181             {
 182                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 183             }
 184             optionOverride = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 185
 186             wasHandled = emberAfLevelControlClusterMoveToLevelCallback(level, transitionTime, optionMask, optionOverride);
 187             break;
 188         }
 189         case ZCL_MOVE_TO_LEVEL_WITH_ON_OFF_COMMAND_ID: {
 190             uint16_t payloadOffset = cmd->payloadStartIndex;
 191             uint8_t level;
 192             uint16_t transitionTime;
 193
 194             if (cmd->bufLen < payloadOffset + 1)
 195             {
 196                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 197             }
 198             level         = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 199             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
 200             if (cmd->bufLen < payloadOffset + 2)
 201             {
 202                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 203             }
 204             transitionTime = emberAfGetInt16u(cmd->buffer, payloadOffset, cmd->bufLen);
 205
 206             wasHandled = emberAfLevelControlClusterMoveToLevelWithOnOffCallback(level, transitionTime);
 207             break;
 208         }
 209         case ZCL_MOVE_WITH_ON_OFF_COMMAND_ID: {
 210             uint16_t payloadOffset = cmd->payloadStartIndex;
 211             uint8_t moveMode;
 212             uint8_t rate;
 213
 214             if (cmd->bufLen < payloadOffset + 1)
 215             {
 216                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 217             }
 218             moveMode      = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 219             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
 220             if (cmd->bufLen < payloadOffset + 1)
 221             {
 222                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 223             }
 224             rate = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 225
 226             wasHandled = emberAfLevelControlClusterMoveWithOnOffCallback(moveMode, rate);
 227             break;
 228         }
 229         case ZCL_STEP_COMMAND_ID: {
 230             uint16_t payloadOffset = cmd->payloadStartIndex;
 231             uint8_t stepMode;
 232             uint8_t stepSize;
 233             uint16_t transitionTime;
 234             uint8_t optionMask;
 235             uint8_t optionOverride;
 236
 237             if (cmd->bufLen < payloadOffset + 1)
 238             {
 239                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 240             }
 241             stepMode      = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 242             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
 243             if (cmd->bufLen < payloadOffset + 1)
 244             {
 245                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 246             }
 247             stepSize      = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 248             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
 249             if (cmd->bufLen < payloadOffset + 2)
 250             {
 251                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 252             }
 253             transitionTime = emberAfGetInt16u(cmd->buffer, payloadOffset, cmd->bufLen);
 254             payloadOffset  = static_cast<uint16_t>(payloadOffset + 2);
 255             if (cmd->bufLen < payloadOffset + 1)
 256             {
 257                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 258             }
 259             optionMask    = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 260             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
 261             if (cmd->bufLen < payloadOffset + 1)
 262             {
 263                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 264             }
 265             optionOverride = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 266
 267             wasHandled = emberAfLevelControlClusterStepCallback(stepMode, stepSize, transitionTime, optionMask, optionOverride);
 268             break;
 269         }
 270         case ZCL_STEP_WITH_ON_OFF_COMMAND_ID: {
 271             uint16_t payloadOffset = cmd->payloadStartIndex;
 272             uint8_t stepMode;
 273             uint8_t stepSize;
 274             uint16_t transitionTime;
 275
 276             if (cmd->bufLen < payloadOffset + 1)
 277             {
 278                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 279             }
 280             stepMode      = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 281             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
 282             if (cmd->bufLen < payloadOffset + 1)
 283             {
 284                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 285             }
 286             stepSize      = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 287             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
 288             if (cmd->bufLen < payloadOffset + 2)
 289             {
 290                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 291             }
 292             transitionTime = emberAfGetInt16u(cmd->buffer, payloadOffset, cmd->bufLen);
 293
 294             wasHandled = emberAfLevelControlClusterStepWithOnOffCallback(stepMode, stepSize, transitionTime);
 295             break;
 296         }
 297         case ZCL_STOP_COMMAND_ID: {
 298             uint16_t payloadOffset = cmd->payloadStartIndex;
 299             uint8_t optionMask;
 300             uint8_t optionOverride;
 301
 302             if (cmd->bufLen < payloadOffset + 1)
 303             {
 304                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 305             }
 306             optionMask    = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 307             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
 308             if (cmd->bufLen < payloadOffset + 1)
 309             {
 310                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 311             }
 312             optionOverride = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 313
 314             wasHandled = emberAfLevelControlClusterStopCallback(optionMask, optionOverride);
 315             break;
 316         }
 317         case ZCL_STOP_WITH_ON_OFF_COMMAND_ID: {
 318             wasHandled = emberAfLevelControlClusterStopWithOnOffCallback();
 319             break;
 320         }
 321         default: {
 322             // Unrecognized command ID, error status will apply.
 323             break;
 324         }
 325         }
 326     }
 327     return status(wasHandled, true, cmd->mfgSpecific);
 328 }
 329 EmberAfStatus emberAfOnOffClusterServerCommandParse(EmberAfClusterCommand * cmd)
 330 {
 331     bool wasHandled = false;
 332
 333     if (!cmd->mfgSpecific)
 334     {
 335         switch (cmd->commandId)
 336         {
 337         case ZCL_OFF_COMMAND_ID: {
 338             wasHandled = emberAfOnOffClusterOffCallback();
 339             break;
 340         }
 341         case ZCL_ON_COMMAND_ID: {
 342             wasHandled = emberAfOnOffClusterOnCallback();
 343             break;
 344         }
 345         case ZCL_TOGGLE_COMMAND_ID: {
 346             wasHandled = emberAfOnOffClusterToggleCallback();
 347             break;
 348         }
 349         default: {
 350             // Unrecognized command ID, error status will apply.
 351             break;
 352         }
 353         }
 354     }
 355     return status(wasHandled, true, cmd->mfgSpecific);
 356 }