diff --git a/HdcpProfile/CMakeLists.txt b/HdcpProfile/CMakeLists.txt
index 9341cc08..36c7f9b5 100644
--- a/HdcpProfile/CMakeLists.txt
+++ b/HdcpProfile/CMakeLists.txt
@@ -67,7 +67,6 @@ target_link_libraries(${PLUGIN_IMPLEMENTATION} PRIVATE ${NAMESPACE}Protocols::${
 endif (USE_THUNDER_R4)
 
 find_package(DS)
-find_package(IARMBus)
 find_package(CEC)
 
 if (RDK_SERVICE_L2_TEST)
@@ -82,14 +81,13 @@ if (RDK_SERVICE_L2_TEST)
 endif()
 
 
-target_include_directories(${PLUGIN_IMPLEMENTATION} PRIVATE ${IARMBUS_INCLUDE_DIRS})
 target_include_directories(${PLUGIN_IMPLEMENTATION} PRIVATE ${DS_INCLUDE_DIRS})
 target_include_directories(${PLUGIN_IMPLEMENTATION} PRIVATE ../helpers)
 
 
 set_source_files_properties(HdcpProfile.cpp PROPERTIES COMPILE_FLAGS "-fexceptions")
 
-target_link_libraries(${PLUGIN_IMPLEMENTATION} PUBLIC ${NAMESPACE}Plugins::${NAMESPACE}Plugins ${IARMBUS_LIBRARIES} ${DS_LIBRARIES})
+target_link_libraries(${PLUGIN_IMPLEMENTATION} PUBLIC ${NAMESPACE}Plugins::${NAMESPACE}Plugins ${DS_LIBRARIES})
 
 install(TARGETS ${PLUGIN_IMPLEMENTATION}
         DESTINATION lib/${STORAGE_DIRECTORY}/plugins)
diff --git a/HdcpProfile/HdcpProfileImplementation.cpp b/HdcpProfile/HdcpProfileImplementation.cpp
index 69b55a21..3c12d471 100644
--- a/HdcpProfile/HdcpProfileImplementation.cpp
+++ b/HdcpProfile/HdcpProfileImplementation.cpp
@@ -23,14 +23,9 @@
  
  #include "videoOutputPort.hpp"
  #include "videoOutputPortConfig.hpp"
- #include "dsMgr.h"
  #include "manager.hpp"
- #include "host.hpp"
  
  #include "UtilsJsonRpc.h"
- #include "UtilsIarm.h"
- 
- #include "UtilsSynchroIarm.hpp"
  
  #define HDMI_HOT_PLUG_EVENT_CONNECTED 0
  #define HDMI_HOT_PLUG_EVENT_DISCONNECTED 1
@@ -61,6 +56,8 @@
          HdcpProfileImplementation::~HdcpProfileImplementation()
          {
              LOGINFO("Call HdcpProfileImplementation destructor\n");
+             device::Host::getInstance().UnRegister(baseInterface<device::Host::IVideoOutputPortEvents>());
+             device::Host::getInstance().UnRegister(baseInterface<device::Host::IDisplayDeviceEvents>());
              if (_powerManagerPlugin) {
                 _powerManagerPlugin.Reset();
              }
@@ -68,7 +65,6 @@
              {
                 _service->Release();
              }
-             DeinitializeIARM();
              HdcpProfileImplementation::_instance = nullptr;
              mShell = nullptr;
          }
@@ -82,26 +78,7 @@
                                      .createInterface();
          }
  
-         void HdcpProfileImplementation::InitializeIARM()
-         {
-             Utils::IARM::init();
- 
-             IARM_Result_t res;
-             IARM_CHECK( Utils::Synchro::RegisterLockedIarmEventHandler<HdcpProfileImplementation>(IARM_BUS_DSMGR_NAME,IARM_BUS_DSMGR_EVENT_HDMI_HOTPLUG, dsHdmiEventHandler) );
-             IARM_CHECK( Utils::Synchro::RegisterLockedIarmEventHandler<HdcpProfileImplementation>(IARM_BUS_DSMGR_NAME,IARM_BUS_DSMGR_EVENT_HDCP_STATUS, dsHdmiEventHandler) );
-         }
- 
-         void HdcpProfileImplementation::DeinitializeIARM()
-         {
-             if (Utils::IARM::isConnected())
-             {
-                 IARM_Result_t res;
-                 IARM_CHECK( Utils::Synchro::RemoveLockedEventHandler<HdcpProfileImplementation>(IARM_BUS_DSMGR_NAME,IARM_BUS_DSMGR_EVENT_HDMI_HOTPLUG, dsHdmiEventHandler) );
-                 IARM_CHECK( Utils::Synchro::RemoveLockedEventHandler<HdcpProfileImplementation>(IARM_BUS_DSMGR_NAME,IARM_BUS_DSMGR_EVENT_HDCP_STATUS, dsHdmiEventHandler) );
-             }
-         }
- 
-         void HdcpProfileImplementation::onHdmiOutputHotPlug(int connectStatus)
+         void HdcpProfileImplementation::onHdmiOutputHotPlug(dsDisplayEvent_t connectStatus)
          {
              if (HDMI_HOT_PLUG_EVENT_CONNECTED == connectStatus)
              {
@@ -137,49 +114,39 @@
                      status.hdcpReason);
         }
  
-         void HdcpProfileImplementation::onHdmiOutputHDCPStatusEvent(int hdcpStatus)
+         void HdcpProfileImplementation::onHdmiOutputHDCPStatusEvent(dsHdcpStatus_t hdcpStatus)
          {
              LOGINFO("hdcpStatus[%d]",hdcpStatus);
              onHdcpProfileDisplayConnectionChanged();
          }
  
-         void HdcpProfileImplementation::dsHdmiEventHandler(const char *owner, IARM_EventId_t eventId, void *data, size_t len)
+         void HdcpProfileImplementation::OnDisplayHDMIHotPlug(dsDisplayEvent_t displayEvent)
+         {
+             LOGINFO("Received OnDisplayHDMIHotPlug  event data:%d \r\n", displayEvent);
+             HdcpProfileImplementation::_instance->onHdmiOutputHotPlug(displayEvent);
+         }
+
+         void HdcpProfileImplementation::OnHDCPStatusChange(dsHdcpStatus_t hdcpStatus)
          {
              uint32_t res = Core::ERROR_GENERAL;
              PowerState pwrStateCur = WPEFramework::Exchange::IPowerManager::POWER_STATE_UNKNOWN;
              PowerState pwrStatePrev = WPEFramework::Exchange::IPowerManager::POWER_STATE_UNKNOWN;
- 
-             if(!HdcpProfileImplementation::_instance)
-                 return;
- 
-             if (IARM_BUS_DSMGR_EVENT_HDMI_HOTPLUG == eventId)
-             {
-                 IARM_Bus_DSMgr_EventData_t *eventData = (IARM_Bus_DSMgr_EventData_t *)data;
-                 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);
- 
-                 HdcpProfileImplementation::_instance->onHdmiOutputHotPlug(hdmi_hotplug_event);
-             }
-             else if (IARM_BUS_DSMGR_EVENT_HDCP_STATUS == eventId)
-             {
-                 ASSERT (_powerManagerPlugin);
-                 if (_powerManagerPlugin){
-                     res = _powerManagerPlugin->GetPowerState(pwrStateCur, pwrStatePrev);
-                     if (Core::ERROR_NONE != res)
-                     {
-                         LOGWARN("Failed to Invoke RPC method: GetPowerState");
-                     }
-                     else
-                     {
-                         IARM_Bus_DSMgr_EventData_t *eventData = (IARM_Bus_DSMgr_EventData_t *)data;
-                         int hdcpStatus = eventData->data.hdmi_hdcp.hdcpStatus;
-                         LOGINFO("Received IARM_BUS_DSMGR_EVENT_HDCP_STATUS  event data:%d  param.curState: %d \r\n", hdcpStatus,pwrStateCur);
-                         HdcpProfileImplementation::_instance->onHdmiOutputHDCPStatusEvent(hdcpStatus);
-                     }
+
+             ASSERT (_powerManagerPlugin);
+             if (_powerManagerPlugin){
+                 res = _powerManagerPlugin->GetPowerState(pwrStateCur, pwrStatePrev);
+                 if (Core::ERROR_NONE != res)
+                 {
+                     LOGWARN("Failed to Invoke RPC method: GetPowerState");
+                 }
+                 else
+                 {
+                     LOGINFO("Received OnHDCPStatusChange  event data:%d  param.curState: %d \r\n", hdcpStatus,pwrStateCur);
+                     HdcpProfileImplementation::_instance->onHdmiOutputHDCPStatusEvent(hdcpStatus);
                  }
              }
          }
- 
+
          /**
           * Register a notification callback
           */
@@ -243,7 +210,8 @@
              _service = service;
              _service->AddRef();
              ASSERT(service != nullptr);
-             InitializeIARM();
+             device::Host::getInstance().Register(baseInterface<device::Host::IVideoOutputPortEvents>(),"WPE::HdcpProfile");
+             device::Host::getInstance().Register(baseInterface<device::Host::IDisplayDeviceEvents>(),"WPE::HdcpProfile");
              InitializePowerManager(service);
              return result;
          }
diff --git a/HdcpProfile/HdcpProfileImplementation.h b/HdcpProfile/HdcpProfileImplementation.h
index 8e0530d4..ea916e43 100644
--- a/HdcpProfile/HdcpProfileImplementation.h
+++ b/HdcpProfile/HdcpProfileImplementation.h
@@ -29,9 +29,9 @@
  #include <core/core.h>
  #include <mutex>
  #include <vector>
- 
- #include "libIBus.h"
- 
+
+#include "host.hpp"
+
  #include "PowerManagerInterface.h"
  
  namespace WPEFramework
@@ -39,14 +39,17 @@
      namespace Plugin
      {
          
-         class HdcpProfileImplementation : public Exchange::IHdcpProfile, public Exchange::IConfiguration
+         class HdcpProfileImplementation : public Exchange::IHdcpProfile, public Exchange::IConfiguration, public device::Host::IVideoOutputPortEvents, public device::Host::IDisplayDeviceEvents
          // , public Exchange::IConfiguration
          {
          public:
              // We do not allow this plugin to be copied !!
              HdcpProfileImplementation();
              ~HdcpProfileImplementation() override;
- 
+
+             virtual void OnDisplayHDMIHotPlug(dsDisplayEvent_t displayEvent) override;
+             virtual void OnHDCPStatusChange(dsHdcpStatus_t hdcpStatus) override;
+
              static HdcpProfileImplementation *instance(HdcpProfileImplementation *HdcpProfileImpl = nullptr);
  
              // We do not allow this plugin to be copied !!
@@ -110,6 +113,13 @@
              
  
          public:
+            template <typename T>
+            T* baseInterface()
+            {
+                static_assert(std::is_base_of<T, HdcpProfileImplementation>(), "base type mismatch");
+                return static_cast<T*>(this);
+            }
+
              Core::hresult Register(Exchange::IHdcpProfile::INotification *notification) override;
              Core::hresult Unregister(Exchange::IHdcpProfile::INotification *notification) override;
  
@@ -117,11 +127,8 @@
              Core::hresult GetSettopHDCPSupport(string& supportedHDCPVersion,bool& isHDCPSupported,bool& success) override;
              bool GetHDCPStatusInternal(HDCPStatus& hdcpstatus);
              void InitializePowerManager(PluginHost::IShell *service);
-             void InitializeIARM();
-             void DeinitializeIARM();
-             static void dsHdmiEventHandler(const char *owner, IARM_EventId_t eventId, void *data, size_t len);
-             void onHdmiOutputHotPlug(int connectStatus);
-             void onHdmiOutputHDCPStatusEvent(int);
+             void onHdmiOutputHotPlug(dsDisplayEvent_t connectStatus);
+             void onHdmiOutputHDCPStatusEvent(dsHdcpStatus_t);
              void logHdcpStatus (const char *trigger, HDCPStatus& status);   
              void onHdcpProfileDisplayConnectionChanged();  
              static PowerManagerInterfaceRef _powerManagerPlugin;      
@@ -143,4 +150,4 @@
          };
  
      } // namespace Plugin
- } // namespace WPEFramework
\ No newline at end of file
+ } // namespace WPEFramework