Line data    Source code

       1              : /*
       2              :  *    Copyright (c) 2022 Project CHIP Authors
       3              :  *    All rights reserved.
       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              : #pragma once
      19              : 
      20              : #include <lib/core/CHIPError.h>
      21              : #include <lib/support/IntrusiveList.h>
      22              : #include <lib/support/Span.h>
      23              : 
      24              : #include <cstddef>
      25              : #include <cstdint>
      26              : 
      27              : namespace chip {
      28              : 
      29              : class TestEventTriggerHandler : public IntrusiveListNodeBase<IntrusiveMode::AutoUnlink>
      30              : {
      31              : public:
      32           10 :     virtual ~TestEventTriggerHandler() = default;
      33              : 
      34              :     /**
      35              :      * Handles the test event trigger based on `eventTrigger` provided.
      36              :      *
      37              :      * @param[in] eventTrigger Event trigger to handle.
      38              :      *
      39              :      * @return CHIP_NO_ERROR on success or another CHIP_ERROR on failure
      40              :      */
      41              :     virtual CHIP_ERROR HandleEventTrigger(uint64_t eventTrigger) = 0;
      42              : 
      43            2 :     static constexpr uint64_t clearEndpointInEventTrigger(uint64_t eventTrigger)
      44              :     {
      45            2 :         constexpr uint64_t kEndpointMask = 0x0000FFFF00000000;
      46            2 :         return eventTrigger & ~kEndpointMask;
      47              :     }
      48              : };
      49              : 
      50              : class TestEventTriggerDelegate
      51              : {
      52              : public:
      53              :     /* Expected byte size of the EnableKey */
      54              :     static constexpr size_t kEnableKeyLength = 16;
      55              : 
      56              :     virtual ~TestEventTriggerDelegate() {}
      57              :     /**
      58              :      * Checks to see if `enableKey` provided matches value chosen by the manufacturer.
      59              :      *
      60              :      * @param[in] enableKey Buffer of the key to verify.
      61              :      */
      62              :     virtual bool DoesEnableKeyMatch(const ByteSpan & enableKey) const = 0;
      63              : 
      64              :     /**
      65              :      * Handles the test event trigger based on `eventTrigger` provided.
      66              :      *
      67              :      * By default, this iterates over handlers added via `AddEventTriggerHandler`.
      68              :      *
      69              :      * If more specific behavior is desired, the method can be completely overridden.
      70              :      *
      71              :      * @param[in] eventTrigger Event trigger to handle.
      72              :      *
      73              :      * @return CHIP_NO_ERROR on success or another CHIP_ERROR on failure
      74              :      */
      75              :     virtual CHIP_ERROR HandleEventTriggers(uint64_t eventTrigger)
      76              :     {
      77              :         CHIP_ERROR last_error = CHIP_ERROR_INVALID_ARGUMENT;
      78              :         for (TestEventTriggerHandler & handler : mHandlerList)
      79              :         {
      80              :             last_error = handler.HandleEventTrigger(eventTrigger);
      81              :             if (last_error == CHIP_NO_ERROR)
      82              :             {
      83              :                 break;
      84              :             }
      85              :         }
      86              : 
      87              :         return last_error;
      88              :     }
      89              : 
      90              :     CHIP_ERROR AddHandler(TestEventTriggerHandler * handler)
      91              :     {
      92              :         VerifyOrReturnError(!mHandlerList.Contains(handler), CHIP_ERROR_INVALID_ARGUMENT);
      93              :         mHandlerList.PushBack(handler);
      94              :         return CHIP_NO_ERROR;
      95              :     }
      96              : 
      97              :     void RemoveHandler(TestEventTriggerHandler * handler)
      98              :     {
      99              :         VerifyOrReturn(mHandlerList.Contains(handler));
     100              :         mHandlerList.Remove(handler);
     101              :     }
     102              : 
     103              :     void ClearAllHandlers() { mHandlerList.Clear(); }
     104              : 
     105              : protected:
     106              :     IntrusiveList<TestEventTriggerHandler, IntrusiveMode::AutoUnlink> mHandlerList;
     107              : };
     108              : 
     109              : /**
     110              :  * @brief TestEventTriggerDelegate that owns its enable key in RAM.
     111              :  *
     112              :  */
     113              : class SimpleTestEventTriggerDelegate : public TestEventTriggerDelegate
     114              : {
     115              : public:
     116              :     SimpleTestEventTriggerDelegate() { memset(&mEnableKey[0], 0, sizeof(mEnableKey)); }
     117              : 
     118              :     /**
     119              :      * @brief Initialize the delegate with a key
     120              :      *
     121              :      * @param enableKey - EnableKey to use for this instance.
     122              :      * @return CHIP_NO_ERROR on success, CHIP_ERROR_INVALID_ARGUMENT if enableKey is wrong size.
     123              :      */
     124              :     CHIP_ERROR Init(ByteSpan enableKey)
     125              :     {
     126              :         VerifyOrReturnError(enableKey.size() == sizeof(mEnableKey), CHIP_ERROR_INVALID_ARGUMENT);
     127              :         MutableByteSpan ourEnableKeySpan(mEnableKey);
     128              :         return CopySpanToMutableSpan(enableKey, ourEnableKeySpan);
     129              :     }
     130              : 
     131              :     bool DoesEnableKeyMatch(const ByteSpan & enableKey) const override { return enableKey.data_equal(ByteSpan(mEnableKey)); }
     132              : 
     133              : private:
     134              :     uint8_t mEnableKey[TestEventTriggerDelegate::kEnableKeyLength];
     135              : };
     136              : 
     137              : } // namespace chip