Chef: Add APIs to provide deviceType info on Endpoints. Make chef static temperature levels (temperature control cluster) endpoint agnostic.

examples/chef/common/DeviceTypes.cpp

@@ -0,0 +1,69 @@
+/*
+ *
+ *    Copyright (c) 2025 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.
+ */
+
+#include "DeviceTypes.h"
+#include <app/InteractionModelEngine.h>
+#include <app/data-model-provider/MetadataTypes.h>
+#include <lib/support/CodeUtils.h>
+
+using namespace chef;
+using namespace chip;
+using namespace chip::app;
+
+bool DeviceTypes::EndpointHasDeviceType(EndpointId endpoint, DeviceTypeId deviceTypeId)
+{
+    DataModel::ListBuilder<DataModel::DeviceTypeEntry> deviceTypesList;
+    CHIP_ERROR err = InteractionModelEngine::GetInstance()->GetDataModelProvider()->DeviceTypes(endpoint, deviceTypesList);
+    if (err != CHIP_NO_ERROR)
+    {
+        ChipLogError(DeviceLayer, "GetDataModelProvider DeviceTypes returned error: %" CHIP_ERROR_FORMAT, err.Format());
+        return false;
+    }
+    auto deviceTypes = deviceTypesList.TakeBuffer();
+    for (const auto & type : deviceTypes)
+    {
+        if (type.deviceTypeId == deviceTypeId)
+        {
+            return true;
+        }
+    }
+    return false;
+}
+
+DataModel::ListBuilder<EndpointId> DeviceTypes::GetAllEndpointsHavingDeviceType(DeviceTypeId deviceTypeId)
+{
+    DataModel::ListBuilder<DataModel::EndpointEntry> endpointsList;
+    CHIP_ERROR err = InteractionModelEngine::GetInstance()->GetDataModelProvider()->Endpoints(endpointsList);
+    if (err != CHIP_NO_ERROR)
+    {
+        ChipLogError(DeviceLayer, "GetDataModelProvider Endpoints returned error: %" CHIP_ERROR_FORMAT, err.Format());
+        return DataModel::ListBuilder<EndpointId>();
+    }
+    auto allEndpoints = endpointsList.TakeBuffer();
+
+    DataModel::ListBuilder<EndpointId> endpoints;
+
+    for (const auto & ep : allEndpoints)
+    {
+        if (EndpointHasDeviceType(ep.id, deviceTypeId))
+        {
+            endpoints.Append(ep.id);
+        }
+    }
+    return endpoints;
+}

examples/chef/common/DeviceTypes.h

@@ -0,0 +1,69 @@
+/*
+ *
+ *    Copyright (c) 2025 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.
+ */
+
+#include <app/data-model-provider/MetadataList.h>
+#include <lib/core/CHIPError.h>
+#include <lib/core/DataModelTypes.h>
+
+namespace chef {
+namespace DeviceTypes {
+
+// Common location to store all device type IDs
+// Official list is in the spec and a complete copy is in -
+// https://github.com/project-chip/connectedhomeip/blob/master/src/app/zap-templates/zcl/data-model/chip/matter-devices.xml
+// TODO: Device type IDs must be code generated from matter-devices.xml
+constexpr chip::DeviceTypeId kCookSurfaceDeviceId                  = 0x0077;
+constexpr chip::DeviceTypeId kCooktopDeviceId                      = 0x0078;
+constexpr chip::DeviceTypeId kOvenDeviceId                         = 0x007B;
+constexpr chip::DeviceTypeId kRefrigeratorDeviceId                 = 0x0070;
+constexpr chip::DeviceTypeId kTemperatureControlledCabinetDeviceId = 0x0071;
+
+// Expected endpoint IDs for different device types
+namespace ExpectedEndpointId {
+// Oven
+constexpr chip::EndpointId kOven                         = 1;
+constexpr chip::EndpointId kTopCabinetPartOfOven         = 2;
+constexpr chip::EndpointId kCooktopPartOfOven            = 3;
+constexpr chip::EndpointId kCookSurfacePartOfCooktopOven = 4;
+
+// Cooktop
+constexpr chip::EndpointId kCooktopStandAlone        = 1;
+constexpr chip::EndpointId kCookSurfacePartOfCooktop = 2;
+
+// Refrigerator
+constexpr chip::EndpointId kRefrigerator                    = 1;
+constexpr chip::EndpointId kColdCabinetPartOfRefrigerator   = 2;
+constexpr chip::EndpointId kFreezeCabinetPartOfRefrigerator = 3;
+} // namespace ExpectedEndpointId
+
+// Devicetype APIs
+
+/**
+ * Returns true if the endpoint has the specified device type in its device types list.
+ * Device types list for the given endpoint is fetched using DataModelProvider.
+ */
+bool EndpointHasDeviceType(chip::EndpointId endpoint, chip::DeviceTypeId deviceTypeId);
+
+/**
+ * Returns a list of all endpoints that have the specified device type in their respective device types list.
+ * Endpoints list is fetched using DataModelProvider. Device type match is checked using EndpointHasDeviceType.
+ */
+chip::app::DataModel::ListBuilder<chip::EndpointId> GetAllEndpointsHavingDeviceType(chip::DeviceTypeId deviceTypeId);
+
+} // namespace DeviceTypes
+} // namespace chef

