Restyle Simplfy the implementation of Mode Select Cluster

examples/all-clusters-app/all-clusters-common/include/static-supported-modes-manager.h

@@ -0,0 +1,73 @@
+/*
+ *
+ *    Copyright (c) 2021 Project CHIP Authors
+ *    All rights reserved.
+ *
+ *    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.
+ */
+
+#pragma once
+
+#include <app/clusters/mode-select-server/supported-modes-manager.h>
+#include <app/util/af.h>
+#include <cstring>
+
+namespace chip {
+namespace app {
+namespace Clusters {
+namespace ModeSelect {
+
+/**
+ * This implementation statically defines the options.
+ */
+
+class StaticSupportedModesManager : public chip::app::Clusters::ModeSelect::SupportedModesManager
+{
+    using ModeOptionStructType = Structs::ModeOptionStruct::Type;
+    using storage_value_type   = const ModeOptionStructType;
+
+    struct EndpointSpanPair
+    {
+        const EndpointId mEndpointId;
+        const Span<storage_value_type> mSpan;
+
+        EndpointSpanPair(const EndpointId aEndpointId, const Span<storage_value_type> && aSpan) :
+            mEndpointId(aEndpointId), mSpan(aSpan)
+        {}
+
+        EndpointSpanPair() : mEndpointId(0), mSpan(Span<storage_value_type>()) {}
+    };
+
+    static storage_value_type coffeeOptions[];
+    static const EndpointSpanPair supportedOptionsByEndpoints[EMBER_AF_MODE_SELECT_CLUSTER_SERVER_ENDPOINT_COUNT];
+
+public:
+    static const StaticSupportedModesManager instance;
+
+    const SupportedModesManager::ModeOptionsProvider getModeOptionsProvider(EndpointId endpointId) const override;
+
+    EmberAfStatus getModeOptionByMode(EndpointId endpointId, uint8_t mode, const ModeOptionStructType ** dataPtr) const override;
+
+    ~StaticSupportedModesManager(){};
+
+    StaticSupportedModesManager() {}
+
+    static inline const StaticSupportedModesManager & getStaticSupportedModesManagerInstance() { return instance; }
+};
+
+const SupportedModesManager * getSupportedModesManager();
+
+} // namespace ModeSelect
+} // namespace Clusters
+} // namespace app
+} // namespace chip

examples/all-clusters-app/all-clusters-common/src/static-supported-modes-manager.cpp

@@ -0,0 +1,71 @@
+#include <static-supported-modes-manager.h>
+
+using namespace std;
+using namespace chip;
+using namespace chip::app::Clusters;
+using namespace chip::app::Clusters::ModeSelect;
+
+using ModeOptionStructType = Structs::ModeOptionStruct::Type;
+using storage_value_type   = const ModeOptionStructType;
+namespace {
+Structs::ModeOptionStruct::Type buildModeOptionStruct(const char * label, uint8_t mode, uint32_t semanticTag)
+{
+    Structs::ModeOptionStruct::Type option;
+    option.label       = CharSpan(label, strlen(label));
+    option.mode        = mode;
+    option.semanticTag = semanticTag;
+    return option;
+}
+} // namespace
+
+// TODO: Configure your options for each endpoint
+storage_value_type StaticSupportedModesManager::coffeeOptions[] = { buildModeOptionStruct("Black", 0, 0),
+                                                                    buildModeOptionStruct("Cappuccino", 4, 0),
+                                                                    buildModeOptionStruct("Espresso", 7, 0) };
+const StaticSupportedModesManager::EndpointSpanPair
+    StaticSupportedModesManager::supportedOptionsByEndpoints[EMBER_AF_MODE_SELECT_CLUSTER_SERVER_ENDPOINT_COUNT] = {
+        EndpointSpanPair(1, Span<storage_value_type>(StaticSupportedModesManager::coffeeOptions)) // Options for Endpoint 1
+    };
+
+const StaticSupportedModesManager StaticSupportedModesManager::instance = StaticSupportedModesManager();
+
+const SupportedModesManager::ModeOptionsProvider StaticSupportedModesManager::getModeOptionsProvider(EndpointId endpointId) const
+{
+    for (auto & endpointSpanPair : supportedOptionsByEndpoints)
+    {
+        if (endpointSpanPair.mEndpointId == endpointId)
+        {
+            return ModeOptionsProvider(endpointSpanPair.mSpan.data(), endpointSpanPair.mSpan.end());
+        }
+    }
+    return ModeOptionsProvider(nullptr, nullptr);
+}
+
+EmberAfStatus StaticSupportedModesManager::getModeOptionByMode(unsigned short endpointId, unsigned char mode,
+                                                               const ModeOptionStructType ** dataPtr) const
+{
+    auto modeOptionsProvider = this->getModeOptionsProvider(endpointId);
+    if (modeOptionsProvider.begin() == nullptr)
+    {
+        return EMBER_ZCL_STATUS_UNSUPPORTED_CLUSTER;
+    }
+    auto * begin = this->getModeOptionsProvider(endpointId).begin();
+    auto * end   = this->getModeOptionsProvider(endpointId).end();
+
+    for (auto * it = begin; it != end; ++it)
+    {
+        auto & modeOption = *it;
+        if (modeOption.mode == mode)
+        {
+            *dataPtr = &modeOption;
+            return EMBER_ZCL_STATUS_SUCCESS;
+        }
+    }
+    emberAfPrintln(EMBER_AF_PRINT_DEBUG, "Cannot find the mode %" PRIu8, mode);
+    return EMBER_ZCL_STATUS_INVALID_ARGUMENT;
+}
+
+const ModeSelect::SupportedModesManager * ModeSelect::getSupportedModesManager()
+{
+    return &StaticSupportedModesManager::instance;
+}

