Chef RPC Actions Draft done.

TBD:
        Debug
        Optimize
        Error code
        Confirm timer is ms

Author: erwinpan1

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

@@ -47,39 +47,10 @@ ActionsDelegate * RpcFindActionsDelegate(ClusterId clusterId)
 
 static void RpcActionsTaskCallback(System::Layer * systemLayer, void * data)
 {
-    ActionTask task = ChefRpcActionsWorker::Instance().PopActionQueue();
+    ChefRpcActionsWorker * worker = (ChefRpcActionsWorker *)data;
+printf("\033[44m %s , %d \033[0m \n", __func__, __LINE__);
 
-printf("\033[41m %s , %d, endpointId=%d, clusterId=%d \033[0m \n", __func__, __LINE__, task.endpointId, task.clusterId);
-
-    ActionsDelegate * delegate = RpcFindActionsDelegate(task.clusterId);
-    if ( nullptr == delegate ) {
-      // TBD: Error cluster not registered
-        return;
-    }
-
-    ActionType type = static_cast<ActionType>(task.type);
-
-    switch (type) {
-    case ActionType::WRITE_ATTRIBUTE:
-    {
-        delegate->AttributeWriteHandler(static_cast<chip::AttributeId>(task.actionId), task.args);
-    }
-    break; 
-    case ActionType::RUN_COMMAND:
-    {
-        delegate->CommandHandler(static_cast<chip::CommandId>(task.actionId), task.args);
-    }
-    break; 
-    case ActionType::EMIT_EVENT:
-    {
-        delegate->EventHandler(static_cast<chip::EventId>(task.actionId), task.args);
-    }
-        break; 
-    default:
-        break;
-    }
-    // TBD: insert the queue t ActionHandler's queue
-//    delete queue;
+    worker->ProcessActionQueue();
 }
 
 bool ChefRpcActionsCallback(EndpointId endpointId, ClusterId clusterId, uint8_t type, uint32_t delayMs, uint32_t actionId, std::vector<uint32_t> args)
@@ -98,18 +69,57 @@ bool ChefRpcActionsWorker::EnqueueAction(ActionTask task)
         kickTimer = true;   // kick timer when the first task is adding to the queue
     }
     if (kickTimer) {
-        (void) DeviceLayer::SystemLayer().StartTimer(System::Clock::Milliseconds32(10), RpcActionsTaskCallback, this);
+        (void) DeviceLayer::SystemLayer().StartTimer(System::Clock::Milliseconds32(task.delayMs), RpcActionsTaskCallback, this);
     }
     return true;
 }
 
