fix distributed screen process crash bug

Signed-off-by: sxzheng96 <zhengshuangxi2@huawei.com>

screenhandler/include/dscreen_handler.h

@@ -23,25 +23,32 @@
 
 namespace OHOS {
 namespace DistributedHardware {
-class DScreenHandler : public IHardwareHandler, public Rosen::ScreenManager::IScreenListener {
-DECLARE_SINGLE_INSTANCE_BASE(DScreenHandler);
+class ScreenListener : public Rosen::ScreenManager::IScreenListener {
 public:
     void OnConnect(uint64_t screenId) override;
     void OnDisconnect(uint64_t screenId) override;
     void OnChange(uint64_t screenId) override {};
+};
+
+class DScreenHandler : public IHardwareHandler, public Rosen::ScreenManager::IScreenListener {
+DECLARE_SINGLE_INSTANCE_BASE(DScreenHandler);
+public:
     int32_t Initialize() override;
     std::vector<DHItem> Query() override;
     std::map<std::string, std::string> QueryExtraInfo() override;
     bool IsSupportPlugin() override;
     void RegisterPluginListener(std::shared_ptr<PluginListener> listener) override;
+    void PluginHardware(const std::string &dhId, const std::string &attr);
+    void UnPluginHardware(const std::string &dhId);
+    std::string QueryCodecInfo();
 
 private:
     DScreenHandler();
     ~DScreenHandler();
-    std::string QueryCodecInfo();
 
     std::shared_ptr<PluginListener> listener_ = nullptr;
     std::string codecInfoStr_;
+    sptr<ScreenListener> screenListener_ = nullptr;
 };
 
 #ifdef __cplusplus

screenhandler/src/dscreen_handler.cpp

@@ -39,26 +39,36 @@ DScreenHandler::DScreenHandler()
 DScreenHandler::~DScreenHandler()
 {
     DHLOGI("~DScreenHandler");
+    Rosen::ScreenManager::GetInstance().UnregisterScreenListener(screenListener_);
 }
 
 int32_t DScreenHandler::Initialize()
 {
     DHLOGI("DScreenHandler Initialize");
-    bool ret = Rosen::ScreenManager::GetInstance().RegisterScreenListener(this);
+    if (!screenListener_) {
+        screenListener_ = new ScreenListener();
+    }
+    bool ret = Rosen::ScreenManager::GetInstance().RegisterScreenListener(screenListener_);
     if (!ret) {
         DHLOGE("register screen listener failed.");
     }
     return DH_SUCCESS;
 }
 
-void DScreenHandler::OnConnect(uint64_t screenId)
+void ScreenListener::OnConnect(uint64_t screenId)
 {
     DHLOGI("on screen connect");
     if (screenId != SCREEN_ID_DEFAULT) {
         return;
     }
-    std::string dhId = DSCREEN_PREFIX + SEPERATOR + std::to_string(screenId);
     sptr<Rosen::Screen> screen = Rosen::ScreenManager::GetInstance().GetScreenById(screenId);
+    if (screen == nullptr) {
+        DHLOGE("screen not found, screenId: %ulld", screenId);
+        return;
+    }
+
+    std::string dhId = DSCREEN_PREFIX + SEPERATOR + std::to_string(screenId);
+
     uint32_t screenWidth = screen->GetWidth();
     uint32_t screenHeight = screen->GetHeight();
 
@@ -66,17 +76,27 @@ void DScreenHandler::OnConnect(uint64_t screenId)
     attrJson[KEY_VERSION] = DSCREEN_VERSION;
     attrJson[KEY_SCREEN_WIDTH] = screenWidth;
     attrJson[KEY_SCREEN_HEIGHT] = screenHeight;
-    attrJson[KEY_CODECTYPE] = QueryCodecInfo();
+    attrJson[KEY_CODECTYPE] = DScreenHandler::GetInstance().QueryCodecInfo();
 
-    if (listener_ != nullptr) {
-        listener_->PluginHardware(dhId, attrJson.dump());
-    }
+    DScreenHandler::GetInstance().PluginHardware(dhId, attrJson.dump());
 }
 
-void DScreenHandler::OnDisconnect(uint64_t screenId)
+void ScreenListener::OnDisconnect(uint64_t screenId)
 {
     DHLOGI("on screen disconnect");
     std::string dhId = DSCREEN_PREFIX + SEPERATOR + std::to_string(screenId);
+    DScreenHandler::GetInstance().UnPluginHardware(dhId);
+}
+
+void DScreenHandler::PluginHardware(const std::string &dhId, const std::string &attr)
+{
+    if (listener_ != nullptr) {
+        listener_->PluginHardware(dhId, attr);
+    }
+}
+
+void DScreenHandler::UnPluginHardware(const std::string &dhId)
+{
     if (listener_ != nullptr) {
         listener_->UnPluginHardware(dhId);
     }

services/screenservice/sourceservice/dscreenmgr/include/dscreen_manager.h

@@ -36,12 +36,14 @@ public:
         int32_t status, const std::string &data) override;
 };
 
-class DScreenManager : public Rosen::ScreenManager::IScreenGroupListener,
-    public std::enable_shared_from_this<DScreenManager> {
-DECLARE_SINGLE_INSTANCE_BASE(DScreenManager);
+class DScreenGroupListener : public Rosen::ScreenManager::IScreenGroupListener {
 public:
     void OnChange(const std::vector<uint64_t> &screenIds, Rosen::ScreenGroupChangeEvent event) override;
+};
 
+class DScreenManager {
+DECLARE_SINGLE_INSTANCE_BASE(DScreenManager);
+public:
     void OnRegResult(const std::shared_ptr<DScreen> &dScreen, const std::string &reqId,
         int32_t status, const std::string &data);
     void OnUnregResult(const std::shared_ptr<DScreen> &dScreen, const std::string &reqId,
@@ -54,6 +56,8 @@ public:
     int32_t DisableDistributedScreen(const std::string &devId, const std::string &dhId, const std::string &reqId);
     void HandleDScreenNotify(const std::string &devId, int32_t eventCode, const std::string &eventContent);
     void RegisterDScreenCallback(const sptr<IDScreenSourceCallback> &callback);
+    void HandleScreenChange(const std::shared_ptr<DScreen> &changedScreen, Rosen::ScreenGroupChangeEvent event);
+    std::shared_ptr<DScreen> FindDScreenByScreenId(uint64_t screenId);
 
 private:
     ~DScreenManager();
@@ -63,10 +67,9 @@ private:
     std::map<uint64_t, std::shared_ptr<DScreenMapRelation>> mapRelations_;
     std::map<std::string, std::shared_ptr<DScreen>> dScreens_;
     sptr<IDScreenSourceCallback> dScreenSourceCallbackProxy_ = nullptr;
+    sptr<DScreenGroupListener> dScreenGroupListener_ = nullptr;
     std::shared_ptr<IDScreenCallback> dScreenCallback_ = nullptr;
 
-    void HandleScreenChange(const std::shared_ptr<DScreen> &changedScreen, Rosen::ScreenGroupChangeEvent event);
-    std::shared_ptr<DScreen> FindDScreenByScreenId(uint64_t screenId);
     sptr<IDScreenSink> GetDScreenSinkSA(const std::string &devId);
     int32_t NotifyRemoteScreenService(const std::string &devId, int32_t eventCode, const std::string &eventContent);
     void NotifyRemoteSinkSetUp(const std::shared_ptr<DScreen> &dScreen);

services/screenservice/sourceservice/dscreenmgr/src/dscreen_manager.cpp

@@ -44,7 +44,10 @@ DScreenManager::~DScreenManager()
 int32_t DScreenManager::Init()
 {
     DHLOGI("DScreenManager::Init");
-    int32_t ret = ScreenMgrAdapter::GetInstance().RegisterScreenGroupListener(this);
+    if (dScreenGroupListener_ == nullptr) {
+        dScreenGroupListener_ = new DScreenGroupListener();
+    }
+    int32_t ret = ScreenMgrAdapter::GetInstance().RegisterScreenGroupListener(dScreenGroupListener_);
     if (ret != DH_SUCCESS) {
         DHLOGE("DScreenManager Init failed, err: %d", ret);
     }
@@ -57,11 +60,17 @@ int32_t DScreenManager::Init()
 int32_t DScreenManager::UnInit()
 {
     DHLOGI("DScreenManager::UnInit");
-    int32_t ret = ScreenMgrAdapter::GetInstance().UnregisterScreenGroupListener(this);
+    int32_t ret = DH_SUCCESS;
+    if (dScreenGroupListener_ != nullptr) {
+        ret = ScreenMgrAdapter::GetInstance().UnregisterScreenGroupListener(dScreenGroupListener_);
+    }
+
     if (ret != DH_SUCCESS) {
         DHLOGE("DScreenManager UnInit failed, err: %d", ret);
     }
     dScreenCallback_ = nullptr;
+    dScreenSourceCallbackProxy_ = nullptr;
+    dScreenGroupListener_ = nullptr;
 
     {
         std::lock_guard<std::mutex> lock(dScreenMapMtx_);
@@ -76,17 +85,17 @@ int32_t DScreenManager::UnInit()
     return ret;
 }
 
-void DScreenManager::OnChange(const std::vector<uint64_t> &screenIds, Rosen::ScreenGroupChangeEvent event)
+void DScreenGroupListener::OnChange(const std::vector<uint64_t> &screenIds, Rosen::ScreenGroupChangeEvent event)
 {
     DHLOGI("On Screen change, screenIds size: %d", screenIds.size());
     for (uint64_t screenId : screenIds) {
         std::shared_ptr<DScreen> changedScreen = nullptr;
-        changedScreen = FindDScreenByScreenId(screenId);
+        changedScreen = DScreenManager::GetInstance().FindDScreenByScreenId(screenId);
         if (!changedScreen) {
             DHLOGD("screen change not about remote screen, screenId: %ulld", screenId);
             continue;
         }
-        HandleScreenChange(changedScreen, event);
+        DScreenManager::GetInstance().HandleScreenChange(changedScreen, event);
     }
 }
 

services/screenservice/sourceservice/dscreenservice/include/dscreen_source_service.h

@@ -49,7 +49,6 @@ protected:
 private:
     bool Init();
 
-    sptr<IDScreenSourceCallback> dScreenSourceCallbackProxy_ = nullptr;
     bool registerToService_ = false;
 };
 } // namespace DistributedHardware

services/screenservice/sourceservice/dscreenservice/src/dscreen_source_service.cpp

@@ -50,7 +50,10 @@ void DScreenSourceService::OnStart()
 void DScreenSourceService::OnStop()
 {
     DHLOGI("dscreen source service stop.");
-    dScreenSourceCallbackProxy_ = nullptr;
+    int32_t ret = DScreenManager::GetInstance().UnInit();
+    if (ret != DH_SUCCESS) {
+        DHLOGE("UnInit DScreenManager failed. err: %d", ret);
+    }
     registerToService_ = false;
 }
 
@@ -72,7 +75,6 @@ bool DScreenSourceService::Init()
 int32_t DScreenSourceService::InitSource(const std::string &params, const sptr<IDScreenSourceCallback> &callback)
 {
     DHLOGI("InitSource");
-    dScreenSourceCallbackProxy_ = callback;
     int32_t ret = DScreenManager::GetInstance().Init();
     if (ret != DH_SUCCESS) {
         DHLOGE("Init DScreenManager failed. err: %d", ret);
@@ -86,7 +88,6 @@ int32_t DScreenSourceService::InitSource(const std::string &params, const sptr<I
 int32_t DScreenSourceService::ReleaseSource()
 {
     DHLOGI("ReleaseSource");
-    dScreenSourceCallbackProxy_ = nullptr;
     int32_t ret = DScreenManager::GetInstance().UnInit();
     if (ret != DH_SUCCESS) {
         DHLOGE("UnInit DScreenManager failed. err: %d", ret);