RDK-55702: Update the MW clients to use Power Manager Plugin

scripts/remote-debugger.service

@@ -20,8 +20,8 @@
 [Unit]
 Description=RDK Remote Debugger
 
-After=tr69hostif.service
-Requires=tr69hostif.service
+After=wpeframework.service wpeframework-powermanager.service tr69hostif.service
+Requires=wpeframework.service wpeframework-powermanager.service tr69hostif.service
 
 [Service]
 Type=simple

src/rrdCommon.h

@@ -34,7 +34,11 @@ extern "C"
 #include "rdk_debug.h"
 #ifdef IARMBUS_SUPPORT
 #include "rdmMgr.h"
+#if defined(PWRMGR_PLUGIN)
+#include "power_controller.h"
+#else
 #include "pwrMgr.h"
+#endif
 #include "tr181api.h"
 #endif
 #endif

src/rrdIarmEvents.c

@@ -19,6 +19,9 @@
 
 #include "rrdInterface.h"
 #include "rrdRunCmdThread.h" 
+#if defined(PWRMGR_PLUGIN)
+#include "power_controller.h"
+#endif
 
 extern int msqid;
 extern rbusHandle_t rrdRbusHandle;
@@ -59,16 +62,94 @@ int RRD_IARM_subscribe()
         return ret;
     }
 
+#if defined(PWRMGR_PLUGIN)
+    // Thunder client library register for Deep Sleep Event Handler
+    PowerController_Init();
+    RDK_LOG(RDK_LOG_DEBUG, LOG_REMDEBUG, "[%s:%d]: completed PowerController_Init().. \n", __FUNCTION__, __LINE__);
+    ret = PowerController_RegisterPowerModeChangedCallback(_pwrManagerEventHandler, NULL);
+    if (ret != 0)
+    {
+        RDK_LOG(RDK_LOG_ERROR, LOG_REMDEBUG, "[%s:%d]: Register power mode change callback EventHandler for RDMMGR failed!!! \n ", __FUNCTION__, __LINE__);
+        return ret;
+    }
+    RDK_LOG(RDK_LOG_DEBUG, LOG_REMDEBUG, "[%s:%d]: Registered power mode change callback.. \n", __FUNCTION__, __LINE__);
+#else
     // IARM Reg for Deep Sleep Event Handler
     ret = IARM_Bus_RegisterEventHandler(IARM_BUS_PWRMGR_NAME, IARM_BUS_PWRMGR_EVENT_MODECHANGED, _pwrManagerEventHandler);
     if (ret != IARM_RESULT_SUCCESS)
     {
         RDK_LOG(RDK_LOG_ERROR, LOG_REMDEBUG, "[%s:%d]: IARM Register EventHandler for RDMMGR failed!!! \n ", __FUNCTION__, __LINE__);
         return ret;
     }
+#endif
+
     return ret;
 }
 
