Handle review comments

arun-silabs · arun-silabs · commit daebfbd00528 · 2025-11-04T15:51:30.000+05:30
diff --git a/examples/oven-app/silabs/include/AppEvent.h b/examples/oven-app/silabs/include/AppEvent.h
@@ -29,6 +29,7 @@ struct AppEvent : public BaseAppEvent
         kEventType_CookTop,
         kEventType_CookSurface,
         kEventType_Install,
+        kEventType_UIUpdate,
     };
 
     union
diff --git a/examples/oven-app/silabs/include/AppTask.h b/examples/oven-app/silabs/include/AppTask.h
@@ -82,22 +82,10 @@ class AppTask : public BaseApplication
 private:
     static AppTask sAppTask;
 
-    static void ActionInitiated(OvenManager::Action_t aAction, int32_t aActor, uint8_t * value);
-    static void ActionCompleted(OvenManager::Action_t aAction);
-
     /**
      * @brief Override of BaseApplication::AppInit() virtual method, called by BaseApplication::Init()
      *
      * @return CHIP_ERROR
      */
     CHIP_ERROR AppInit() override;
-
-    /**
-     * @brief PB0 Button event processing function
-     *        Press and hold will trigger a factory reset timer start
-     *        Press and release will restart BLEAdvertising if not commissioned
-     *
-     * @param aEvent button event being processed
-     */
-    static void ButtonHandler(AppEvent * aEvent);
 };
diff --git a/examples/oven-app/silabs/include/OvenManager.h b/examples/oven-app/silabs/include/OvenManager.h
@@ -43,35 +43,15 @@
 
 class OvenManager
 {
-public:
-    enum Action_t
-    {
-        ON_ACTION = 0,
-        OFF_ACTION,
-
-        INVALID_ACTION
-    } Action;
 
+public:
     enum State_t
     {
-        kCookTopState_OffInitiated = 0,
-        kCookTopState_OffCompleted,
-        kCookTopState_OnInitiated,
-        kCookTopState_OnCompleted,
-
-        // Cook Surface states
-        kCookSurfaceState_OffInitiated,
-        kCookSurfaceState_OffCompleted,
-        kCookSurfaceState_OnInitiated,
-        kCookSurfaceState_OnCompleted,
-        kCookSurfaceState_ActionInProgress,
-        kCookSurfaceState_NoAction,
-    } State;
-
-    bool InitiateAction(int32_t aActor, Action_t aAction, uint8_t * aValue, chip::EndpointId endpointId = kCookTopEndpoint);
-    typedef void (*Callback_fn_initiated)(Action_t, int32_t aActor, uint8_t * value);
-    typedef void (*Callback_fn_completed)(Action_t);
-    void SetCallbacks(Callback_fn_initiated aActionInitiated_CB, Callback_fn_completed aActionCompleted_CB);
+        kCookTopState_Off = 0,
+        kCookTopState_On,
+        kCookSurfaceState_Off,
+        kCookSurfaceState_On
+    };
 
     /**
      * @brief Initializes the OvenManager and its associated resources.
@@ -152,10 +132,12 @@ class OvenManager
     State_t mCookSurfaceState1;
     State_t mCookSurfaceState2;
 
-    Callback_fn_initiated mActionInitiated_CB;
-    Callback_fn_completed mActionCompleted_CB;
-
-    static void ActuatorMovementHandler(AppEvent * aEvent);
+    /**
+     * @brief Updates the oven hardware state and UI (LEDs, LCD) in response to an event.
+     *
+     * @param aEvent Pointer to the event structure.
+     */
+    static void OvenActionHandler(AppEvent * aEvent);
 
     // Define the endpoint ID for the Oven
     static constexpr chip::EndpointId kOvenEndpoint                         = 1;
diff --git a/examples/oven-app/silabs/src/AppTask.cpp b/examples/oven-app/silabs/src/AppTask.cpp
@@ -72,7 +72,6 @@ CHIP_ERROR AppTask::AppInit()
 
     // Initialization of Oven Manager and endpoints of oven.
     OvenManager::GetInstance().Init();
