Line data    Source code

       1             : /*
       2             :  *
       3             :  *    Copyright (c) 2021 Project CHIP Authors
       4             :  *    All rights reserved.
       5             :  *
       6             :  *    Licensed under the Apache License, Version 2.0 (the "License");
       7             :  *    you may not use this file except in compliance with the License.
       8             :  *    You may obtain a copy of the License at
       9             :  *
      10             :  *        http://www.apache.org/licenses/LICENSE-2.0
      11             :  *
      12             :  *    Unless required by applicable law or agreed to in writing, software
      13             :  *    distributed under the License is distributed on an "AS IS" BASIS,
      14             :  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
      15             :  *    See the License for the specific language governing permissions and
      16             :  *    limitations under the License.
      17             :  */
      18             : 
      19             : #pragma once
      20             : 
      21             : #include "protocols/interaction_model/Constants.h"
      22             : #include <app/CommandSender.h>
      23             : #include <app/data-model/Decode.h>
      24             : #include <app/data-model/NullObject.h>
      25             : #include <functional>
      26             : 
      27             : namespace chip {
      28             : namespace Controller {
      29             : 
      30             : /*
      31             :  * This provides an adapter class that implements CommandSender::Callback and provides two additional features:
      32             :  *  1. The ability to pass in std::function closures to permit more flexible programming scenarios than are provided by the strict
      33             :  *     delegate interface stipulated by CommandSender::Callback
      34             :  *
      35             :  *  2. Automatic decoding of command response data provided in the TLVReader by the CommandSender callback into a decoded cluster
      36             :  * object.
      37             :  */
      38             : template <typename CommandResponseObjectT>
      39             : class TypedCommandCallback final : public app::CommandSender::Callback
      40             : {
      41             : public:
      42             :     using OnSuccessCallbackType =
      43             :         std::function<void(const app::ConcreteCommandPath &, const app::StatusIB &, const CommandResponseObjectT &)>;
      44             :     using OnErrorCallbackType = std::function<void(CHIP_ERROR aError)>;
      45             :     using OnDoneCallbackType  = std::function<void(app::CommandSender * commandSender)>;
      46             : 
      47             :     /*
      48             :      * Constructor that takes in success, failure and onDone callbacks.
      49             :      *
      50             :      * The latter can be provided later through the SetOnDoneCallback below in cases where the
      51             :      * TypedCommandCallback object needs to be created first before it can be passed in as a closure
      52             :      * into a hypothetical OnDoneCallback function.
      53             :      */
      54           0 :     TypedCommandCallback(OnSuccessCallbackType aOnSuccess, OnErrorCallbackType aOnError, OnDoneCallbackType aOnDone = {}) :
      55           0 :         mOnSuccess(aOnSuccess), mOnError(aOnError), mOnDone(aOnDone)
      56           0 :     {}
      57             : 
      58           0 :     void SetOnDoneCallback(OnDoneCallbackType callback) { mOnDone = callback; }
      59             : 
      60             : private:
      61             :     void OnResponse(app::CommandSender * apCommandSender, const app::ConcreteCommandPath & aCommandPath,
      62             :                     const app::StatusIB & aStatus, TLV::TLVReader * aReader) override;
      63             : 
      64           0 :     void OnError(const app::CommandSender * apCommandSender, CHIP_ERROR aError) override
      65             :     {
      66           0 :         if (mCalledCallback)
      67             :         {
      68           0 :             return;
      69             :         }
      70           0 :         mCalledCallback = true;
      71             : 
      72           0 :         mOnError(aError);
      73             :     }
      74             : 
      75           0 :     void OnDone(app::CommandSender * apCommandSender) override
      76             :     {
      77           0 :         if (!mCalledCallback)
      78             :         {
      79             :             // This can happen if the server sends a response with an empty
      80             :             // InvokeResponses list.  Since we are not sending wildcard command
      81             :             // paths, that's not a valid response and we should treat it as an
      82             :             // error.  Use the error we would have gotten if we in fact expected
      83             :             // a nonempty list.
      84           0 :             OnError(apCommandSender, CHIP_END_OF_TLV);
      85             :         }
      86             : 
      87           0 :         mOnDone(apCommandSender);
      88           0 :     }
      89             : 
      90             :     OnSuccessCallbackType mOnSuccess;
      91             :     OnErrorCallbackType mOnError;
      92             :     OnDoneCallbackType mOnDone;
      93             : 
      94             :     bool mCalledCallback = false;
      95             : };
      96             : 
      97             : /*
      98             :  * Decodes the data provided by the TLVReader into the templated cluster object that denotes the command response.
      99             :  *
     100             :  * This function specifically decodes command responses that have actual data payloads.
     101             :  */
     102             : template <typename CommandResponseObjectT>
     103           0 : void TypedCommandCallback<CommandResponseObjectT>::OnResponse(app::CommandSender * apCommandSender,
     104             :                                                               const app::ConcreteCommandPath & aCommandPath,
     105             :                                                               const app::StatusIB & aStatus, TLV::TLVReader * aReader)
     106             : {
     107           0 :     if (mCalledCallback)
     108             :     {
     109           0 :         return;
     110             :     }
     111           0 :     mCalledCallback = true;
     112             : 
     113           0 :     CommandResponseObjectT response;
     114           0 :     CHIP_ERROR err = CHIP_NO_ERROR;
     115             : 
     116             :     //
     117             :     // We're expecting response data in this variant of OnResponse. Consequently, aReader should always be
     118             :     // non-null. If it is, it means we received a success status code instead, which is not what was expected.
     119             :     //
     120           0 :     VerifyOrExit(aReader != nullptr, err = CHIP_ERROR_SCHEMA_MISMATCH);
     121             : 
     122             :     //
     123             :     // Validate that the data response we received matches what we expect in terms of its cluster and command IDs.
     124             :     //
     125           0 :     VerifyOrExit(aCommandPath.mClusterId == CommandResponseObjectT::GetClusterId() &&
     126             :                      aCommandPath.mCommandId == CommandResponseObjectT::GetCommandId(),
     127             :                  err = CHIP_ERROR_SCHEMA_MISMATCH);
     128             : 
     129           0 :     err = app::DataModel::Decode(*aReader, response);
     130           0 :     SuccessOrExit(err);
     131             : 
     132           0 :     mOnSuccess(aCommandPath, aStatus, response);
     133             : 
     134           0 : exit:
     135           0 :     if (err != CHIP_NO_ERROR)
     136             :     {
     137           0 :         mOnError(err);
     138             :     }
     139           0 : }
     140             : 
     141             : /*
     142             :  * Decodes the data provided by the TLVReader into the templated cluster object that denotes the command response.
     143             :  *
     144             :  * This function specifically decodes command responses that do not have actual data payloads and where the passed in TLVReader
     145             :  * should be null.
     146             :  */
     147             : template <>
     148           0 : inline void TypedCommandCallback<app::DataModel::NullObjectType>::OnResponse(app::CommandSender * apCommandSender,
     149             :                                                                              const app::ConcreteCommandPath & aCommandPath,
     150             :                                                                              const app::StatusIB & aStatus,
     151             :                                                                              TLV::TLVReader * aReader)
     152             : {
     153           0 :     if (mCalledCallback)
     154             :     {
     155           0 :         return;
     156             :     }
     157           0 :     mCalledCallback = true;
     158             : 
     159             :     //
     160             :     // If we got a valid reader, it means we received response data that we were not expecting to receive.
     161             :     //
     162           0 :     if (aReader != nullptr)
     163             :     {
     164           0 :         mOnError(CHIP_ERROR_SCHEMA_MISMATCH);
     165           0 :         return;
     166             :     }
     167             : 
     168             :     app::DataModel::NullObjectType nullResp;
     169           0 :     mOnSuccess(aCommandPath, aStatus, nullResp);
     170             : }
     171             : 
     172             : } // namespace Controller
     173             : } // namespace chip