+#if defined(PWRMGR_PLUGIN)
+/*
+ * @function  _pwrManagerEventHandler
+ * @brief Receives the power manager event and sends the value as a message in the message-queue
+ *              to the thread function.
+ * @param
+ *        const PowerController_PowerState_t currentState - current power state.
+ *        const PowerController_PowerState_t newState - New power state.
+ *        void* userdata - user event data.
+ * Output: void
+ */
+void _pwrManagerEventHandler(const PowerController_PowerState_t currentState,
+    const PowerController_PowerState_t newState, void* userdata)
+{
+#if !defined(ENABLE_WEBCFG_FEATURE)
+    data_buf *sbuf = NULL;
+    int msgLen = strlen(DEEP_SLEEP_STR) + 1;
+#endif
+    RDK_LOG(RDK_LOG_DEBUG, LOG_REMDEBUG, "[%s:%d]: ...Entering.. currentState =%d, newState = %d\n", __FUNCTION__, __LINE__, currentState, newState);
+
+    if ((currentState == POWER_STATE_STANDBY_DEEP_SLEEP &&
+            newState != POWER_STATE_STANDBY_DEEP_SLEEP))
+    {
+        RDK_LOG(RDK_LOG_DEBUG, LOG_REMDEBUG, "[%s:%d]: Received state from Power Manager Current :[%d] New[%d] \n", __FUNCTION__, __LINE__, currentState, newState);
+#ifdef ENABLE_WEBCFG_FEATURE
+        rbusError_t rc = RBUS_ERROR_BUS_ERROR;
+        rbusValue_t value;
+	    rbusValue_Init(&value);
+        rbusValue_SetString(value,"root");
+        rc = rbus_set(rrdRbusHandle, RRD_WEBCFG_FORCE_SYNC, value, NULL);
+        if (rc != RBUS_ERROR_SUCCESS)
+        {
+            RDK_LOG(RDK_LOG_ERROR, LOG_REMDEBUG, "[%s:%d]: rbus_set failed for [%s] with error [%d]\n\n", __FUNCTION__, __LINE__,RRD_WEBCFG_FORCE_SYNC ,rc);
+            return;
+        }
+        RDK_LOG(RDK_LOG_INFO, LOG_REMDEBUG, "[%s:%d]: Invoking WebCfg Force Sync: %s... \n", __FUNCTION__, __LINE__, RRD_WEBCFG_FORCE_SYNC);
+#else
+        RDK_LOG(RDK_LOG_DEBUG, LOG_REMDEBUG, "[%s:%d]: Copying Message Received to the queue.. \n", __FUNCTION__, __LINE__);
+        sbuf = (data_buf *)malloc(sizeof(data_buf));
+        if (!sbuf)
+        {
+            RDK_LOG(RDK_LOG_DEBUG, LOG_REMDEBUG, "[%s:%d]: Memory Allocation Failed for EventId %d \n", __FUNCTION__, __LINE__, eventId);
+            return;
+        }
+
+        RRD_data_buff_init(sbuf, DEEPSLEEP_EVENT_MSG, RRD_DEEPSLEEP_RDM_DOWNLOAD_PKG_INITIATE);
+        sbuf->mdata = (char *)malloc(msgLen);
+        if (!sbuf->mdata)
+        {
+            RDK_LOG(RDK_LOG_DEBUG, LOG_REMDEBUG, "[%s:%d]: Memory Allocation Failed for EventId %d \n", __FUNCTION__, __LINE__, eventId);
+            RRD_data_buff_deAlloc(sbuf);
+            return;
+        }
+        strncpy((char *)sbuf->mdata, (const char *)DEEP_SLEEP_STR, msgLen);
+        RRDMsgDeliver(msqid, sbuf);
+#endif
+    }
+    else
+    {
+        RDK_LOG(RDK_LOG_DEBUG, LOG_REMDEBUG, "[%s:%d]: Event Triggred for DeepSleep\n", __FUNCTION__, __LINE__);
+    }
+    RDK_LOG(RDK_LOG_DEBUG, LOG_REMDEBUG, "[%s:%d]: ...Exit.. \n", __FUNCTION__, __LINE__);
+}
+#else
 /*
  * @function  _pwrManagerEventHandler
  * @brief Receives the power manager event and sends the value as a message in the message-queue
@@ -142,6 +223,7 @@ void _pwrManagerEventHandler(const char *owner, IARM_EventId_t eventId, void *da
     }
     RDK_LOG(RDK_LOG_DEBUG, LOG_REMDEBUG, "[%s:%d]: ...Exit.. \n", __FUNCTION__, __LINE__);
 }
+#endif
 
 /*
  * @function  _rdmManagerEventHandler
@@ -288,6 +370,19 @@ int RRD_IARM_unsubscribe()
         return ret;
     }
     RDK_LOG(RDK_LOG_DEBUG, LOG_REMDEBUG, "[%s:%d]: SUCCESS: IARM_Bus_UnRegisterEventHandler for RDMMGR done! \n", __FUNCTION__, __LINE__);
+
+#if defined(PWRMGR_PLUGIN)
+    // Thunder client Unregister for Deep Sleep Event Handler
+    ret = PowerController_UnRegisterPowerModeChangedCallback(_pwrManagerEventHandler);
+    if (ret != 0)
+    {
+        RDK_LOG(RDK_LOG_ERROR, LOG_REMDEBUG, "[%s:%d]: UnRegistering power mode change EventHandler for PWRMGR-plugin failed!!! \n ", __FUNCTION__, __LINE__);
+        return ret;
+    }
+    RDK_LOG(RDK_LOG_DEBUG, LOG_REMDEBUG, "[%s:%d]: SUCCESS: UnRegistering power mode change EventHandler for PWRMGR-plugin done! \n", __FUNCTION__, __LINE__);
+    PowerController_Term();
+    RDK_LOG(RDK_LOG_DEBUG, LOG_REMDEBUG, "[%s:%d]: completed PowerController_Term().. \n", __FUNCTION__, __LINE__);
+#else
     // IARM Unregister for Deep Sleep Event Handler
     ret = IARM_Bus_UnRegisterEventHandler(IARM_BUS_PWRMGR_NAME, IARM_BUS_PWRMGR_EVENT_MODECHANGED);
     if (ret != 0)
@@ -296,5 +391,6 @@ int RRD_IARM_unsubscribe()
         return ret;
     }
     RDK_LOG(RDK_LOG_DEBUG, LOG_REMDEBUG, "[%s:%d]: SUCCESS: IARM_Bus_UnRegisterEventHandler for PWRMGR done! \n", __FUNCTION__, __LINE__);
+#endif
     return ret;
 }

src/rrdInterface.h

@@ -62,8 +62,13 @@ void _remoteDebuggerWebCfgDataEventHandler(rbusHandle_t handle, rbusEvent_t cons
 int RRD_IARM_subscribe(void);
 int RRD_IARM_unsubscribe(void);
 void _rdmManagerEventHandler(const char *owner, IARM_EventId_t eventId, void *data, size_t len);
+#if defined(PWRMGR_PLUGIN)
+void _pwrManagerEventHandler(const PowerController_PowerState_t currentState,
+    const PowerController_PowerState_t newState, void* userdata);
+#else
 void _pwrManagerEventHandler(const char *owner, IARM_EventId_t eventId, void *data, size_t len);
 #endif
+#endif
 void RRD_data_buff_deAlloc(data_buf *sbuf);
 void RRDMsgDeliver(int msgqid, data_buf *sbuf);
 int RRD_subscribe(void);

src/unittest/mocks/Client_Mock.h

@@ -74,7 +74,16 @@ typedef enum _IARM_Bus_Daemon_PowerState_t
     IARM_BUS_PWRMGR_POWERSTATE_STANDBY_DEEP_SLEEP
 } IARM_Bus_PowerState_t;
 
-typedef IARM_Bus_PowerState_t IARM_Bus_PWRMgr_PowerState_t;
+typedef enum PowerController_PowerState {
+    POWER_STATE_UNKNOWN = 0 /* UNKNOWN */,
+    POWER_STATE_OFF = 1 /* OFF */,
+    POWER_STATE_STANDBY = 2 /* STANDBY */,
+    POWER_STATE_ON = 3 /* ON */,
+    POWER_STATE_STANDBY_LIGHT_SLEEP = 4 /* LIGHT_SLEEP */,
+    POWER_STATE_STANDBY_DEEP_SLEEP = 5 /* DEEP_SLEEP */
+} PowerController_PowerState_t;
+
+typedef PowerController_PowerState_t IARM_Bus_PWRMgr_PowerState_t;
 
 typedef enum _PWRMgr_EventId_t
 {

src/unittest/rrdUnitTestRunner.cpp

@@ -67,6 +67,8 @@
 #include "rrdMain.h"
 #include "rrdMain.c"
 
+#include "power_controller.h"
+
 #define GTEST_DEFAULT_RESULT_FILEPATH "/tmp/Gtest_Report/"
 #define GTEST_DEFAULT_RESULT_FILENAME "rdkRemoteDebugger_gtest_report.json"
 #define GTEST_REPORT_FILEPATH_SIZE 256
@@ -2200,7 +2202,8 @@ TEST_F(RRDUnsubscribeTest, TestRRD_Unsubscribe_Success)
     EXPECT_CALL(mock, IARM_Bus_Term()).WillOnce(::testing::Return(IARM_RESULT_SUCCESS));
     EXPECT_CALL(mock, IARM_Bus_UnRegisterEventHandler(IARM_BUS_RDK_REMOTE_DEBUGGER_NAME, IARM_BUS_RDK_REMOTE_DEBUGGER_ISSUETYPE)).WillOnce(::testing::Return(IARM_RESULT_SUCCESS));
     EXPECT_CALL(mock, IARM_Bus_UnRegisterEventHandler(IARM_BUS_RDMMGR_NAME, IARM_BUS_RDMMGR_EVENT_APP_INSTALLATION_STATUS)).WillOnce(::testing::Return(IARM_RESULT_SUCCESS));
-    EXPECT_CALL(mock, IARM_Bus_UnRegisterEventHandler(IARM_BUS_PWRMGR_NAME, IARM_BUS_PWRMGR_EVENT_MODECHANGED)).WillOnce(::testing::Return(IARM_RESULT_SUCCESS));
+    EXPECT_CALL(mock, PowerController_UnRegisterPowerModeChangedCallback(::testing::_, nullptr)).WillOnce(::testing::Return(0));
+
     IARM_Result_t result = RRD_unsubscribe();
 
     EXPECT_EQ(result, IARM_RESULT_SUCCESS);
@@ -2250,7 +2253,8 @@ TEST_F(RRDUnsubscribeTest, TestRRD_Unsubscribe_UnRegisterPwrMgrEventHandlerFailu
     EXPECT_CALL(mock, IARM_Bus_Term()).WillOnce(::testing::Return(IARM_RESULT_SUCCESS));
     EXPECT_CALL(mock, IARM_Bus_UnRegisterEventHandler(IARM_BUS_RDK_REMOTE_DEBUGGER_NAME, IARM_BUS_RDK_REMOTE_DEBUGGER_ISSUETYPE)).WillOnce(::testing::Return(IARM_RESULT_SUCCESS));
     EXPECT_CALL(mock, IARM_Bus_UnRegisterEventHandler(IARM_BUS_RDMMGR_NAME, IARM_BUS_RDMMGR_EVENT_APP_INSTALLATION_STATUS)).WillOnce(::testing::Return(IARM_RESULT_SUCCESS));
-    EXPECT_CALL(mock, IARM_Bus_UnRegisterEventHandler(IARM_BUS_PWRMGR_NAME, IARM_BUS_PWRMGR_EVENT_MODECHANGED)).WillOnce(::testing::Return(IARM_RESULT_FAILURE));
+    EXPECT_CALL(mock, PowerController_UnRegisterPowerModeChangedCallback(::testing::_, nullptr)).WillOnce(::testing::Return(0));
+
     IARM_Result_t result = RRD_unsubscribe();
 
     EXPECT_EQ(result, IARM_RESULT_FAILURE);
@@ -2645,61 +2649,52 @@ class PwrMgrEventHandlerTest : public ::testing::Test
 
 TEST_F(PwrMgrEventHandlerTest, TestInvalidOwnerName)
 {
-    const char *owner = "InvalidOwner";
-    IARM_EventId_t eventId = IARM_BUS_RDK_REMOTE_DEBUGGER_ISSUETYPE;
-    char data[] = "Test data";
-    _pwrManagerEventHandler(owner, eventId, data, sizeof(data));
+    PowerController_PowerState_t curState = -1;
+    PowerController_PowerState_t newState = -1;
+    void* userdata;
+    _pwrManagerEventHandler(curState, newState, userdata);
 }
 
 TEST_F(PwrMgrEventHandlerTest, TestCurrentStateNotDeepSleep)
 {
-    const char *owner = IARM_BUS_PWRMGR_NAME;
-    IARM_EventId_t eventId = IARM_BUS_RDK_REMOTE_DEBUGGER_ISSUETYPE;
-    IARM_Bus_PWRMgr_EventData_t eventData;
-    eventData.data.state.curState = IARM_BUS_PWRMGR_POWERSTATE_ON;
-    eventData.data.state.newState = IARM_BUS_PWRMGR_POWERSTATE_STANDBY_DEEP_SLEEP;
-    _pwrManagerEventHandler(owner, eventId, &eventData, sizeof(eventData));
+    PowerController_PowerState_t curState = POWER_STATE_ON;
+    PowerController_PowerState_t newState = POWER_STATE_STANDBY_DEEP_SLEEP;
+    void* userdata;
+    _pwrManagerEventHandler(curState, newState, userdata);
 }
 
 TEST_F(PwrMgrEventHandlerTest, TestCurrentStateDeepSleepRBusOpenFail)
 {
-    const char *owner = IARM_BUS_PWRMGR_NAME;
-    IARM_EventId_t eventId = IARM_BUS_RDK_REMOTE_DEBUGGER_ISSUETYPE;
-    IARM_Bus_PWRMgr_EventData_t eventData;
-    eventData.data.state.curState = IARM_BUS_PWRMGR_POWERSTATE_STANDBY_DEEP_SLEEP;
-    eventData.data.state.newState = IARM_BUS_PWRMGR_POWERSTATE_ON;
-    EXPECT_CALL(mock_rbus_api, rbus_open(_, _)).WillOnce(Return(RBUS_ERROR_BUS_ERROR));
-    _pwrManagerEventHandler(owner, eventId, &eventData, sizeof(eventData));
+    PowerController_PowerState_t curState = POWER_STATE_STANDBY_DEEP_SLEEP;
+    PowerController_PowerState_t newState = POWER_STATE_ON;
+    void* userdata;
+    _pwrManagerEventHandler(curState, newState, userdata);
 }
 
 TEST_F(PwrMgrEventHandlerTest, TestCurrentStateDeepSleepRBusOpenSuccessRbusSetFail)
 {
-    const char *owner = IARM_BUS_PWRMGR_NAME;
-    IARM_EventId_t eventId = IARM_BUS_RDK_REMOTE_DEBUGGER_ISSUETYPE;
-    IARM_Bus_PWRMgr_EventData_t eventData;
-    eventData.data.state.curState = IARM_BUS_PWRMGR_POWERSTATE_STANDBY_DEEP_SLEEP;
-    eventData.data.state.newState = IARM_BUS_PWRMGR_POWERSTATE_ON;
+    PowerController_PowerState_t curState = POWER_STATE_STANDBY_DEEP_SLEEP;
+    PowerController_PowerState_t newState = POWER_STATE_ON;
+    void* userdata;
 
     EXPECT_CALL(mock_rbus_api, rbus_open(_, _)).WillOnce(Return(RBUS_ERROR_SUCCESS));
     EXPECT_CALL(mock_rbus_api, rbusValue_Init(_)).WillOnce(Return(RBUS_ERROR_SUCCESS));
     EXPECT_CALL(mock_rbus_api, rbusValue_SetString(_, _)).WillOnce(Return(RBUS_ERROR_SUCCESS));
     EXPECT_CALL(mock_rbus_api, rbus_set(_, _, _, _)).WillOnce(Return(RBUS_ERROR_BUS_ERROR));
-    _pwrManagerEventHandler(owner, eventId, &eventData, sizeof(eventData));
+    _pwrManagerEventHandler(curState, newState, userdata);
 }
 
 TEST_F(PwrMgrEventHandlerTest, TestCurrentStateDeepSleepRBusOpenSuccessRbusSetSuccess)
 {
-    const char *owner = IARM_BUS_PWRMGR_NAME;
-    IARM_EventId_t eventId = IARM_BUS_RDK_REMOTE_DEBUGGER_ISSUETYPE;
-    IARM_Bus_PWRMgr_EventData_t eventData;
-    eventData.data.state.curState = IARM_BUS_PWRMGR_POWERSTATE_STANDBY_DEEP_SLEEP;
-    eventData.data.state.newState = IARM_BUS_PWRMGR_POWERSTATE_ON;
+    PowerController_PowerState_t curState = POWER_STATE_STANDBY_DEEP_SLEEP;
+    PowerController_PowerState_t newState = POWER_STATE_ON;
+    void* userdata;
 
     EXPECT_CALL(mock_rbus_api, rbus_open(_, _)).WillOnce(Return(RBUS_ERROR_SUCCESS));
     EXPECT_CALL(mock_rbus_api, rbusValue_Init(_)).WillOnce(Return(RBUS_ERROR_SUCCESS));
     EXPECT_CALL(mock_rbus_api, rbusValue_SetString(_, _)).WillOnce(Return(RBUS_ERROR_SUCCESS));
     EXPECT_CALL(mock_rbus_api, rbus_set(_, _, _, _)).WillOnce(Return(RBUS_ERROR_SUCCESS));
-    _pwrManagerEventHandler(owner, eventId, &eventData, sizeof(eventData));
+    _pwrManagerEventHandler(curState, newState, userdata);
 }
 
 /* --------------- Test RRD_subscribe() from rrdIarm --------------- */
@@ -2729,7 +2724,8 @@ TEST_F(RRDSubscribeTest, TestRRD_Subscribe_AllSuccess)
     EXPECT_CALL(mock, IARM_Bus_RegisterEventHandler(IARM_BUS_RDK_REMOTE_DEBUGGER_NAME, IARM_BUS_RDK_REMOTE_DEBUGGER_ISSUETYPE, ::testing::_)).WillOnce(::testing::Return(IARM_RESULT_SUCCESS));
     EXPECT_CALL(mock, IARM_Bus_RegisterEventHandler(IARM_BUS_RDK_REMOTE_DEBUGGER_NAME, IARM_BUS_RDK_REMOTE_DEBUGGER_WEBCFGDATA, ::testing::_)).WillOnce(::testing::Return(IARM_RESULT_SUCCESS));
     EXPECT_CALL(mock, IARM_Bus_RegisterEventHandler(IARM_BUS_RDMMGR_NAME, IARM_BUS_RDMMGR_EVENT_APP_INSTALLATION_STATUS, ::testing::_)).WillOnce(::testing::Return(IARM_RESULT_SUCCESS));
-    EXPECT_CALL(mock, IARM_Bus_RegisterEventHandler(IARM_BUS_PWRMGR_NAME, IARM_BUS_PWRMGR_EVENT_MODECHANGED, ::testing::_)).WillOnce(::testing::Return(IARM_RESULT_SUCCESS));
+    EXPECT_CALL(mock, PowerController_RegisterPowerModeChangedCallback(::testing::_, nullptr)).WillOnce(::testing::Return(0));
+
     EXPECT_CALL(mock_webconfig, register_sub_docs_mock(_, _, _, _)).Times(1);
     IARM_Result_t result = RRD_subscribe();
 
@@ -2793,7 +2789,8 @@ TEST_F(RRDSubscribeTest, TestRRD_Subscribe_PwrMgrHandlerFail)
     EXPECT_CALL(mock, IARM_Bus_RegisterEventHandler(IARM_BUS_RDK_REMOTE_DEBUGGER_NAME, IARM_BUS_RDK_REMOTE_DEBUGGER_ISSUETYPE, ::testing::_)).WillOnce(::testing::Return(IARM_RESULT_SUCCESS));
     EXPECT_CALL(mock, IARM_Bus_RegisterEventHandler(IARM_BUS_RDK_REMOTE_DEBUGGER_NAME, IARM_BUS_RDK_REMOTE_DEBUGGER_WEBCFGDATA, ::testing::_)).WillOnce(::testing::Return(IARM_RESULT_SUCCESS));
     EXPECT_CALL(mock, IARM_Bus_RegisterEventHandler(IARM_BUS_RDMMGR_NAME, IARM_BUS_RDMMGR_EVENT_APP_INSTALLATION_STATUS, ::testing::_)).WillOnce(::testing::Return(IARM_RESULT_SUCCESS));
-    EXPECT_CALL(mock, IARM_Bus_RegisterEventHandler(IARM_BUS_PWRMGR_NAME, IARM_BUS_PWRMGR_EVENT_MODECHANGED, ::testing::_)).WillOnce(::testing::Return(IARM_RESULT_FAILURE));
+    EXPECT_CALL(mock, PowerController_RegisterPowerModeChangedCallback(::testing::_, nullptr)).WillOnce(::testing::Return(0));
+
     IARM_Result_t result = RRD_subscribe();
 
     EXPECT_NE(result, IARM_RESULT_SUCCESS);