-    OvenManager::GetInstance().SetCallbacks(ActionInitiated, ActionCompleted);
 // Update the LCD with the Stored value. Show QR Code if not provisioned
 #ifdef DISPLAY_ENABLED
     GetLCD().WriteDemoUI(false);
@@ -130,47 +129,3 @@ void AppTask::ButtonEventHandler(uint8_t button, uint8_t btnAction)
     AppTask::GetAppTask().PostEvent(&button_event);
 }
 
-void AppTask::ActionInitiated(OvenManager::Action_t aAction, int32_t aActor, uint8_t * aValue)
-{
-    if (aActor == AppEvent::kEventType_CookTop)
-    {
-        bool lightOn = aAction == OvenManager::ON_ACTION;
-        ChipLogProgress(AppServer, "Turning CookTop %s", (lightOn) ? "On" : "Off");
-
-        // TODO: Update LED state
-
-#ifdef DISPLAY_ENABLED
-        sAppTask.GetLCD().WriteDemoUI(lightOn);
-#endif
-    }
-
-    if (aActor == AppEvent::kEventType_CookSurface)
-    {
-        bool lightOn = aAction == OvenManager::ON_ACTION;
-        ChipLogProgress(AppServer, "Turning CookSurface %s", (lightOn) ? "On" : "Off");
-    }
-
-    if (aActor == AppEvent::kEventType_Button)
-    {
-        sAppTask.mSyncClusterToButtonAction = true;
-    }
-}
-
-void AppTask::ActionCompleted(OvenManager::Action_t aAction)
-{
-    // Action has been completed on the oven
-    if (aAction == OvenManager::ON_ACTION)
-    {
-        ChipLogProgress(AppServer, "ON action completed");
-    }
-    else if (aAction == OvenManager::OFF_ACTION)
-    {
-        ChipLogProgress(AppServer, "OFF action completed");
-    }
-
-    if (sAppTask.mSyncClusterToButtonAction)
-    {
-        // TODO: Schedule work to Update CookTop and CookSurfaceEndpoints (turn on/off)
-        sAppTask.mSyncClusterToButtonAction = false;
-    }
-}
diff --git a/examples/oven-app/silabs/src/OvenManager.cpp b/examples/oven-app/silabs/src/OvenManager.cpp
@@ -47,9 +47,9 @@ void OvenManager::Init()
     DeviceLayer::PlatformMgr().LockChipStack();
 
     // Initialize states
-    mCookTopState      = kCookTopState_OffCompleted;
-    mCookSurfaceState1 = kCookSurfaceState_OffCompleted;
-    mCookSurfaceState2 = kCookSurfaceState_OffCompleted;
+    mCookTopState      = kCookTopState_Off;
+    mCookSurfaceState1 = kCookSurfaceState_Off;
+    mCookSurfaceState2 = kCookSurfaceState_Off;
 
     // Endpoint initializations
     VerifyOrReturn(mOvenEndpoint.Init() == CHIP_NO_ERROR, ChipLogError(AppServer, "OvenEndpoint Init failed"));
@@ -90,10 +90,6 @@ void OvenManager::Init()
 
     VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(AppServer, "RegisterSupportedLevels failed for CookSurfaceEndpoint2"));
 
-    // Get CookTop On/Off value
-    // OnOffServer::Instance().getOnOffValue(1, &currentLedState);
-    // mCookTopState                 = currentLedState ? kState_OnCompleted : kState_OffCompleted;
-
     DeviceLayer::PlatformMgr().UnlockChipStack();
 }
 