-ActionTask ChefRpcActionsWorker::PopActionQueue()
+void ChefRpcActionsWorker::ProcessActionQueue()
 {
-    // assert !queue.empty()
+//    delete queue;
     ActionTask task = queue.front();
     queue.pop();
 
-    return task;
+printf("\033[41m %s , %d, endpointId=%d, clusterId=%d \033[0m \n", __func__, __LINE__, task.endpointId, task.clusterId);
+
+    ActionsDelegate * delegate = RpcFindActionsDelegate(task.clusterId);
+    if ( nullptr == delegate ) {
+printf("\033[41m %s , %d, Cannot run action due to not finding delegate: endpointId=%d, clusterId=%d \033[0m \n", __func__, __LINE__, task.endpointId, task.clusterId);
+    } else {
+        ActionType type = static_cast<ActionType>(task.type);
+
+        switch (type) {
+        case ActionType::WRITE_ATTRIBUTE:
+        {
+printf("\033[41m %s , %d, Writing Attribute: %d, args size=%lu \033[0m \n", __func__, __LINE__, task.actionId, task.args.size());
+            delegate->AttributeWriteHandler(task.endpointId, static_cast<chip::AttributeId>(task.actionId), task.args);
+        }
+        break; 
+        case ActionType::RUN_COMMAND:
+        {
+printf("\033[41m %s , %d, Running Command: %d, args size=%lu \033[0m \n", __func__, __LINE__, task.actionId, task.args.size());
+            delegate->CommandHandler(task.endpointId, static_cast<chip::CommandId>(task.actionId), task.args);
+        }
+        break; 
+        case ActionType::EMIT_EVENT:
+        {
+printf("\033[41m %s , %d, Emitting Event: %d, args size=%lu \033[0m \n", __func__, __LINE__, task.actionId, 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 extra queue item to run. 
+        return;
+    }
+
+    // Run next task
+    task = queue.front();
+    (void) DeviceLayer::SystemLayer().StartTimer(System::Clock::Milliseconds32(task.delayMs), RpcActionsTaskCallback, this);
 }
 
 void ChefRpcActionsWorker::RegisterRpcActionsDelegate(ClusterId clusterId, ActionsDelegate * delegate)

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

@@ -30,18 +30,16 @@ namespace app {
 
 class ActionsDelegate
 {
-
 public:
-    ActionsDelegate(EndpointId endpoint, ClusterId cluster): mEndpointId(endpoint), mClusterId(cluster) { };
+    ActionsDelegate(ClusterId clusterId): mClusterId(clusterId) { };
 
     virtual ~ActionsDelegate() = default;
 
-    virtual void AttributeWriteHandler(chip::AttributeId attributeId, std::vector<uint32_t>args) {};
-    virtual void CommandHandler(chip::CommandId commandId, std::vector<uint32_t>args) {};
-    virtual void EventHandler(chip::EventId eventId, std::vector<uint32_t>args) {};
+    virtual void AttributeWriteHandler(chip::EndpointId endpointId, chip::AttributeId attributeId, std::vector<uint32_t>args) {};
+    virtual void CommandHandler(chip::EndpointId endpointId, chip::CommandId commandId, std::vector<uint32_t>args) {};
+    virtual void EventHandler(chip::EndpointId endpointId, chip::EventId eventId, std::vector<uint32_t>args) {};
 
 protected:
-    EndpointId mEndpointId;
     ClusterId mClusterId;
 };
 
@@ -65,7 +63,7 @@ class ChefRpcActionsWorker
     ChefRpcActionsWorker();
 
     bool EnqueueAction(ActionTask task);
-    ActionTask PopActionQueue();
+    void ProcessActionQueue();
     void RegisterRpcActionsDelegate(ClusterId clusterId, ActionsDelegate * delegate);
 
  private:

examples/chef/common/clusters/switch/SwitchEventHandler.cpp

@@ -31,61 +31,61 @@ using namespace chip::app::Clusters::Switch;
 using namespace chip::DeviceLayer;
 
 
-void SwitchEventHandler::OnSwitchLatched(uint8_t newPosition)
+void SwitchEventHandler::OnSwitchLatched(EndpointId endpointId, uint8_t newPosition)
 {
     ChipLogDetail(NotSpecified, "The latching switch is moved to a new position:%d", newPosition);
 
-    Clusters::SwitchServer::Instance().OnSwitchLatch(mEndpointId, newPosition);
+    Clusters::SwitchServer::Instance().OnSwitchLatch(endpointId, newPosition);
 }
 
-void SwitchEventHandler::OnSwitchInitialPressed(uint8_t newPosition)
+void SwitchEventHandler::OnInitialPress(EndpointId endpointId, uint8_t newPosition)
 {
     ChipLogDetail(NotSpecified, "The new position when the momentary switch starts to be pressed:%d", newPosition);
 
-    Clusters::SwitchServer::Instance().OnInitialPress(mEndpointId, newPosition);
+    Clusters::SwitchServer::Instance().OnInitialPress(endpointId, newPosition);
 }
 
-void SwitchEventHandler::OnSwitchLongPressed(uint8_t newPosition)
+void SwitchEventHandler::OnLongPress(EndpointId endpointId, uint8_t newPosition)
 {
     ChipLogDetail(NotSpecified, "The new position when the momentary switch has been pressed for a long time:%d", newPosition);
 
-    Clusters::SwitchServer::Instance().OnLongPress(mEndpointId, newPosition);
+    Clusters::SwitchServer::Instance().OnLongPress(endpointId, newPosition);
 }
 
-void SwitchEventHandler::OnSwitchShortReleased(uint8_t previousPosition)
+void SwitchEventHandler::OnShortRelease(EndpointId endpointId, uint8_t previousPosition)
 {
     ChipLogDetail(NotSpecified, "The the previous value of the CurrentPosition when the momentary switch has been released:%d",
                   previousPosition);
 
-    Clusters::SwitchServer::Instance().OnShortRelease(mEndpointId, previousPosition);
+    Clusters::SwitchServer::Instance().OnShortRelease(endpointId, previousPosition);
 }
 
-void SwitchEventHandler::OnSwitchLongReleased(uint8_t previousPosition)
+void SwitchEventHandler::OnLongRelease(EndpointId endpointId, uint8_t previousPosition)
 {
     ChipLogDetail(NotSpecified,
                   "The the previous value of the CurrentPosition when the momentary switch has been released after having been "
                   "pressed for a long time:%d",
                   previousPosition);
 
-    Clusters::SwitchServer::Instance().OnLongRelease(mEndpointId, previousPosition);
+    Clusters::SwitchServer::Instance().OnLongRelease(endpointId, previousPosition);
 }
 
-void SwitchEventHandler::OnSwitchMultiPressOngoing(uint8_t newPosition, uint8_t count)
+void SwitchEventHandler::OnMultiPressOngoing(EndpointId endpointId, uint8_t newPosition, uint8_t count)
 {
     ChipLogDetail(NotSpecified, "The new position when the momentary switch has been pressed in a multi-press sequence:%d",
                   newPosition);
     ChipLogDetail(NotSpecified, "%d times the momentary switch has been pressed", count);
 
-    Clusters::SwitchServer::Instance().OnMultiPressOngoing(mEndpointId, newPosition, count);
+    Clusters::SwitchServer::Instance().OnMultiPressOngoing(endpointId, newPosition, count);
 }
 
-void SwitchEventHandler::OnSwitchMultiPressComplete(uint8_t previousPosition, uint8_t count)
+void SwitchEventHandler::OnMultiPressComplete(EndpointId endpointId, uint8_t previousPosition, uint8_t count)
 {
     ChipLogDetail(NotSpecified, "The previous position when the momentary switch has been pressed in a multi-press sequence:%d",
                   previousPosition);
     ChipLogDetail(NotSpecified, "%d times the momentary switch has been pressed", count);
 
-    Clusters::SwitchServer::Instance().OnMultiPressComplete(mEndpointId, previousPosition, count);
+    Clusters::SwitchServer::Instance().OnMultiPressComplete(endpointId, previousPosition, count);
 }
 
 

examples/chef/common/clusters/switch/SwitchEventHandler.h

@@ -32,59 +32,50 @@ namespace Switch {
 class SwitchEventHandler
 {
 public:
-    SwitchEventHandler(EndpointId endpoint):mEndpointId(endpoint){};
+    SwitchEventHandler() {};
 
     /**
      * Should be called when the latching switch is moved to a new position.
      */
-    void OnSwitchLatched(uint8_t newPosition);
+    void OnSwitchLatched(EndpointId endpointId, uint8_t newPosition);
 
     /**
      * Should be called when the momentary switch starts to be pressed.
      */
-    void OnSwitchInitialPressed(uint8_t newPosition);
+    void OnInitialPress(EndpointId endpointId, uint8_t newPosition);
 
     /**
      * Should be called when the momentary switch has been pressed for a "long" time.
      */
-    void OnSwitchLongPressed(uint8_t newPosition);
+    void OnLongPress(EndpointId endpointId, uint8_t newPosition);
 
     /**
      * Should be called when the momentary switch has been released.
      */
-    void OnSwitchShortReleased(uint8_t previousPosition);
+    void OnShortRelease(EndpointId endpointId, uint8_t previousPosition);
 
     /**
      * Should be called when the momentary switch has been released after having been pressed for a long time.
      */
-    void OnSwitchLongReleased(uint8_t previousPosition);
+    void OnLongRelease(EndpointId endpointId, uint8_t previousPosition);
 
     /**
      * Should be called to indicate how many times the momentary switch has been pressed in a multi-press
      * sequence, during that sequence.
      */
-    void OnSwitchMultiPressOngoing(uint8_t newPosition, uint8_t count);
+    void OnMultiPressOngoing(EndpointId endpointId, uint8_t newPosition, uint8_t count);
 
     /**
      * Should be called to indicate how many times the momentary switch has been pressed in a multi-press
      * sequence, after it has been detected that the sequence has ended.
      */
-    void OnSwitchMultiPressComplete(uint8_t previousPosition, uint8_t count);
+    void OnMultiPressComplete(EndpointId endpointId, uint8_t previousPosition, uint8_t count);
 
 private:
-    EndpointId mEndpointId;
 };
 
 
 } // namespace Switch
 } // namespace Clusters
 } // namespace app
 } // namespace chip
-
-
-
-//class AllClustersCommandDelegate : public NamedPipeCommandDelegate
-//{
-//public:
-//    void OnEventCommandReceived(const char * json) override;
-//};