[Scenes] SceneHandler helpers (project-chip#30245)

* Added helpers to reduce code copied over when created scene new scene handlers

* Applied comments

* Update src/app/clusters/scenes-server/SceneHandlerImpl.h

Co-authored-by: Boris Zbarsky <bzbarsky@apple.com>

---------

Co-authored-by: Boris Zbarsky <bzbarsky@apple.com>

Author: lpbeliveau-silabs

src/app/chip_data_model.gni

@@ -163,6 +163,7 @@ template("chip_data_model") {
       "${_app_root}/clusters/on-off-server/on-off-server.h",
       "${_app_root}/clusters/scenes-server/ExtensionFieldSets.h",
       "${_app_root}/clusters/scenes-server/ExtensionFieldSetsImpl.h",
+      "${_app_root}/clusters/scenes-server/SceneHandlerImpl.h",
       "${_app_root}/clusters/scenes-server/SceneTable.h",
       "${_app_root}/clusters/scenes-server/SceneTableImpl.h",
       "${_app_root}/clusters/scenes-server/scenes-server.h",
@@ -278,6 +279,7 @@ template("chip_data_model") {
         sources += [
           "${_app_root}/clusters/${cluster}/${cluster}.cpp",
           "${_app_root}/clusters/scenes-server/ExtensionFieldSetsImpl.cpp",
+          "${_app_root}/clusters/scenes-server/SceneHandlerImpl.cpp",
           "${_app_root}/clusters/scenes-server/SceneTableImpl.cpp",
         ]
       } else if (cluster == "operational-state-server") {

src/app/clusters/on-off-server/on-off-server.cpp

@@ -104,101 +104,15 @@ static constexpr size_t kOnOffMaxEnpointCount =
     EMBER_AF_ON_OFF_CLUSTER_SERVER_ENDPOINT_COUNT + CHIP_DEVICE_CONFIG_DYNAMIC_ENDPOINT_COUNT;
 
 #ifdef EMBER_AF_PLUGIN_SCENES
-static EmberEventControl sceneHandlerEventControls[kOnOffMaxEnpointCount];
 static void sceneOnOffCallback(EndpointId endpoint);
+using OnOffEndPointPair = scenes::DefaultSceneHandlerImpl::EndpointStatePair<bool>;
+using OnOffTransitionTimeInterface =
+    scenes::DefaultSceneHandlerImpl::TransitionTimeInterface<kOnOffMaxEnpointCount, EMBER_AF_ON_OFF_CLUSTER_SERVER_ENDPOINT_COUNT>;
 
 class DefaultOnOffSceneHandler : public scenes::DefaultSceneHandlerImpl
 {
 public:
-    /// @brief Struct to keep track of the desired state of the OnOff attribute between ApplyScene and
-    /// transition time expiration
-    struct EndpointStatePair
-    {
-        EndpointStatePair(EndpointId endpoint = kInvalidEndpointId, bool status = false) : mEndpoint(endpoint), mState(status) {}
-        EndpointId mEndpoint;
-        bool mState;
-    };
-
-    /// @brief Struct holding an array of EndpointStatePair. Handles insertion, get and removal by EndpointID.
-    /// TODO: Implement generic object to handle this boilerplate array manipulation
-    struct StatePairBuffer
-    {
-        bool IsEmpty() const { return (mPairCount == 0); }
-
-        CHIP_ERROR FindPair(const EndpointId endpoint, uint16_t & found_index) const
-        {
-            VerifyOrReturnError(!IsEmpty(), CHIP_ERROR_NOT_FOUND);
-            for (found_index = 0; found_index < mPairCount; found_index++)
-            {
-                if (endpoint == mStatePairBuffer[found_index].mEndpoint)
-                {
-                    return CHIP_NO_ERROR;
-                }
-            }
-
-            return CHIP_ERROR_NOT_FOUND;
-        }
-
-        CHIP_ERROR InsertPair(const EndpointStatePair & status)
-        {
-            uint16_t idx;
-            CHIP_ERROR err = FindPair(status.mEndpoint, idx);
-
-            if (CHIP_NO_ERROR == err)
-            {
-                mStatePairBuffer[idx] = status;
-            }
-            else if (mPairCount < MAX_ENDPOINT_COUNT)
-            {
-                // if not found, insert at the end
-                mStatePairBuffer[mPairCount] = status;
-                mPairCount++;
-            }
-            else
-            {
-                return CHIP_ERROR_NO_MEMORY;
-            }
-
-            return CHIP_NO_ERROR;
-        }
-
-        CHIP_ERROR GetPair(const EndpointId endpoint, EndpointStatePair & status) const
-        {
-            uint16_t idx;
-            ReturnErrorOnFailure(FindPair(endpoint, idx));
-
-            status = mStatePairBuffer[idx];
-            return CHIP_NO_ERROR;
-        }
-
-        /// @brief Removes Pair and decrements Pair count if the endpoint existed in the array
-        /// @param endpoint : endpoint id of the pair
-        CHIP_ERROR RemovePair(const EndpointId endpoint)
-        {
-            uint16_t position;
-            VerifyOrReturnValue(CHIP_NO_ERROR == FindPair(endpoint, position), CHIP_NO_ERROR);
-
-            uint16_t nextPos = static_cast<uint16_t>(position + 1);
-            uint16_t moveNum = static_cast<uint16_t>(mPairCount - nextPos);
-
-            // Compress array after removal, if the removed position is not the last
-            if (moveNum)
-            {
-                memmove(&mStatePairBuffer[position], &mStatePairBuffer[nextPos], sizeof(EndpointStatePair) * moveNum);
-            }
-
-            mPairCount--;
-            // Clear last occupied position
-            mStatePairBuffer[mPairCount].mEndpoint = kInvalidEndpointId;
-
-            return CHIP_NO_ERROR;
-        }
-
-        uint16_t mPairCount;
-        EndpointStatePair mStatePairBuffer[kOnOffMaxEnpointCount];
-    };
-
-    StatePairBuffer mSceneEndpointStatePairs;
+    DefaultSceneHandlerImpl::StatePairBuffer<bool, kOnOffMaxEnpointCount> mSceneEndpointStatePairs;
     // As per spec, 1 attribute is scenable in the on off cluster
     static constexpr uint8_t scenableAttributeCount = 1;
 
@@ -279,7 +193,7 @@ class DefaultOnOffSceneHandler : public scenes::DefaultSceneHandlerImpl
             auto & decodePair = pair_iterator.GetValue();
             VerifyOrReturnError(decodePair.attributeID == Attributes::OnOff::Id, CHIP_ERROR_INVALID_ARGUMENT);
             ReturnErrorOnFailure(
-                mSceneEndpointStatePairs.InsertPair(EndpointStatePair(endpoint, static_cast<bool>(decodePair.attributeValue))));
+                mSceneEndpointStatePairs.InsertPair(OnOffEndPointPair(endpoint, static_cast<bool>(decodePair.attributeValue))));
         }
         // Verify that the EFS was completely read
         CHIP_ERROR err = pair_iterator.GetStatus();
@@ -299,38 +213,22 @@ class DefaultOnOffSceneHandler : public scenes::DefaultSceneHandlerImpl
               Scenes::ScenesServer::Instance().IsHandlerRegistered(endpoint, LevelControlServer::GetSceneHandler())))
 #endif
         {
-            OnOffServer::Instance().scheduleTimerCallbackMs(sceneEventControl(endpoint), timeMs);
+            OnOffServer::Instance().scheduleTimerCallbackMs(mTransitionTimeInterface.sceneEventControl(endpoint), timeMs);
         }
 
         return CHIP_NO_ERROR;
     }
 
 private:
