[RDKEMW-6163] [RDKEMW-6164] CEC source and sink changes

.github/workflows/L1-tests.yml

@@ -123,7 +123,7 @@ jobs:
         with:
           repository: rdkcentral/entservices-testframework
           path: entservices-testframework
-          ref: develop
+          ref: feature/RDKEMW-6167
           token: ${{ secrets.RDKCM_RDKE }}
 
       - name: Checkout entservices-inputoutput
@@ -460,8 +460,8 @@ jobs:
           -DDS_FOUND=ON
           -DHAS_FRONT_PANEL=ON
           -DRDK_SERVICES_L1_TEST=ON
-          -DPLUGIN_AVINPUT=ON
-          -DPLUGIN_HDCPPROFILE=ON
+          -DPLUGIN_AVINPUT=OFF
+          -DPLUGIN_HDCPPROFILE=OFF
           -DPLUGIN_HDMICECSOURCE=ON
           -DPLUGIN_HDMICECSINK=ON
           -DUSE_THUNDER_R4=ON

HdmiCecSink/HdmiCecSink.h

@@ -1,4 +1,4 @@
 /**
 * If not stated otherwise in this file or this component's LICENSE
 * file the following copyright and licenses apply:
 *
@@ -41,6 +41,8 @@
 #include "UtilsLogging.h"
 #include <interfaces/IPowerManager.h>
 #include "PowerManagerInterface.h"
+#include "host.hpp"
+
 
 using namespace WPEFramework;
 using PowerState = WPEFramework::Exchange::IPowerManager::PowerState;
@@ -482,7 +484,7 @@
 		// As the registration/unregistration of notifications is realized by the class PluginHost::JSONRPC,
 		// this class exposes a public method called, Notify(), using this methods, all subscribed clients
 		// will receive a JSONRPC message as a notification, in case this method is called.
-        class HdmiCecSink : public PluginHost::IPlugin, public PluginHost::JSONRPC {
+        class HdmiCecSink : public PluginHost::IPlugin, public PluginHost::JSONRPC, public device::Host::IHdmiInEvents {
 
 		enum {
 			POLL_THREAD_STATE_NONE,
@@ -530,6 +532,7 @@
             virtual const string Initialize(PluginHost::IShell* shell) override;
             virtual void Deinitialize(PluginHost::IShell* service) override;
             virtual string Information() const override { return {}; }
+            virtual void OnHdmiInEventHotPlug(dsHdmiInPort_t port, bool isConnected) override;
             static HdmiCecSink* _instance;
 			CECDeviceParams deviceList[16];
 			std::vector<HdmiPortMap> hdmiInputs;
@@ -586,6 +589,13 @@
             END_INTERFACE_MAP
 
         private:
+            template <typename T>
+            T* baseInterface()
+            {
+                static_assert(std::is_base_of<T, HdmiCecSink>(), "base type mismatch");
+                return static_cast<T*>(this);
+            }
+
             class PowerManagerNotification : public Exchange::IPowerManager::IModeChangedNotification {
             private:
                 PowerManagerNotification(const PowerManagerNotification&) = delete;

HdmiCecSource/HdmiCecSourceImplementation.cpp

@@ -1,4 +1,4 @@
 /**
 * If not stated otherwise in this file or this component's LICENSE
 * file the following copyright and licenses apply:
 *
@@ -25,7 +25,6 @@
 #include "ccec/MessageEncoder.hpp"
 #include "host.hpp"
 
-#include "dsMgr.h"
 #include "dsDisplay.h"
 #include "videoOutputPort.hpp"
 #include "manager.hpp"
@@ -389,8 +388,7 @@
                _powerManagerPlugin.Reset();
            }
            _registeredEventHandlers = false;
-
-           DeinitializeIARM();
+           device::Host::getInstance().UnRegister(baseInterface<device::Host::IDisplayDeviceEvents>());
     }
 
     Core::hresult HdmiCecSourceImplementation::Configure(PluginHost::IShell* service)
@@ -409,7 +407,6 @@
             logicalAddress = 0xFF;
 
             //CEC plugin functionalities will only work if CECmgr is available. If plugin Initialize failure upper layer will call dtor directly.
-            InitializeIARM();
             InitializePowerManager(service);
 
             // load persistence setting
@@ -418,6 +415,8 @@
             {
                 //TODO(MROLLINS) this is probably per process so we either need to be running in our own process or be carefull no other plugin is calling it
                 device::Manager::Initialize();
+                device::Host::getInstance().Register(baseInterface<device::Host::IDisplayDeviceEvents>(), "WPE::CecSource");
+
                 std::string strVideoPort = device::Host::getInstance().getDefaultVideoPortName();
                 device::VideoOutputPort vPort = device::Host::getInstance().getVideoOutputPort(strVideoPort.c_str());
                 if (vPort.isDisplayConnected())
@@ -731,20 +730,6 @@
             registerEventHandlers();
         }
 
-       const void HdmiCecSourceImplementation::InitializeIARM()
-       {
-            IARM_Result_t res;
-            IARM_CHECK( IARM_Bus_RegisterEventHandler(IARM_BUS_DSMGR_NAME,IARM_BUS_DSMGR_EVENT_HDMI_HOTPLUG, dsHdmiEventHandler) );
-       }
-
-       void HdmiCecSourceImplementation::DeinitializeIARM()
-       {
-            if (Utils::IARM::isConnected())
-            {
-                IARM_Result_t res;
-                IARM_CHECK( IARM_Bus_RemoveEventHandler(IARM_BUS_DSMGR_NAME,IARM_BUS_DSMGR_EVENT_HDMI_HOTPLUG,dsHdmiEventHandler) );
-            }
-       }
         void HdmiCecSourceImplementation::threadHotPlugEventHandler(int data)
         {
             LOGINFO("entry threadHotPlugEventHandler \r\n");
@@ -759,25 +744,21 @@
             LOGINFO("Exit threadHotPlugEventHandler \r\n");
         }
 
-       void HdmiCecSourceImplementation::dsHdmiEventHandler(const char *owner, IARM_EventId_t eventId, void *data, size_t len)
+       void HdmiCecSourceImplementation::OnDisplayHDMIHotPlug(dsDisplayEvent_t displayEvent)
        {
-            if(!HdmiCecSourceImplementation::_instance  || !_instance->cecEnableStatus)
-            {
-                LOGINFO("Return from dsHdmiEventHandler due HdmiCecSourceImplementation::_instance:%p cecEnableStatus:%d  \r\n", HdmiCecSourceImplementation::_instance, _instance->cecEnableStatus);
-                return;
-            }
+           LOGINFO("HdmiCecSourceImplementation::OnDisplayHDMIHotPlug : displayEvent = %d ", displayEvent);
+
+           if(!HdmiCecSourceImplementation::_instance  || !_instance->cecEnableStatus)
+           {
+               LOGINFO("HdmiCecSourceImplementation::OnDisplayHDMIHotPlug failed _instance:%p cecEnableStatus:%d  \r\n", HdmiCecSourceImplementation::_instance, _instance->cecEnableStatus);
+               return;
+           }
+
+           int hdmi_hotplug_event = (int) displayEvent;
+           LOGINFO("Received IARM_BUS_DSMGR_EVENT_HDMI_HOTPLUG  event data:%d \r\n", hdmi_hotplug_event);
+           std::thread worker(threadHotPlugEventHandler,hdmi_hotplug_event);
+           worker.detach();
 
-            if (owner && !strcmp(owner, IARM_BUS_DSMGR_NAME) && (IARM_BUS_DSMGR_EVENT_HDMI_HOTPLUG == eventId))
-            {
-                IARM_Bus_DSMgr_EventData_t *eventData = (IARM_Bus_DSMgr_EventData_t *)data;
-                if(eventData)
-                {
-                    int hdmi_hotplug_event = eventData->data.hdmi_hpd.event;
-                    LOGINFO("Received IARM_BUS_DSMGR_EVENT_HDMI_HOTPLUG  event data:%d \r\n", hdmi_hotplug_event);
-                    std::thread worker(threadHotPlugEventHandler,hdmi_hotplug_event);
-                    worker.detach();
-                }
-            }
        }
 
        void HdmiCecSourceImplementation::onPowerModeChanged(const PowerState currentState, const PowerState newState)

HdmiCecSource/HdmiCecSourceImplementation.h

@@ -42,6 +42,8 @@
 #include <interfaces/IPowerManager.h>
 #include "PowerManagerInterface.h"
 #include <interfaces/IHdmiCecSource.h>
+#include "host.hpp"
+
 
 using namespace WPEFramework;
 using PowerState = WPEFramework::Exchange::IPowerManager::PowerState;
@@ -170,7 +172,7 @@ namespace WPEFramework {
 		// As the registration/unregistration of notifications is realized by the class PluginHost::JSONRPC,
 		// this class exposes a public method called, Notify(), using this methods, all subscribed clients
 		// will receive a JSONRPC message as a notification, in case this method is called.
-        class HdmiCecSourceImplementation : public Exchange::IHdmiCecSource {
+        class HdmiCecSourceImplementation : public Exchange::IHdmiCecSource, public device::Host::IDisplayDeviceEvents {
 		enum {
 				VOLUME_UP     = 0x41,
 				VOLUME_DOWN   = 0x42,
@@ -196,6 +198,7 @@ namespace WPEFramework {
         public:
             HdmiCecSourceImplementation();
             virtual ~HdmiCecSourceImplementation();
+            virtual void OnDisplayHDMIHotPlug(dsDisplayEvent_t displayEvent) override;
             void onPowerModeChanged(const PowerState currentState, const PowerState newState);
             void registerEventHandlers();
             static HdmiCecSourceImplementation* _instance;
@@ -226,6 +229,13 @@ namespace WPEFramework {
 
 
         private:
+            template <typename T>
+            T* baseInterface()
+            {
+                static_assert(std::is_base_of<T, HdmiCecSourceImplementation>(), "base type mismatch");
+                return static_cast<T*>(this);
+            }
+
             class PowerManagerNotification : public Exchange::IPowerManager::IModeChangedNotification {
             private:
                 PowerManagerNotification(const PowerManagerNotification&) = delete;

Tests/L1Tests/tests/test_HdmiCecSink.cpp

@@ -34,6 +34,10 @@
 #include "RfcApiMock.h"
 #include "ThunderPortability.h"
 #include "PowerManagerMock.h"
+#include "ManagerMock.h"
+#include "HostMock.h"
+#include "HdmiInputMock.h"
+
 
 using namespace WPEFramework;
 using ::testing::NiceMock;
@@ -67,6 +71,9 @@
 class HdmiCecSinkWOInitializeTest : public ::testing::Test {
 protected:
     IarmBusImplMock         *p_iarmBusImplMock = nullptr ;
+    ManagerImplMock         *p_managerImplMock = nullptr ;
+    HostImplMock            *p_hostImplMock = nullptr ;
+    HdmiInputImplMock       *p_hdmiInputImplMock = nullptr;
     ConnectionImplMock      *p_connectionImplMock = nullptr ;
     MessageEncoderMock      *p_messageEncoderMock = nullptr ;
     LibCCECImplMock         *p_libCCECImplMock = nullptr ;
@@ -88,6 +95,15 @@
         p_iarmBusImplMock  = new NiceMock <IarmBusImplMock>;
         IarmBus::setImpl(p_iarmBusImplMock);
 
+        p_managerImplMock  = new NiceMock <ManagerImplMock>;
+        device::Manager::setImpl(p_managerImplMock);
+
+        p_hostImplMock      = new NiceMock <HostImplMock>;
+        device::Host::setImpl(p_hostImplMock);
+
+        p_hdmiInputImplMock  = new NiceMock <HdmiInputImplMock>;
+        device::HdmiInput::setImpl(p_hdmiInputImplMock);
+
         p_libCCECImplMock  = new testing::NiceMock <LibCCECImplMock>;
         LibCCEC::setImpl(p_libCCECImplMock);
 
@@ -121,15 +137,9 @@
         ON_CALL(*p_messageEncoderMock, encode(::testing::Matcher<const UserControlPressed&>(::testing::_)))
            .WillByDefault(::testing::ReturnRef(CECFrame::getInstance()));
 
-        ON_CALL(*p_iarmBusImplMock, IARM_Bus_RegisterEventHandler(::testing::_, ::testing::_, ::testing::_))
-            .WillByDefault(::testing::Invoke(
-                [&](const char* ownerName, IARM_EventId_t eventId, IARM_EventHandler_t handler) {
-                    if ((string(IARM_BUS_DSMGR_NAME) == string(ownerName)) && (eventId == IARM_BUS_DSMGR_EVENT_HDMI_IN_HOTPLUG)) {
-                        EXPECT_TRUE(handler != nullptr);
-                        dsHdmiEventHandler = handler;
-                    }
-                    return IARM_RESULT_SUCCESS;
-                }));
+        EXPECT_CALL(*p_managerImplMock, Initialize())
+            .Times(::testing::AnyNumber())
+            .WillRepeatedly(::testing::Return());
 
         ON_CALL(*p_connectionImplMock, open())
             .WillByDefault(::testing::Return());
@@ -144,6 +154,24 @@
             delete p_iarmBusImplMock;
             p_iarmBusImplMock = nullptr;
         }
+        device::Manager::setImpl(nullptr);
+        if (p_managerImplMock != nullptr)
+        {
+            delete p_managerImplMock;
+            p_managerImplMock = nullptr;
+        }
+        device::Host::setImpl(nullptr);
+        if (p_hostImplMock != nullptr)
+        {
+            delete p_hostImplMock;
+            p_hostImplMock = nullptr;
+        }
+        device::HdmiInput::setImpl(nullptr);
+        if (p_hdmiInputImplMock != nullptr)
+        {
+            delete p_hdmiInputImplMock;
+            p_hdmiInputImplMock = nullptr;
+        }
         LibCCEC::setImpl(nullptr);
         if (p_libCCECImplMock != nullptr)
         {
@@ -211,31 +239,23 @@
 
     HdmiCecSinkDsTest(): HdmiCecSinkTest()
     {
-        ON_CALL(*p_iarmBusImplMock, IARM_Bus_Call)
-            .WillByDefault(
-                [](const char* ownerName, const char* methodName, void* arg, size_t argLen) {
-                    if (strcmp(methodName, IARM_BUS_PWRMGR_API_GetPowerState) == 0) {
-                        auto* param = static_cast<IARM_Bus_PWRMgr_GetPowerState_Param_t*>(arg);
-                        param->curState  = IARM_BUS_PWRMGR_POWERSTATE_ON;
-                    }
-                    if (strcmp(methodName, IARM_BUS_DSMGR_API_dsHdmiInGetNumberOfInputs) == 0) {
-                        auto* param = static_cast<dsHdmiInGetNumberOfInputsParam_t*>(arg);
-                        param->result = dsERR_NONE;
-                        param->numHdmiInputs = 3;
-                    }
-                    if (strcmp(methodName, IARM_BUS_DSMGR_API_dsHdmiInGetStatus) == 0) {
-                        auto* param = static_cast<dsHdmiInGetStatusParam_t*>(arg);
-                        param->result = dsERR_NONE;
-                        param->status.isPortConnected[1] = 1;
-                    }
-                    if (strcmp(methodName, IARM_BUS_DSMGR_API_dsGetHDMIARCPortId) == 0) {
-                        auto* param = static_cast<dsGetHDMIARCPortIdParam_t*>(arg);
-                        param->portId = 1;
-                    }
-                    return IARM_RESULT_SUCCESS;
-                });
+        EXPECT_CALL(*p_hdmiInputImplMock, getNumberOfInputs())
+            .WillRepeatedly(::testing::Return(3));
+
+        ON_CALL(*p_hdmiInputImplMock, isPortConnected(::testing::_))
+            .WillByDefault(::testing::Invoke(
+                [](int8_t port) {
+                    return port == 1? true : false;
+                }));
+
+        ON_CALL(*p_hdmiInputImplMock, getHDMIARCPortId(::testing::_))
+            .WillByDefault(::testing::Invoke(
+                [](int &portId) {
+                    portId = 1;
+                    return dsERR_NONE;
+                }));
 
         EXPECT_EQ(Core::ERROR_NONE, handler.Invoke(connection, _T("setEnabled"), _T("{\"enabled\": true}"), response));
         EXPECT_EQ(response, string("{\"success\":true}"));
     }
     virtual ~HdmiCecSinkDsTest() override {
@@ -459,15 +479,8 @@
 TEST_F(HdmiCecSinkInitializedEventDsTest, onHdmiOutputHDCPStatusEvent)
 {
 
-    ASSERT_TRUE(dsHdmiEventHandler != nullptr);
-
-    IARM_Bus_DSMgr_EventData_t eventData;
-    eventData.data.hdmi_in_connect.port =dsHDMI_IN_PORT_1;
-    eventData.data.hdmi_in_connect.isPortConnected = true;
-
     EVENT_SUBSCRIBE(0, _T("onDevicesChanged"), _T("client.events.onDevicesChanged"), message);
-
-    dsHdmiEventHandler(IARM_BUS_DSMGR_NAME, IARM_BUS_DSMGR_EVENT_HDMI_IN_HOTPLUG, &eventData , 0);
+    plugin->OnHdmiInEventHotPlug(dsHDMI_IN_PORT_1, true);
     EVENT_UNSUBSCRIBE(0, _T("onDevicesChanged"), _T("client.events.onDevicesChanged"), message);
 
 }

Tests/L1Tests/tests/test_HdmiCecSource.cpp

@@ -1,5 +1,5 @@
 /*
  * If not stated otherwise in this file or this component's LICENSE file the
  * following copyright and licenses apply:
  *
  * Copyright 2022 RDK Management
@@ -342,29 +342,9 @@
             .WillByDefault(::testing::Return());
         ON_CALL(*p_connectionImplMock, addFrameListener(::testing::_))
             .WillByDefault(::testing::Return());
-        ON_CALL(*p_iarmBusImplMock, IARM_Bus_RegisterEventHandler(::testing::_, ::testing::_, ::testing::_))
-            .WillByDefault(::testing::Invoke(
-                [&](const char* ownerName, IARM_EventId_t eventId, IARM_EventHandler_t handler) {
-                   if ((string(IARM_BUS_CECMGR_NAME) == string(ownerName)) && (eventId == IARM_BUS_CECMGR_EVENT_DAEMON_INITIALIZED)) {
-                        EXPECT_TRUE(handler != nullptr);
-                        cecMgrEventHandler = handler;
-                    }
-                        if ((string(IARM_BUS_CECMGR_NAME) == string(ownerName)) && (eventId == IARM_BUS_CECMGR_EVENT_STATUS_UPDATED)) {
-                        EXPECT_TRUE(handler != nullptr);
-                        cecMgrEventHandler = handler;
-                    }
-                if ((string(IARM_BUS_DSMGR_NAME) == string(ownerName)) && (eventId == IARM_BUS_DSMGR_EVENT_HDMI_HOTPLUG)) {
-                        EXPECT_TRUE(handler != nullptr);
-                        dsHdmiEventHandler = handler;
-                    }
-                if ((string(IARM_BUS_PWRMGR_NAME) == string(ownerName)) && (eventId == IARM_BUS_PWRMGR_EVENT_MODECHANGED)) {
-                        EXPECT_TRUE(handler != nullptr);
-                        pwrMgrEventHandler = handler;
-                    }
-
-                    return IARM_RESULT_SUCCESS;
-                }));
-
+        EXPECT_CALL(*p_managerImplMock, Initialize())
+            .Times(::testing::AnyNumber())
+            .WillRepeatedly(::testing::Return());
     }
     virtual ~HdmiCecSourceTest() override
     {
@@ -1408,18 +1388,13 @@
         iCounter ++;
     }
 
-    ASSERT_TRUE(dsHdmiEventHandler != nullptr);
     EXPECT_CALL(*p_hostImplMock, getDefaultVideoPortName())
     .Times(1)
         .WillOnce(::testing::Return("TEST"));
 
-
-    IARM_Bus_DSMgr_EventData_t eventData;
-    eventData.data.hdmi_hpd.event = 0;
-
     EVENT_SUBSCRIBE(0, _T("onHdmiHotPlug"), _T("client.events.onHdmiHotPlug"), message);
 
-    dsHdmiEventHandler(IARM_BUS_DSMGR_NAME, IARM_BUS_DSMGR_EVENT_HDMI_HOTPLUG, &eventData , 0);
+    Plugin::HdmiCecSourceImplementation::_instance->OnDisplayHDMIHotPlug(dsDISPLAY_EVENT_CONNECTED);
 
     EVENT_UNSUBSCRIBE(0, _T("onHdmiHotPlug"), _T("client.events.onHdmiHotPlug"), message);
 }