@@ -153,193 +149,56 @@ void OvenManager::OnOffAttributeChangeHandler(EndpointId endpointId, AttributeId
     switch (endpointId)
     {
     case kCookTopEndpoint:
-        InitiateAction(AppEvent::kEventType_CookTop, *value ? OvenManager::ON_ACTION : OvenManager::OFF_ACTION, value,
-                       kCookTopEndpoint);
-        // Update CookSurface states accordingly
+        mCookTopState = (*value != 0) ? kCookTopState_On : kCookTopState_Off;
+        // Turn on/off the associated cook surfaces.
         mCookSurfaceEndpoint1.SetOnOffState(*value);
         mCookSurfaceEndpoint2.SetOnOffState(*value);
         break;
     case kCookSurfaceEndpoint1:
     case kCookSurfaceEndpoint2:
-        // Handle On/Off attribute changes for the cook surface endpoints
-        InitiateAction(AppEvent::kEventType_CookSurface, *value ? OvenManager::ON_ACTION : OvenManager::OFF_ACTION, value,
-                       endpointId);
+        if (endpointId == kCookSurfaceEndpoint1)
+            mCookSurfaceState1 = (*value != 0) ? kCookSurfaceState_On : kCookSurfaceState_Off;
+        else
+            mCookSurfaceState2 = (*value != 0) ? kCookSurfaceState_On : kCookSurfaceState_Off;
+
+        bool cookSurfaceEndpoint1State;
+        bool cookSurfaceEndpoint2State;
+        mCookSurfaceEndpoint1.GetOnOffState(cookSurfaceEndpoint1State);
+        mCookSurfaceEndpoint2.GetOnOffState(cookSurfaceEndpoint2State);
+        // Turn off CookTop if both the CookSurfaces are off.
+        if (!cookSurfaceEndpoint1State && !cookSurfaceEndpoint2State)
         {
-            bool cookSurfaceEndpoint1State;
-            bool cookSurfaceEndpoint2State;
-            mCookSurfaceEndpoint1.GetOnOffState(cookSurfaceEndpoint1State);
-            mCookSurfaceEndpoint2.GetOnOffState(cookSurfaceEndpoint2State);
-            // Check if both cooksurfaces are off. If yes, turn off the cooktop (call cooktop.TurnOffCookTop)
-            if (cookSurfaceEndpoint1State == false && cookSurfaceEndpoint2State == false)
-            {
-                mCookTopEndpoint.SetOnOffState(false);
-            }
+            mCookTopEndpoint.SetOnOffState(false);
+            mCookTopState = kCookTopState_Off;
         }
         break;
     default:
         break;
     }
+
+    // Post an event to AppTask for the hardware actions (like LCD and LED update).
+    AppEvent event = {};
+    event.Type = AppEvent::kEventType_UIUpdate;
+    event.Handler = OvenActionHandler;
+    AppTask::GetAppTask().PostEvent(&event);
 }
 
 void OvenManager::OvenModeAttributeChangeHandler(chip::EndpointId endpointId, chip::AttributeId attributeId, uint8_t * value,
                                                  uint16_t size)
 {
     VerifyOrReturn(endpointId == kTemperatureControlledCabinetEndpoint,
                    ChipLogError(AppServer, "Command received over Unsupported Endpoint"));
-    // TODO: Update the LCD with the new Oven Mode
+    // Post an event to AppTask for the hardware actions (like LCD and LED update).
+    AppEvent event = {};
+    event.Type = AppEvent::kEventType_UIUpdate;
+    event.Handler = OvenActionHandler;
+    AppTask::GetAppTask().PostEvent(&event);
     return;
 }
 