-    /**
-     * @brief Configures EventControl callback when setting On Off through scenes callback
-     *
-     * @param[in] endpoint endpoint to start timer for
-     * @return EmberEventControl* configured event control
-     */
-    EmberEventControl * sceneEventControl(EndpointId endpoint)
-    {
-        EmberEventControl * controller =
-            OnOffServer::Instance().getEventControl(endpoint, Span<EmberEventControl>(sceneHandlerEventControls));
-        VerifyOrReturnValue(controller != nullptr, nullptr);
-
-        controller->endpoint = endpoint;
-        controller->callback = &sceneOnOffCallback;
-
-        return controller;
-    }
+    OnOffTransitionTimeInterface mTransitionTimeInterface = OnOffTransitionTimeInterface(Attributes::OnOff::Id, sceneOnOffCallback);
 };
 static DefaultOnOffSceneHandler sOnOffSceneHandler;
 
 static void sceneOnOffCallback(EndpointId endpoint)
 {
-    DefaultOnOffSceneHandler::EndpointStatePair savedState;
+    OnOffEndPointPair savedState;
     ReturnOnFailure(sOnOffSceneHandler.mSceneEndpointStatePairs.GetPair(endpoint, savedState));
-    chip::CommandId command = (savedState.mState) ? Commands::On::Id : Commands::Off::Id;
+    CommandId command = (savedState.mValue) ? Commands::On::Id : Commands::Off::Id;
     OnOffServer::Instance().setOnOffValue(endpoint, command, false);
     ReturnOnFailure(sOnOffSceneHandler.mSceneEndpointStatePairs.RemovePair(endpoint));
 }

