Merge branch 'master' into icd_provisional_attributes

Author: cecille

examples/all-clusters-app/all-clusters-common/all-clusters-app.matter

@@ -3876,7 +3876,7 @@ cluster ValveConfigurationAndControl = 129 {
 }
 
 /** This cluster provides a mechanism for querying data about electrical power as measured by the server. */
-provisional cluster ElectricalPowerMeasurement = 144 {
+cluster ElectricalPowerMeasurement = 144 {
   revision 1;
 
   enum MeasurementTypeEnum : enum16 {
@@ -3981,7 +3981,7 @@ provisional cluster ElectricalPowerMeasurement = 144 {
 }
 
 /** This cluster provides a mechanism for querying data about the electrical energy imported or provided by the server. */
-provisional cluster ElectricalEnergyMeasurement = 145 {
+cluster ElectricalEnergyMeasurement = 145 {
   revision 1;
 
   enum MeasurementTypeEnum : enum16 {
@@ -4278,7 +4278,7 @@ provisional cluster DeviceEnergyManagement = 152 {
 }
 
 /** Electric Vehicle Supply Equipment (EVSE) is equipment used to charge an Electric Vehicle (EV) or Plug-In Hybrid Electric Vehicle. This cluster provides an interface to the functionality of Electric Vehicle Supply Equipment (EVSE) management. */
-provisional cluster EnergyEvse = 153 {
+cluster EnergyEvse = 153 {
   revision 2;
 
   enum EnergyTransferStoppedReasonEnum : enum8 {
@@ -4490,7 +4490,7 @@ provisional cluster EnergyPreference = 155 {
 }
 
 /** The Power Topology Cluster provides a mechanism for expressing how power is flowing between endpoints. */
-provisional cluster PowerTopology = 156 {
+cluster PowerTopology = 156 {
   revision 1;
 
   bitmap Feature : bitmap32 {
@@ -4511,7 +4511,7 @@ provisional cluster PowerTopology = 156 {
 }
 
 /** Attributes and commands for selecting a mode from a list of supported options. */
-provisional cluster EnergyEvseMode = 157 {
+cluster EnergyEvseMode = 157 {
   revision 1;
 
   enum ModeTag : enum16 {

examples/chef/common/chef-descriptor-namespace.h

@@ -0,0 +1,51 @@
+/*
+ *
+ *    Copyright (c) 2024 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.
+ */
+
+#pragma once
+
+// Please refer to https://github.com/CHIP-Specifications/connectedhomeip-spec/blob/master/src/namespaces
+constexpr const uint8_t kNamespaceCommonLevel = 5;
+// Common Number Namespace: 5, tag 0 (Low)
+constexpr const uint8_t kTagCommonLow = 0;
+// Common Number Namespace: 5, tag 1 (Medium)
+constexpr const uint8_t kTagCommonMedium = 1;
+// Common Number Namespace: 5, tag 2 (High)
+constexpr const uint8_t kTagCommonHigh = 2;
+
+constexpr const uint8_t kNamespaceCommonNumber = 7;
+// Common Number Namespace: 7, tag 0 (Zero)
+constexpr const uint8_t kTagCommonZero = 0;
+// Common Number Namespace: 7, tag 1 (One)
+constexpr const uint8_t kTagCommonOne = 1;
+// Common Number Namespace: 7, tag 2 (Two)
+constexpr const uint8_t kTagCommonTwo = 2;
+
+constexpr const uint8_t kNamespacePosition = 8;
+// Common Position Namespace: 8, tag: 0 (Left)
+constexpr const uint8_t kTagPositionLeft = 0;
+// Common Position Namespace: 8, tag: 1 (Right)
+constexpr const uint8_t kTagPositionRight = 1;
+// Common Position Namespace: 8, tag: 2 (Top)
+constexpr const uint8_t kTagPositionTop = 2;
+// Common Position Namespace: 8, tag: 3 (Bottom)
+constexpr const uint8_t kTagPositionBottom = 3;
+// Common Position Namespace: 8, tag: 4 (Middle)
+constexpr const uint8_t kTagPositionMiddle = 4;
+// Common Position Namespace: 8, tag: 5 (Row)
+constexpr const uint8_t kTagPositionRow = 5;
+// Common Position Namespace: 8, tag: 6 (Column)
+constexpr const uint8_t kTagPositionColumn = 6;

examples/chef/common/chef-rpc-actions-worker.cpp

@@ -0,0 +1,158 @@
+/*
+ *
+ *    Copyright (c) 2024 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 "chef-rpc-actions-worker.h"
+#include <app-common/zap-generated/attributes/Accessors.h>
+#include <app-common/zap-generated/callback.h>
+#include <app/data-model/Nullable.h>
+#include <app/util/config.h>
+#include <lib/core/DataModelTypes.h>
+#include <map>
+#include <platform/CHIPDeviceLayer.h>
+
+using chip::app::DataModel::Nullable;
+
+using namespace chip;
+using namespace chip::app;
+using namespace chip::app::Clusters;
+using namespace chip::rpc;
+
+static std::map<ClusterId, ActionsDelegate *> gActionsDelegateMap{};
+
+ActionsDelegate * RpcFindActionsDelegate(ClusterId clusterId)
+{
+    if (gActionsDelegateMap.find(clusterId) != gActionsDelegateMap.end())
+    {
+        return gActionsDelegateMap[clusterId];
+    }
+
+    return nullptr;
+}
+
+static void RpcActionsTaskCallback(System::Layer * systemLayer, void * data)
+{
+    ChefRpcActionsWorker * worker = (ChefRpcActionsWorker *) data;
+
+    worker->ProcessActionQueue();
+}
+
+bool ChefRpcActionsCallback(EndpointId endpointId, ClusterId clusterId, uint8_t type, uint32_t delayMs, uint32_t actionId,
+                            std::vector<uint32_t> args)
+{
+    ActionTask task(endpointId, clusterId, static_cast<ActionType>(type), delayMs, actionId, args);
+
+    return ChefRpcActionsWorker::Instance().EnqueueAction(task);
+}
+
+bool ChefRpcActionsWorker::EnqueueAction(ActionTask task)
+{
+    bool kickTimer = false;
+
+    if (queue.empty())
+    {
+        kickTimer = true; // kick timer when the first task is adding to the queue
+    }
+
+    queue.push(task);
+
+    if (kickTimer)
+    {
+        (void) DeviceLayer::SystemLayer().StartTimer(System::Clock::Milliseconds32(task.delayMs), RpcActionsTaskCallback, this);
+    }
+    return true;
+}
+
+void ChefRpcActionsWorker::ProcessActionQueue()
+{
+    // Dequeue the first item
+    ActionTask task = queue.front();
+    queue.pop();
+
+    ActionsDelegate * delegate = RpcFindActionsDelegate(task.clusterId);
+    if (nullptr == delegate)
+    {
+        ChipLogError(NotSpecified,
+                     "Cannot run action due to not finding delegate: endpointId=%d, clusterId=%04lx, attributeId=%04lx",
+                     task.endpointId, static_cast<unsigned long>(task.clusterId), static_cast<unsigned long>(task.actionId));
+        return;
+    }
+
+    ActionType type = static_cast<ActionType>(task.type);
+
+    switch (type)
+    {
+    case ActionType::WRITE_ATTRIBUTE: {
+        ChipLogProgress(NotSpecified, "Writing Attribute: endpointId=%d, clusterId=%04lx, attributeId=%04lx, args.size=%lu",
+                        task.endpointId, static_cast<unsigned long>(task.clusterId), static_cast<unsigned long>(task.actionId),
+                        static_cast<unsigned long>(task.args.size()));
+        delegate->AttributeWriteHandler(task.endpointId, static_cast<chip::AttributeId>(task.actionId), task.args);
+    }
+    break;
+    case ActionType::RUN_COMMAND: {
+        ChipLogProgress(NotSpecified, "Running Command: endpointId=%d, clusterId=%04lx, commandId=%04lx, args.size=%lu",
+                        task.endpointId, static_cast<unsigned long>(task.clusterId), static_cast<unsigned long>(task.actionId),
+                        static_cast<unsigned long>(task.args.size()));
+        delegate->CommandHandler(task.endpointId, static_cast<chip::CommandId>(task.actionId), task.args);
+    }
+    break;
+    case ActionType::EMIT_EVENT: {
+        ChipLogProgress(NotSpecified, "Emitting Event: endpointId=%d, clusterId=%04lx, eventIdId=%04lx, args.size=%lu",
+                        task.endpointId, static_cast<unsigned long>(task.clusterId), static_cast<unsigned long>(task.actionId),
+                        static_cast<unsigned long>(task.args.size()));
+        delegate->EventHandler(task.endpointId, static_cast<chip::EventId>(task.actionId), task.args);
+    }
+    break;
+    default:
+        break;
+    }
+
+    if (queue.empty())
+    {
+        // Return due to no more actions in queue
+        return;
+    }
+
+    // Run next action
+    task = queue.front();
+    ChipLogProgress(NotSpecified, "StartTimer: endpointId=%d, clusterId=%04lx, eventIdId=%04lx, task.delyMs=%lu", task.endpointId,
+                    static_cast<unsigned long>(task.clusterId), static_cast<unsigned long>(task.actionId),
+                    static_cast<unsigned long>(task.delayMs));
+    (void) DeviceLayer::SystemLayer().StartTimer(System::Clock::Milliseconds32(task.delayMs), RpcActionsTaskCallback, this);
+}
+
+void ChefRpcActionsWorker::RegisterRpcActionsDelegate(ClusterId clusterId, ActionsDelegate * delegate)
+{
+    // Register by cluster
+    if (nullptr == RpcFindActionsDelegate(clusterId))
+    {
+        gActionsDelegateMap[clusterId] = delegate;
+        return;
+    }
+}
+
+ChefRpcActionsWorker::ChefRpcActionsWorker()
+{
+    chip::rpc::SubscribeActions(ChefRpcActionsCallback);
+}
+
+static ChefRpcActionsWorker instance;
+
+ChefRpcActionsWorker & ChefRpcActionsWorker::Instance()
+{
+    return instance;
+}

examples/chef/common/chef-rpc-actions-worker.h

@@ -0,0 +1,79 @@
+/*
+ *
+ *    Copyright (c) 2024 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-base-server/mode-base-server.h>
+#include <app/util/config.h>
+#include <cstring>
+#include <queue>
+#include <utility>
+#include <vector>
+
+#include "Rpc.h"
+
+namespace chip {
+namespace app {
+
+class ActionsDelegate
+{
+public:
+    ActionsDelegate(ClusterId clusterId) : mClusterId(clusterId){};
+
+    virtual ~ActionsDelegate() = default;
+
+    virtual void AttributeWriteHandler(chip::EndpointId endpointId, chip::AttributeId attributeId, std::vector<uint32_t> args) = 0;
+    virtual void CommandHandler(chip::EndpointId endpointId, chip::CommandId commandId, std::vector<uint32_t> args)            = 0;
+    virtual void EventHandler(chip::EndpointId endpointId, chip::EventId eventId, std::vector<uint32_t> args)                  = 0;
+
+protected:
+    ClusterId mClusterId;
+};
+
+struct ActionTask
+{
+    chip::EndpointId endpointId;
+    chip::ClusterId clusterId;
+    chip::rpc::ActionType type; // Aligned with Storage buf
+    uint32_t delayMs;
+    uint32_t actionId;
+    std::vector<uint32_t> args;
+    ActionTask(chip::EndpointId endpoint, chip::ClusterId cluster, chip::rpc::ActionType actionType, uint32_t delay, uint32_t id,
+               std::vector<uint32_t> arg) :
+        endpointId(endpoint),
+        clusterId(cluster), type(actionType), delayMs(delay), actionId(id), args(arg){};
+    ~ActionTask(){};
+};
+
+class ChefRpcActionsWorker
+{
+public:
+    static ChefRpcActionsWorker & Instance();
+
+    ChefRpcActionsWorker();
+
+    bool EnqueueAction(ActionTask task);
+    void ProcessActionQueue();
+    void RegisterRpcActionsDelegate(ClusterId clusterId, ActionsDelegate * delegate);
+
+private:
+    std::queue<ActionTask> queue;
+};
+
+} // namespace app
+} // namespace chip