examples/all-clusters-app/ameba/chip_main.cmake

@@ -36,6 +36,7 @@ list(
     ${chip_dir}/zzz_generated/all-clusters-app/zap-generated/CHIPClusters.cpp
 
     ${chip_dir}/examples/all-clusters-app/all-clusters-common/src/bridged-actions-stub.cpp
+    ${chip_dir}/examples/all-clusters-app/all-clusters-common/src/static-supported-modes-manager.cpp
 
     ${chip_dir}/examples/all-clusters-app/ameba/main/chipinterface.cpp
     ${chip_dir}/examples/all-clusters-app/ameba/main/DeviceCallbacks.cpp
@@ -63,6 +64,7 @@ target_include_directories(
     ${chip_dir}/zzz_generated/all-clusters-app/zap-generated
     ${chip_dir}/zzz_generated/app-common
     ${chip_dir}/examples/all-clusters-app/all-clusters-common
+    ${chip_dir}/examples/all-clusters-app/all-clusters-common/include
     ${chip_dir}/examples/all-clusters-app/ameba/main/include
     ${chip_dir_output}/gen/include
     ${chip_dir}/src/include/

examples/all-clusters-app/esp32/main/CMakeLists.txt

@@ -19,6 +19,7 @@
 # The list of src and include dirs must be in sync with that in all-clusters-app/esp32/main/component.mk
 set(PRIV_INCLUDE_DIRS_LIST
                       "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/zzz_generated/all-clusters-app"
+                      "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/examples/all-clusters-app/all-clusters-common/include"
                       "${CMAKE_CURRENT_LIST_DIR}/include"
 )
 set(SRC_DIRS_LIST

examples/all-clusters-app/linux/BUILD.gn

@@ -15,6 +15,28 @@
 import("//build_overrides/build.gni")
 import("//build_overrides/chip.gni")
 
+static_library("static-supported-modes-manager") {
+  sources = [ "${chip_root}/examples/all-clusters-app/all-clusters-common/src/static-supported-modes-manager.cpp" ]
+
+  #zap_pregenerated_dir = "${chip_root}/zzz_generated"
+
+  deps = []
+  deps += [
+    "${chip_root}/src/app",
+    "${chip_root}/src/app/common:cluster-objects",
+    "${chip_root}/src/controller",
+    "${chip_root}/src/lib/core",
+  ]
+  include_dirs = [
+    "include",
+    "${chip_root}/examples/all-clusters-app/all-clusters-common/include",
+    "${chip_root}/src",
+    "${chip_root}/zzz_generated/all-clusters-app",
+  ]
+
+  cflags = [ "-Wconversion" ]
+}
+
 executable("chip-all-clusters-app") {
   sources = [
     "${chip_root}/examples/all-clusters-app/all-clusters-common/src/bridged-actions-stub.cpp",
@@ -23,6 +45,7 @@ executable("chip-all-clusters-app") {
   ]
 
   deps = [
+    ":static-supported-modes-manager",
     "${chip_root}/examples/all-clusters-app/all-clusters-common",
     "${chip_root}/examples/platform/linux:app-main",
     "${chip_root}/src/lib",

examples/all-clusters-app/mbed/CMakeLists.txt

@@ -37,6 +37,8 @@ target_include_directories(${APP_TARGET} PRIVATE
                            ${CMAKE_CURRENT_SOURCE_DIR}
                            ${CMAKE_CURRENT_SOURCE_DIR}/main/include/
                            ${APP_ROOT}/all-clusters-common
+                           ${APP_ROOT}/all-clusters-common/include
+                           ${APP_CLUSTERS}
                            ${MBED_COMMON}/util/include
                            ${CHIP_ROOT}/src/app
                            ${CHIP_ROOT}/third_party/nlio/repo/include
@@ -67,6 +69,7 @@ target_sources(${APP_TARGET} PRIVATE
                ${CHIP_ROOT}/src/app/server/CommissioningWindowManager.cpp
 
                ${CHIP_ROOT}/examples/all-clusters-app/all-clusters-common/src/bridged-actions-stub.cpp
+               ${CHIP_ROOT}/examples/all-clusters-app/all-clusters-common/src/static-supported-modes-manager.cpp
 
                ${APP_UTIL}/DataModelHandler.cpp
                ${APP_UTIL}/af-event.cpp
@@ -112,7 +115,6 @@ target_sources(${APP_TARGET} PRIVATE
                ${APP_CLUSTERS}/media-input-server/media-input-server.cpp
                ${APP_CLUSTERS}/media-playback-server/media-playback-server.cpp
                ${APP_CLUSTERS}/mode-select-server/mode-select-server.cpp
-               ${APP_CLUSTERS}/mode-select-server/static-supported-modes-manager.cpp
                ${APP_CLUSTERS}/network-commissioning/network-commissioning-ember.cpp
                ${APP_CLUSTERS}/network-commissioning/network-commissioning.cpp
                ${APP_CLUSTERS}/on-off-server/on-off-server.cpp

examples/all-clusters-app/p6/BUILD.gn

@@ -54,6 +54,30 @@ p6_sdk_sources("all_clusters_app_sdk_sources") {
   public_configs = [ "${chip_root}/third_party/p6:p6_sdk_config" ]
 }
 
+static_library("static-supported-modes-manager") {
+  sources = [ "${chip_root}/examples/all-clusters-app/all-clusters-common/src/static-supported-modes-manager.cpp" ]
+
+  #zap_pregenerated_dir = "${chip_root}/zzz_generated"
+
+  public_deps = []
+  public_deps += [
+    "${chip_root}/src/app",
+    "${chip_root}/src/app/common:cluster-objects",
+    "${chip_root}/src/controller",
+    "${chip_root}/src/lib/core",
+  ]
+  include_dirs = [
+    "${chip_root}",
+    "${chip_root}/src",
+    "${chip_root}/zzz_generated/all-clusters-app",
+    "${chip_root}/examples/all-clusters-app/all-clusters-common/include",
+  ]
+
+  cflags = [ "-Wconversion" ]
+
+  print("include_dirs = ")
+}
+
 p6_executable("clusters_app") {
   include_dirs = []
   defines = []
@@ -72,6 +96,7 @@ p6_executable("clusters_app") {
 
   deps = [
     ":all_clusters_app_sdk_sources",
+    ":static-supported-modes-manager",
     "${chip_root}/examples/all-clusters-app/all-clusters-common",
     "${chip_root}/examples/common/QRCode",
     "${chip_root}/src/lib",

src/app/chip_data_model.gni

@@ -145,7 +145,7 @@ template("chip_data_model") {
       } else if (cluster == "mode-select-server") {
         sources += [
           "${_app_root}/clusters/${cluster}/${cluster}.cpp",
-          "${_app_root}/clusters/${cluster}/static-supported-modes-manager.cpp",
+          "${_app_root}/clusters/${cluster}/supported-modes-manager.h",
         ]
       } else {
         sources += [ "${_app_root}/clusters/${cluster}/${cluster}.cpp" ]

src/app/clusters/mode-select-server/mode-select-server.cpp

@@ -25,7 +25,7 @@
 #include <app/AttributeAccessInterface.h>
 #include <app/CommandHandler.h>
 #include <app/ConcreteCommandPath.h>
-#include <app/clusters/mode-select-server/static-supported-modes-manager.h>
+#include <app/clusters/mode-select-server/supported-modes-manager.h>
 #include <app/util/af.h>
 #include <app/util/attribute-storage.h>
 #include <lib/support/CodeUtils.h>
@@ -51,25 +51,22 @@ CHIP_ERROR ModeSelectAttrAccess::Read(const ConcreteAttributePath & aPath, Attri
 {
     VerifyOrDie(aPath.mClusterId == ModeSelect::Id);
 
-    const ModeSelect::StaticSupportedModesManager & gSupportedModeManager =
-        ModeSelect::StaticSupportedModesManager::getStaticSupportedModesManagerInstance();
+    const ModeSelect::SupportedModesManager * gSupportedModeManager = ModeSelect::getSupportedModesManager();
 
     if (ModeSelect::Attributes::SupportedModes::Id == aPath.mAttributeId)
     {
-        const ModeSelect::StaticSupportedModesManager::IteratorFactory * iteratorFactory =
-            gSupportedModeManager.getIteratorFactory(aPath.mEndpointId);
-        if (iteratorFactory == nullptr)
+        const ModeSelect::SupportedModesManager::ModeOptionsProvider modeOptionsProvider =
+            gSupportedModeManager->getModeOptionsProvider(aPath.mEndpointId);
+        if (modeOptionsProvider.begin() == nullptr)
         {
             aEncoder.Encode(DataModel::List<ModeSelect::Structs::ModeOptionStruct::Type>());
             return CHIP_NO_ERROR;
         }
         CHIP_ERROR err;
-        err = aEncoder.EncodeList([iteratorFactory](const TagBoundEncoder & encoder) -> CHIP_ERROR {
-            const auto & end = *(iteratorFactory->end());
-            for (auto it = *(iteratorFactory->begin()); it != end; ++it)
+        err = aEncoder.EncodeList([modeOptionsProvider](const TagBoundEncoder & encoder) -> CHIP_ERROR {
+            const auto * end = modeOptionsProvider.end();
+            for (auto * it = modeOptionsProvider.begin(); it != end; ++it)
             {
-                emberAfPrintln(EMBER_AF_PRINT_DEBUG, "ModeSelect: dereferencing it");
-                emberAfPrintln(EMBER_AF_PRINT_DEBUG, "ModeSelect: it= %p", (void *) it.operator->());
                 auto & modeOption = *it;
                 ReturnErrorOnFailure(encoder.Encode(modeOption));
             }
@@ -90,9 +87,8 @@ bool emberAfModeSelectClusterChangeToModeCallback(CommandHandler * commandHandle
     uint8_t newMode       = commandData.newMode;
     // Check that the newMode matches one of the supported options
     const ModeSelect::Structs::ModeOptionStruct::Type * modeOptionPtr;
-    const ModeSelect::StaticSupportedModesManager & gSupportedModeManager =
-        ModeSelect::StaticSupportedModesManager::getStaticSupportedModesManagerInstance();
-    EmberAfStatus checkSupportedModeStatus = gSupportedModeManager.getModeOptionByMode(endpointId, newMode, &modeOptionPtr);
+    EmberAfStatus checkSupportedModeStatus =
+        ModeSelect::getSupportedModesManager()->getModeOptionByMode(endpointId, newMode, &modeOptionPtr);
     if (EMBER_ZCL_STATUS_SUCCESS != checkSupportedModeStatus)
     {
         emberAfPrintln(EMBER_AF_PRINT_DEBUG, "ModeSelect: Failed to find the option with mode %" PRIu8, newMode);