src/app/clusters/scenes-server/BUILD.gn

@@ -20,6 +20,8 @@ static_library("scenes") {
     "ExtensionFieldSets.h",
     "ExtensionFieldSetsImpl.cpp",
     "ExtensionFieldSetsImpl.h",
+    "SceneHandlerImpl.cpp",
+    "SceneHandlerImpl.h",
     "SceneTable.h",
     "SceneTableImpl.cpp",
     "SceneTableImpl.h",

src/app/clusters/scenes-server/SceneHandlerImpl.cpp

@@ -0,0 +1,99 @@
+/*
+ *
+ *    Copyright (c) 2023 Project CHIP Authors
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+
+#include <app/clusters/scenes-server/SceneHandlerImpl.h>
+
+namespace chip {
+namespace scenes {
+
+CHIP_ERROR
+DefaultSceneHandlerImpl::EncodeAttributeValueList(const List<AttributeValuePairType> & aVlist, MutableByteSpan & serializedBytes)
+{
+    TLV::TLVWriter writer;
+    writer.Init(serializedBytes);
+    ReturnErrorOnFailure(app::DataModel::Encode(writer, TLV::AnonymousTag(), aVlist));
+    serializedBytes.reduce_size(writer.GetLengthWritten());
+
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR DefaultSceneHandlerImpl::DecodeAttributeValueList(const ByteSpan & serializedBytes,
+                                                             DecodableList<AttributeValuePairDecodableType> & aVlist)
+{
+    TLV::TLVReader reader;
+
+    reader.Init(serializedBytes);
+    ReturnErrorOnFailure(reader.Next(TLV::kTLVType_Array, TLV::AnonymousTag()));
+    ReturnErrorOnFailure(aVlist.Decode(reader));
+
+    return CHIP_NO_ERROR;
+}
+
+CHIP_ERROR
+DefaultSceneHandlerImpl::SerializeAdd(EndpointId endpoint, const ExtensionFieldSetDecodableType & extensionFieldSet,
+                                      MutableByteSpan & serializedBytes)
+{
+    AttributeValuePairType aVPairs[kMaxAvPair];
+
+    size_t pairTotal = 0;
+    // Verify size of list
+    ReturnErrorOnFailure(extensionFieldSet.attributeValueList.ComputeSize(&pairTotal));
+    VerifyOrReturnError(pairTotal <= ArraySize(aVPairs), CHIP_ERROR_BUFFER_TOO_SMALL);
+
+    uint8_t pairCount  = 0;
+    auto pair_iterator = extensionFieldSet.attributeValueList.begin();
+    while (pair_iterator.Next())
+    {
+        aVPairs[pairCount] = pair_iterator.GetValue();
+        pairCount++;
+    }
+    ReturnErrorOnFailure(pair_iterator.GetStatus());
+    List<AttributeValuePairType> attributeValueList(aVPairs, pairCount);
+
+    return EncodeAttributeValueList(attributeValueList, serializedBytes);
+}
+
+CHIP_ERROR DefaultSceneHandlerImpl::Deserialize(EndpointId endpoint, ClusterId cluster, const ByteSpan & serializedBytes,
+                                                ExtensionFieldSetType & extensionFieldSet)
+{
+    DecodableList<AttributeValuePairDecodableType> attributeValueList;
+
+    ReturnErrorOnFailure(DecodeAttributeValueList(serializedBytes, attributeValueList));
+
+    // Verify size of list
+    size_t pairTotal = 0;
+    ReturnErrorOnFailure(attributeValueList.ComputeSize(&pairTotal));
+    VerifyOrReturnError(pairTotal <= ArraySize(mAVPairs), CHIP_ERROR_BUFFER_TOO_SMALL);
+
+    uint8_t pairCount  = 0;
+    auto pair_iterator = attributeValueList.begin();
+    while (pair_iterator.Next())
+    {
+        mAVPairs[pairCount] = pair_iterator.GetValue();
+        pairCount++;
+    };
+    ReturnErrorOnFailure(pair_iterator.GetStatus());
+
+    extensionFieldSet.clusterID          = cluster;
+    extensionFieldSet.attributeValueList = mAVPairs;
+    extensionFieldSet.attributeValueList.reduce_size(pairCount);
+
+    return CHIP_NO_ERROR;
+}
+
+} // namespace scenes
+} // namespace chip