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             // No commands are enabled for cluster Basic
  76             result = status(false, true, cmd->mfgSpecific);
  77             break;
  78         case ZCL_LEVEL_CONTROL_CLUSTER_ID:
  79             result = emberAfLevelControlClusterServerCommandParse(cmd);
  80             break;
  81         case ZCL_ON_OFF_CLUSTER_ID:
  82             result = emberAfOnOffClusterServerCommandParse(cmd);
  83             break;
  84         default:
  85             // Unrecognized cluster ID, error status will apply.
  86             break;
  87         }
  88     }
  89     return result;
  90 }
  91
  92 // Cluster specific command parsing
  93
  94 EmberAfStatus emberAfLevelControlClusterServerCommandParse(EmberAfClusterCommand * cmd)
  95 {
  96     bool wasHandled = false;
  97
  98     if (!cmd->mfgSpecific)
  99     {
 100         switch (cmd->commandId)
 101         {
 102         case ZCL_MOVE_COMMAND_ID: {
 103             uint16_t payloadOffset = cmd->payloadStartIndex;
 104             uint8_t moveMode;
 105             uint8_t rate;
 106             uint8_t optionMask;
 107             uint8_t optionOverride;
 108
 109             if (cmd->bufLen < payloadOffset + 1)
 110             {
 111                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 112             }
 113             moveMode      = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 114             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
 115             if (cmd->bufLen < payloadOffset + 1)
 116             {
 117                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 118             }
 119             rate          = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 120             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
 121             if (cmd->bufLen < payloadOffset + 1)
 122             {
 123                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 124             }
 125             optionMask    = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 126             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
 127             if (cmd->bufLen < payloadOffset + 1)
 128             {
 129                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 130             }
 131             optionOverride = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 132
 133             wasHandled = emberAfLevelControlClusterMoveCallback(moveMode, rate, optionMask, optionOverride);
 134             break;
 135         }
 136         case ZCL_MOVE_TO_LEVEL_COMMAND_ID: {
 137             uint16_t payloadOffset = cmd->payloadStartIndex;
 138             uint8_t level;
 139             uint16_t transitionTime;
 140             uint8_t optionMask;
 141             uint8_t optionOverride;
 142
 143             if (cmd->bufLen < payloadOffset + 1)
 144             {
 145                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 146             }
 147             level         = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 148             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
 149             if (cmd->bufLen < payloadOffset + 2)
 150             {
 151                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 152             }
 153             transitionTime = emberAfGetInt16u(cmd->buffer, payloadOffset, cmd->bufLen);
 154             payloadOffset  = static_cast<uint16_t>(payloadOffset + 2);
 155             if (cmd->bufLen < payloadOffset + 1)
 156             {
 157                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 158             }
 159             optionMask    = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 160             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
 161             if (cmd->bufLen < payloadOffset + 1)
 162             {
 163                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 164             }
 165             optionOverride = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 166
 167             wasHandled = emberAfLevelControlClusterMoveToLevelCallback(level, transitionTime, optionMask, optionOverride);
 168             break;
 169         }
 170         case ZCL_MOVE_TO_LEVEL_WITH_ON_OFF_COMMAND_ID: {
 171             uint16_t payloadOffset = cmd->payloadStartIndex;
 172             uint8_t level;
 173             uint16_t transitionTime;
 174
 175             if (cmd->bufLen < payloadOffset + 1)
 176             {
 177                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 178             }
 179             level         = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 180             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
 181             if (cmd->bufLen < payloadOffset + 2)
 182             {
 183                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 184             }
 185             transitionTime = emberAfGetInt16u(cmd->buffer, payloadOffset, cmd->bufLen);
 186
 187             wasHandled = emberAfLevelControlClusterMoveToLevelWithOnOffCallback(level, transitionTime);
 188             break;
 189         }
 190         case ZCL_MOVE_WITH_ON_OFF_COMMAND_ID: {
 191             uint16_t payloadOffset = cmd->payloadStartIndex;
 192             uint8_t moveMode;
 193             uint8_t rate;
 194
 195             if (cmd->bufLen < payloadOffset + 1)
 196             {
 197                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 198             }
 199             moveMode      = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 200             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
 201             if (cmd->bufLen < payloadOffset + 1)
 202             {
 203                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 204             }
 205             rate = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 206
 207             wasHandled = emberAfLevelControlClusterMoveWithOnOffCallback(moveMode, rate);
 208             break;
 209         }
 210         case ZCL_STEP_COMMAND_ID: {
 211             uint16_t payloadOffset = cmd->payloadStartIndex;
 212             uint8_t stepMode;
 213             uint8_t stepSize;
 214             uint16_t transitionTime;
 215             uint8_t optionMask;
 216             uint8_t optionOverride;
 217
 218             if (cmd->bufLen < payloadOffset + 1)
 219             {
 220                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 221             }
 222             stepMode      = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 223             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
 224             if (cmd->bufLen < payloadOffset + 1)
 225             {
 226                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 227             }
 228             stepSize      = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 229             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
 230             if (cmd->bufLen < payloadOffset + 2)
 231             {
 232                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 233             }
 234             transitionTime = emberAfGetInt16u(cmd->buffer, payloadOffset, cmd->bufLen);
 235             payloadOffset  = static_cast<uint16_t>(payloadOffset + 2);
 236             if (cmd->bufLen < payloadOffset + 1)
 237             {
 238                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 239             }
 240             optionMask    = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 241             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
 242             if (cmd->bufLen < payloadOffset + 1)
 243             {
 244                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 245             }
 246             optionOverride = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 247
 248             wasHandled = emberAfLevelControlClusterStepCallback(stepMode, stepSize, transitionTime, optionMask, optionOverride);
 249             break;
 250         }
 251         case ZCL_STEP_WITH_ON_OFF_COMMAND_ID: {
 252             uint16_t payloadOffset = cmd->payloadStartIndex;
 253             uint8_t stepMode;
 254             uint8_t stepSize;
 255             uint16_t transitionTime;
 256
 257             if (cmd->bufLen < payloadOffset + 1)
 258             {
 259                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 260             }
 261             stepMode      = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 262             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
 263             if (cmd->bufLen < payloadOffset + 1)
 264             {
 265                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 266             }
 267             stepSize      = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 268             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
 269             if (cmd->bufLen < payloadOffset + 2)
 270             {
 271                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 272             }
 273             transitionTime = emberAfGetInt16u(cmd->buffer, payloadOffset, cmd->bufLen);
 274
 275             wasHandled = emberAfLevelControlClusterStepWithOnOffCallback(stepMode, stepSize, transitionTime);
 276             break;
 277         }
 278         case ZCL_STOP_COMMAND_ID: {
 279             uint16_t payloadOffset = cmd->payloadStartIndex;
 280             uint8_t optionMask;
 281             uint8_t optionOverride;
 282
 283             if (cmd->bufLen < payloadOffset + 1)
 284             {
 285                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 286             }
 287             optionMask    = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 288             payloadOffset = static_cast<uint16_t>(payloadOffset + 1);
 289             if (cmd->bufLen < payloadOffset + 1)
 290             {
 291                 return EMBER_ZCL_STATUS_MALFORMED_COMMAND;
 292             }
 293             optionOverride = emberAfGetInt8u(cmd->buffer, payloadOffset, cmd->bufLen);
 294
 295             wasHandled = emberAfLevelControlClusterStopCallback(optionMask, optionOverride);
 296             break;
 297         }
 298         case ZCL_STOP_WITH_ON_OFF_COMMAND_ID: {
 299             wasHandled = emberAfLevelControlClusterStopWithOnOffCallback();
 300             break;
 301         }
 302         default: {
 303             // Unrecognized command ID, error status will apply.
 304             break;
 305         }
 306         }
 307     }
 308     return status(wasHandled, true, cmd->mfgSpecific);
 309 }
 310 EmberAfStatus emberAfOnOffClusterServerCommandParse(EmberAfClusterCommand * cmd)
 311 {
 312     bool wasHandled = false;
 313
 314     if (!cmd->mfgSpecific)
 315     {
 316         switch (cmd->commandId)
 317         {
 318         case ZCL_OFF_COMMAND_ID: {
 319             wasHandled = emberAfOnOffClusterOffCallback();
 320             break;
 321         }
 322         case ZCL_ON_COMMAND_ID: {
 323             wasHandled = emberAfOnOffClusterOnCallback();
 324             break;
 325         }
 326         case ZCL_TOGGLE_COMMAND_ID: {
 327             wasHandled = emberAfOnOffClusterToggleCallback();
 328             break;
 329         }
 330         default: {
 331             // Unrecognized command ID, error status will apply.
 332             break;
 333         }
 334         }
 335     }
 336     return status(wasHandled, true, cmd->mfgSpecific);
 337 }