-void OvenManager::SetCallbacks(Callback_fn_initiated aActionInitiated_CB, Callback_fn_completed aActionCompleted_CB)
+void OvenManager::OvenActionHandler(AppEvent * aEvent)
 {
-    mActionInitiated_CB = aActionInitiated_CB;
-    mActionCompleted_CB = aActionCompleted_CB;
-}
-
-bool OvenManager::InitiateAction(int32_t aActor, Action_t aAction, uint8_t * aValue, chip::EndpointId endpointId)
-{
-    bool action_initiated = false;
-    State_t new_state;
-    State_t * currentState = nullptr;
-    uint8_t eventType;
-
-    // Determine which state to manage based on endpoint
-    if (endpointId == kCookTopEndpoint)
-    {
-        currentState = &mCookTopState;
-        eventType    = AppEvent::kEventType_CookTop;
-    }
-    else if (endpointId == kCookSurfaceEndpoint1)
-    {
-        currentState = &mCookSurfaceState1;
-        eventType    = AppEvent::kEventType_CookSurface;
-    }
-    else if (endpointId == kCookSurfaceEndpoint2)
-    {
-        currentState = &mCookSurfaceState2;
-        eventType    = AppEvent::kEventType_CookSurface;
-    }
-    else
-    {
-        return false; // Invalid endpoint
-    }
-
-    // Determine the appropriate state transitions based on endpoint type
-    if (endpointId == kCookTopEndpoint)
-    {
-        // CookTop state transitions
-        if (*currentState == kCookTopState_OffCompleted && aAction == ON_ACTION)
-        {
-            action_initiated = true;
-            new_state        = kCookTopState_OnInitiated;
-        }
-        else if (*currentState == kCookTopState_OnCompleted && aAction == OFF_ACTION)
-        {
-            action_initiated = true;
-            new_state        = kCookTopState_OffInitiated;
-        }
-    }
-    else
-    {
-        // CookSurface state transitions
-        if (*currentState == kCookSurfaceState_OffCompleted && aAction == ON_ACTION)
-        {
-            action_initiated = true;
-            new_state        = kCookSurfaceState_OnInitiated;
-        }
-        else if (*currentState == kCookSurfaceState_OnCompleted && aAction == OFF_ACTION)
-        {
-            action_initiated = true;
-            new_state        = kCookSurfaceState_OffInitiated;
-        }
-    }
-
-    if (action_initiated && (aAction == ON_ACTION || aAction == OFF_ACTION))
-    {
-        *currentState = new_state;
-
-        AppEvent event;
-        event.Type              = eventType;
-        event.OvenEvent.Context = this;
-        event.OvenEvent.Action  = aAction;
-        event.OvenEvent.Actor   = endpointId; // Store endpoint ID in Actor field
-        event.Handler           = ActuatorMovementHandler;
-
-        AppTask::GetAppTask().PostEvent(&event);
-    }
-
-    if (action_initiated && mActionInitiated_CB)
-    {
-        mActionInitiated_CB(aAction, aActor, aValue);
-    }
-
-    return action_initiated;
-}
-
-void OvenManager::ActuatorMovementHandler(AppEvent * aEvent)
-{
-    Action_t actionCompleted = INVALID_ACTION;
-    OvenManager * oven       = static_cast<OvenManager *>(aEvent->OvenEvent.Context);
-
-    switch (aEvent->Type)
-    {
-    case AppEvent::kEventType_CookTop: {
-        // Handle CookTop state transitions
-        if (oven->mCookTopState == kCookTopState_OffInitiated)
-        {
-            oven->mCookTopState = kCookTopState_OffCompleted;
-            actionCompleted     = OFF_ACTION;
-        }
-        else if (oven->mCookTopState == kCookTopState_OnInitiated)
-        {
-            oven->mCookTopState = kCookTopState_OnCompleted;
-            actionCompleted     = ON_ACTION;
-        }
-    }
-    break;
-    case AppEvent::kEventType_CookSurface: {
-        // Handle CookSurface state transitions
-        chip::EndpointId endpointId = static_cast<chip::EndpointId>(aEvent->OvenEvent.Actor);
-        State_t * currentState      = nullptr;
-
-        // Get the appropriate state pointer based on endpoint
-        if (endpointId == kCookSurfaceEndpoint1)
-        {
-            currentState = &oven->mCookSurfaceState1;
-        }
-        else if (endpointId == kCookSurfaceEndpoint2)
-        {
-            currentState = &oven->mCookSurfaceState2;
-        }
-        else
-        {
-            ChipLogError(AppServer, "Invalid CookSurface endpoint ID");
-            return; // Invalid endpoint
-        }
-
-        if (*currentState == kCookSurfaceState_OffInitiated)
-        {
-            *currentState   = kCookSurfaceState_OffCompleted;
-            actionCompleted = OFF_ACTION;
-        }
-        else if (*currentState == kCookSurfaceState_OnInitiated)
-        {
-            *currentState   = kCookSurfaceState_OnCompleted;
-            actionCompleted = ON_ACTION;
-        }
-    }
-    break;
-    default:
-        break;
-    }
-
-    if (actionCompleted != INVALID_ACTION)
-    {
-        if (oven->mActionCompleted_CB)
-        {
-            oven->mActionCompleted_CB(actionCompleted);
-        }
-    }
+    // TODO: hardware Action : Update the LEDs and LCD of oven-app as required.
 }
 
 bool OvenManager::IsTransitionBlocked(uint8_t fromMode, uint8_t toMode)