examples/chef/common/clusters/temperature-control/static-supported-temperature-levels.cpp

@@ -21,6 +21,7 @@
 #ifdef MATTER_DM_PLUGIN_TEMPERATURE_CONTROL_SERVER
 #include "static-supported-temperature-levels.h"
 #include <app/clusters/temperature-control-server/supported-temperature-levels-manager.h>
+#include <app/util/attribute-storage.h>
 #include <lib/support/CodeUtils.h>
 
 using namespace chip;
@@ -30,20 +31,25 @@ using chip::Protocols::InteractionModel::Status;
 
 app::Clusters::TemperatureControl::AppSupportedTemperatureLevelsDelegate sAppSupportedTemperatureLevelsDelegate;
 
-CharSpan AppSupportedTemperatureLevelsDelegate::temperatureLevelOptions[] = { "Low"_span, "Medium"_span, "High"_span };
+namespace chef {
+namespace Configuration {
+namespace TemperatureControl {
 
-const AppSupportedTemperatureLevelsDelegate::EndpointPair AppSupportedTemperatureLevelsDelegate::supportedOptionsByEndpoints
-    [MATTER_DM_TEMPERATURE_CONTROL_CLUSTER_SERVER_ENDPOINT_COUNT] = { EndpointPair(
-        1 /* endpointId */, AppSupportedTemperatureLevelsDelegate::temperatureLevelOptions,
-        MATTER_ARRAY_SIZE(AppSupportedTemperatureLevelsDelegate::temperatureLevelOptions)) };
+static const CharSpan kTemperatureLevelOptions[3] = { "Low"_span, "Medium"_span, "High"_span };
+} // namespace TemperatureControl
+} // namespace Configuration
+} // namespace chef
+
+chef::Configuration::TemperatureControl::EndpointPair
+    AppSupportedTemperatureLevelsDelegate::supportedOptionsByEndpoints[MATTER_DM_TEMPERATURE_CONTROL_CLUSTER_SERVER_ENDPOINT_COUNT];
 
 uint8_t AppSupportedTemperatureLevelsDelegate::Size()
 {
     for (auto & endpointPair : AppSupportedTemperatureLevelsDelegate::supportedOptionsByEndpoints)
     {
         if (endpointPair.mEndpointId == mEndpoint)
         {
-            return endpointPair.mSize;
+            return endpointPair.mTemperatureLevels.size();
         }
     }
     return 0;
@@ -55,7 +61,7 @@ CHIP_ERROR AppSupportedTemperatureLevelsDelegate::Next(MutableCharSpan & item)
     {
         if (endpointPair.mEndpointId == mEndpoint)
         {
-            if (endpointPair.mSize > mIndex)
+            if (endpointPair.mTemperatureLevels.size() > mIndex)
             {
                 CHIP_ERROR err = CopyCharSpanToMutableCharSpan(endpointPair.mTemperatureLevels[mIndex], item);
                 if (err != CHIP_NO_ERROR)
@@ -72,7 +78,13 @@ CHIP_ERROR AppSupportedTemperatureLevelsDelegate::Next(MutableCharSpan & item)
 }
 void emberAfTemperatureControlClusterInitCallback(EndpointId endpoint)
 {
-    static_assert(MATTER_DM_TEMPERATURE_CONTROL_CLUSTER_SERVER_ENDPOINT_COUNT == 1, "This cluster is only enabled for endpoint 1");
+    ChipLogDetail(DeviceLayer, "Initializing TemperatureControl cluster for Endpoint: %d", endpoint);
+    uint16_t epIndex = emberAfGetClusterServerEndpointIndex(endpoint, TemperatureControl::Id,
+                                                            MATTER_DM_TEMPERATURE_CONTROL_CLUSTER_SERVER_ENDPOINT_COUNT);
+    sAppSupportedTemperatureLevelsDelegate.SetSupportedEndpointPair(
+        epIndex,
+        chef::Configuration::TemperatureControl::EndpointPair(
+            endpoint /* endpointId */, Span<const CharSpan>(chef::Configuration::TemperatureControl::kTemperatureLevelOptions)));
 
     chip::app::Clusters::TemperatureControl::SetInstance(&sAppSupportedTemperatureLevelsDelegate);
 }

examples/chef/common/clusters/temperature-control/static-supported-temperature-levels.h

@@ -21,32 +21,53 @@
 #include <app/clusters/temperature-control-server/supported-temperature-levels-manager.h>
 #include <app/util/config.h>
 
+namespace chef {
+namespace Configuration {
+namespace TemperatureControl {
+
+/**
+ * @brief Endpoint to temperature levels mapping. The endpoint must have a temperature control cluster.
+ * Represents a pair of endpoints and temperature levels supported by that endpoint.
+ */
+struct EndpointPair
+{
+    /// An endpoint having temperature control cluster.
+    chip::EndpointId mEndpointId;
+
+    /// Temperature levels supported by the temperature control cluster at this endpoint.
+    /// This should point to a const char span array initialized statically.
+    chip::Span<const chip::CharSpan> mTemperatureLevels;
+
+    EndpointPair() : mEndpointId(chip::kInvalidEndpointId), mTemperatureLevels() {}
+
+    EndpointPair(chip::EndpointId aEndpointId, chip::Span<const chip::CharSpan> TemperatureLevels) :
+        mEndpointId(aEndpointId), mTemperatureLevels(TemperatureLevels)
+    {}
+};
+} // namespace TemperatureControl
+} // namespace Configuration
+} // namespace chef
+
 namespace chip {
 namespace app {
 namespace Clusters {
 namespace TemperatureControl {
 
 class AppSupportedTemperatureLevelsDelegate : public SupportedTemperatureLevelsIteratorDelegate
 {
-    struct EndpointPair
-    {
-        EndpointId mEndpointId;
-        CharSpan * mTemperatureLevels;
-        uint8_t mSize;
-
-        EndpointPair(EndpointId aEndpointId, CharSpan * TemperatureLevels, uint8_t size) :
-            mEndpointId(aEndpointId), mTemperatureLevels(TemperatureLevels), mSize(size)
-        {}
-    };
-
-    static CharSpan temperatureLevelOptions[3];
-    static const EndpointPair supportedOptionsByEndpoints[MATTER_DM_TEMPERATURE_CONTROL_CLUSTER_SERVER_ENDPOINT_COUNT];
+    static chef::Configuration::TemperatureControl::EndpointPair
+        supportedOptionsByEndpoints[MATTER_DM_TEMPERATURE_CONTROL_CLUSTER_SERVER_ENDPOINT_COUNT];
 
 public:
     uint8_t Size() override;
 
     CHIP_ERROR Next(MutableCharSpan & item) override;
 
+    static void SetSupportedEndpointPair(uint16_t index, chef::Configuration::TemperatureControl::EndpointPair endpointPair)
+    {
+        supportedOptionsByEndpoints[index] = endpointPair;
+    }
+
     ~AppSupportedTemperatureLevelsDelegate() {}
 };