!449 优化dm和dms代码，优化测试用例，修复部分bug

Merge pull request !449 from xiaojianfeng/master

dm/src/screen.cpp

@@ -45,7 +45,7 @@ Screen::~Screen()
 bool Screen::IsGroup() const
 {
     UpdateScreenInfo();
-    return pImpl_->GetScreenInfo()->GetCanHasChild();
+    return pImpl_->GetScreenInfo()->GetIsScreenGroup();
 }
 
 const std::string Screen::GetName() const
@@ -60,7 +60,6 @@ ScreenId Screen::GetId() const
 
 uint32_t Screen::GetWidth() const
 {
-    UpdateScreenInfo();
     auto modeId = GetModeId();
     auto modes = GetSupportedModes();
     if (modeId < 0 || modeId >= modes.size()) {
@@ -112,7 +111,6 @@ Orientation Screen::GetOrientation() const
 
 bool Screen::IsReal() const
 {
-    UpdateScreenInfo();
     return pImpl_->GetScreenInfo()->GetType() == ScreenType::REAL;
 }
 
@@ -154,11 +152,13 @@ DMError Screen::SetScreenColorTransform()
 
 ScreenId Screen::GetParentId() const
 {
+    UpdateScreenInfo();
     return pImpl_->GetScreenInfo()->GetParentId();
 }
 
 uint32_t Screen::GetModeId() const
 {
+    UpdateScreenInfo();
     return pImpl_->GetScreenInfo()->GetModeId();
 }
 
@@ -173,11 +173,7 @@ bool Screen::SetScreenActiveMode(uint32_t modeId)
     if (modeId >= GetSupportedModes().size()) {
         return false;
     }
-    if (SingletonContainer::Get<ScreenManagerAdapter>().SetScreenActiveMode(screenId, modeId)) {
-        pImpl_->GetScreenInfo()->SetModeId(modeId);
-        return true;
-    }
-    return false;
+    return SingletonContainer::Get<ScreenManagerAdapter>().SetScreenActiveMode(screenId, modeId);
 }
 
 void Screen::UpdateScreenInfo(sptr<ScreenInfo> info) const

dm/src/screen_group.cpp

@@ -14,6 +14,8 @@
  */
 
 #include "screen_group.h"
+
+#include "display_manager_adapter.h"
 #include "screen.h"
 #include "screen_group_info.h"
 #include "window_manager_hilog.h"
@@ -38,31 +40,41 @@ ScreenGroup::ScreenGroup(sptr<ScreenGroupInfo> info)
 {
 }
 
-void ScreenGroup::UpdateScreenGroupInfo(sptr<ScreenGroupInfo> info)
+void ScreenGroup::UpdateScreenGroupInfo(sptr<ScreenGroupInfo> info) const
 {
     if (info == nullptr) {
         WLOGFE("ScreenGroupInfo is nullptr.");
         return;
     }
+    Screen::UpdateScreenInfo(info);
     pImpl_->SetScreenGroupInfo(info);
 }
 
+void ScreenGroup::UpdateScreenGroupInfo() const
+{
+    auto screenInfo = SingletonContainer::Get<ScreenManagerAdapter>().GetScreenGroupInfoById(GetId());
+    UpdateScreenGroupInfo(screenInfo);
+}
+
 ScreenGroup::~ScreenGroup()
 {
 }
 
 ScreenCombination ScreenGroup::GetCombination() const
 {
+    UpdateScreenGroupInfo();
     return pImpl_->GetScreenGroupInfo()->GetCombination();
 }
 
 std::vector<ScreenId> ScreenGroup::GetChildIds() const
 {
+    UpdateScreenGroupInfo();
     return pImpl_->GetScreenGroupInfo()->GetChildren();
 }
 
 std::vector<Point> ScreenGroup::GetChildPositions() const
 {
+    UpdateScreenGroupInfo();
     return pImpl_->GetScreenGroupInfo()->GetPosition();
 }
 } // namespace OHOS::Rosen

dm/test/systemtest/screen_manager_test.cpp

@@ -30,6 +30,7 @@ namespace Rosen {
 namespace {
     constexpr HiviewDFX::HiLogLabel LABEL = {LOG_CORE, HILOG_DOMAIN_DISPLAY, "ScreenManagerTest"};
 }
+class ScreenGroupChangeListener;
 class ScreenManagerTest : public testing::Test {
 public:
     static void SetUpTestCase();
@@ -37,6 +38,9 @@ public:
     virtual void SetUp() override;
     virtual void TearDown() override;
     sptr<Window> CreateWindowByDisplayId(DisplayId displayId);
+    void CheckScreenStateInGroup(bool, sptr<ScreenGroup>, ScreenId, sptr<Screen>, ScreenId);
+    void CheckScreenGroupState(ScreenCombination, ScreenGroupChangeEvent event, ScreenId,
+        sptr<ScreenGroup>, sptr<ScreenGroupChangeListener>);
     static sptr<Display> defaultDisplay_;
     static DisplayId defaultDisplayId_;
     static ScreenId defaultScreenId_;
@@ -144,6 +148,68 @@ sptr<Window> ScreenManagerTest::CreateWindowByDisplayId(DisplayId displayId)
     return window;
 }
 
+#define CHECK_TEST_INIT_SCREEN_STATE \
+    std::vector<sptr<Screen>> allScreens = ScreenManager::GetInstance().GetAllScreens(); \
+    ASSERT_LT(0, allScreens.size()); \
+    ScreenId groupId = SCREEN_ID_INVALID; \
+    for (auto screen : allScreens) { \
+        if (screen->IsGroup()) { \
+        groupId = screen->GetId(); \
+        ASSERT_EQ(SCREEN_ID_INVALID, screen->GetParentId()); \
+        } \
+    } \
+    ASSERT_NE(SCREEN_ID_INVALID, groupId); \
+    auto group = ScreenManager::GetInstance().GetScreenGroup(groupId); \
+    ASSERT_NE(nullptr, group); \
+    ASSERT_EQ(groupId, group->GetId()); \
+    sptr<ScreenChangeListener> screenListener = new ScreenChangeListener(); \
+    sptr<ScreenGroupChangeListener> screenGroupChangeListener = new ScreenGroupChangeListener(); \
+    ScreenManager::GetInstance().RegisterScreenListener(screenListener); \
+    ScreenManager::GetInstance().RegisterScreenGroupListener(screenGroupChangeListener); \
+
+#define CHECK_SCREEN_STATE_AFTER_CREATE_VIRTUAL_SCREEN \
+    auto virtualScreen = ScreenManager::GetInstance().GetScreenById(virtualScreenId); \
+    ASSERT_NE(nullptr, virtualScreen); \
+    ASSERT_EQ(virtualScreenId, virtualScreen->GetId()); \
+    ScreenId screenId = screenListener->connectFuture_.GetResult(TIME_OUT); \
+    screenListener->connectFuture_.Reset(); \
+    ASSERT_EQ(virtualScreenId, screenId); \
+
+void ScreenManagerTest::CheckScreenStateInGroup(
+    bool isInGroup, sptr<ScreenGroup> group, ScreenId groupId, sptr<Screen> virtualScreen, ScreenId virtualScreenId)
+{
+    auto childIds = group->GetChildIds();
+    ASSERT_LT(0, childIds.size());
+    auto iter = std::find(childIds.begin(), childIds.end(), virtualScreenId);
+    if (isInGroup) {
+        ASSERT_EQ(groupId, virtualScreen->GetParentId());
+    } else {
+        ASSERT_EQ(SCREEN_ID_INVALID, virtualScreen->GetParentId());
+    }
+    if (isInGroup) {
+        ASSERT_NE(childIds.end(), iter);
+    } else {
+        ASSERT_EQ(childIds.end(), iter);
+    }
+}
+
+void ScreenManagerTest::CheckScreenGroupState(ScreenCombination combination, ScreenGroupChangeEvent event,
+    ScreenId virtualScreenId, sptr<ScreenGroup> group, sptr<ScreenGroupChangeListener> screenGroupChangeListener)
+{
+    auto pair = screenGroupChangeListener->changeFuture_.GetResult(TIME_OUT);
+    screenGroupChangeListener->changeFuture_.Reset();
+    ASSERT_EQ(virtualScreenId, pair.first);
+    ASSERT_EQ(event, pair.second);
+    ASSERT_EQ(combination, group->GetCombination());
+}
+
+#define CHECK_SCREEN_STATE_AFTER_DESTROY_VIRTUAL_SCREEN \
+    { \
+        auto screenId = screenListener->disconnectFuture_.GetResult(TIME_OUT); \
+        screenListener->disconnectFuture_.Reset(); \
+        ASSERT_EQ(virtualScreenId, screenId); \
+    }
+
 namespace {
 /**
  * @tc.name: ScreenManager01
@@ -315,31 +381,23 @@ HWTEST_F(ScreenManagerTest, ScreenManager08, Function | MediumTest | Level2)
     ASSERT_TRUE(utils.CreateSurface());
     defaultOption_.surface_ = utils.psurface_;
     defaultOption_.isForShot_ = false;
-    sptr<ScreenChangeListener> screenListener = new ScreenChangeListener();
-    sptr<ScreenGroupChangeListener> screenGroupChangeListener = new ScreenGroupChangeListener();
-    ScreenManager::GetInstance().RegisterScreenListener(screenListener);
-    ScreenManager::GetInstance().RegisterScreenGroupListener(screenGroupChangeListener);
+    CHECK_TEST_INIT_SCREEN_STATE
     ScreenId virtualScreenId = ScreenManager::GetInstance().CreateVirtualScreen(defaultOption_);
-    ScreenId screenId = screenListener->connectFuture_.GetResult(TIME_OUT);
-    screenListener->connectFuture_.Reset();
-    ASSERT_EQ(virtualScreenId, screenId);
+    CHECK_SCREEN_STATE_AFTER_CREATE_VIRTUAL_SCREEN
+    CheckScreenStateInGroup(false, group, groupId, virtualScreen, virtualScreenId);
     std::vector<sptr<Screen>> screens = ScreenManager::GetInstance().GetAllScreens();
-    sptr<Screen> DefaultScreen = screens.front();
-    std::vector<ExpandOption> options = {{DefaultScreen->GetId(), 0, 0}, {virtualScreenId, defaultWidth_, 0}};
-    ScreenId expansionId = ScreenManager::GetInstance().MakeExpand(options);
-    ASSERT_NE(SCREEN_ID_INVALID, expansionId);
-    auto pair = screenGroupChangeListener->changeFuture_.GetResult(TIME_OUT);
-    screenGroupChangeListener->changeFuture_.Reset();
-    ASSERT_EQ(virtualScreenId, pair.first);
-    ASSERT_EQ(ScreenGroupChangeEvent::ADD_TO_GROUP, pair.second);
+    sptr<Screen> defaultScreen = screens.front();
+    std::vector<ExpandOption> options = {{defaultScreen->GetId(), 0, 0}, {virtualScreenId, defaultWidth_, 0}};
+    ScreenId expansionGroup = ScreenManager::GetInstance().MakeExpand(options);
+    ASSERT_NE(SCREEN_ID_INVALID, expansionGroup);
+    CheckScreenGroupState(ScreenCombination::SCREEN_EXPAND, ScreenGroupChangeEvent::ADD_TO_GROUP,
+        virtualScreenId, group, screenGroupChangeListener);
+    CheckScreenStateInGroup(true, group, groupId, virtualScreen, virtualScreenId);
     ASSERT_EQ(DMError::DM_OK, ScreenManager::GetInstance().DestroyVirtualScreen(virtualScreenId));
-    screenId = screenListener->disconnectFuture_.GetResult(TIME_OUT);
-    screenListener->disconnectFuture_.Reset();
-    ASSERT_EQ(virtualScreenId, screenId);
-    pair = screenGroupChangeListener->changeFuture_.GetResult(TIME_OUT);
-    screenGroupChangeListener->changeFuture_.Reset();
-    ASSERT_EQ(virtualScreenId, pair.first);
-    ASSERT_EQ(ScreenGroupChangeEvent::REMOVE_FROM_GROUP, pair.second);
+    CHECK_SCREEN_STATE_AFTER_DESTROY_VIRTUAL_SCREEN
+    CheckScreenGroupState(ScreenCombination::SCREEN_EXPAND, ScreenGroupChangeEvent::REMOVE_FROM_GROUP,
+        virtualScreenId, group, screenGroupChangeListener);
+    CheckScreenStateInGroup(false, group, groupId, virtualScreen, virtualScreenId);
     ScreenManager::GetInstance().UnregisterScreenListener(screenListener);
     ScreenManager::GetInstance().UnregisterScreenGroupListener(screenGroupChangeListener);
 }
@@ -356,14 +414,10 @@ HWTEST_F(ScreenManagerTest, ScreenManager09, Function | MediumTest | Level2)
     ASSERT_TRUE(utils.CreateSurface());
     defaultOption_.surface_ = utils.psurface_;
     defaultOption_.isForShot_ = false;
-    sptr<ScreenChangeListener> screenListener = new ScreenChangeListener();
-    sptr<ScreenGroupChangeListener> screenGroupChangeListener = new ScreenGroupChangeListener();
-    ScreenManager::GetInstance().RegisterScreenListener(screenListener);
-    ScreenManager::GetInstance().RegisterScreenGroupListener(screenGroupChangeListener);
+    CHECK_TEST_INIT_SCREEN_STATE
     ScreenId virtualScreenId = ScreenManager::GetInstance().CreateVirtualScreen(defaultOption_);
-    ScreenId screenId = screenListener->connectFuture_.GetResult(TIME_OUT);
-    screenListener->connectFuture_.Reset();
-    ASSERT_EQ(virtualScreenId, screenId);
+    CHECK_SCREEN_STATE_AFTER_CREATE_VIRTUAL_SCREEN
+    CheckScreenStateInGroup(false, group, groupId, virtualScreen, virtualScreenId);
     std::vector<sptr<Screen>> screens = ScreenManager::GetInstance().GetAllScreens();
     sptr<Screen> DefaultScreen = screens.front();
     DisplayId virtualDisplayId = DISPLAY_ID_INVALID;
@@ -377,21 +431,17 @@ HWTEST_F(ScreenManagerTest, ScreenManager09, Function | MediumTest | Level2)
     ASSERT_NE(nullptr, window);
     sleep(TEST_SPEEP_S);
     std::vector<ExpandOption> options = {{DefaultScreen->GetId(), 0, 0}, {virtualScreenId, defaultWidth_, 0}};
-    ScreenId expansionId = ScreenManager::GetInstance().MakeExpand(options);
-    auto pair = screenGroupChangeListener->changeFuture_.GetResult(TIME_OUT);
-    screenGroupChangeListener->changeFuture_.Reset();
-    ASSERT_EQ(virtualScreenId, pair.first);
-    ASSERT_EQ(ScreenGroupChangeEvent::ADD_TO_GROUP, pair.second);
+    ScreenId expansionGroup = ScreenManager::GetInstance().MakeExpand(options);
+    ASSERT_NE(SCREEN_ID_INVALID, expansionGroup);
+    CheckScreenGroupState(ScreenCombination::SCREEN_EXPAND, ScreenGroupChangeEvent::ADD_TO_GROUP,
+        virtualScreenId, group, screenGroupChangeListener);
+    CheckScreenStateInGroup(true, group, groupId, virtualScreen, virtualScreenId);
     sleep(TEST_SPEEP_S);
-    ASSERT_NE(SCREEN_ID_INVALID, expansionId);
     ASSERT_EQ(DMError::DM_OK, ScreenManager::GetInstance().DestroyVirtualScreen(virtualScreenId));
-    screenId = screenListener->disconnectFuture_.GetResult(TIME_OUT);
-    screenListener->disconnectFuture_.Reset();
-    ASSERT_EQ(virtualScreenId, screenId);
-    pair = screenGroupChangeListener->changeFuture_.GetResult(TIME_OUT);
-    screenGroupChangeListener->changeFuture_.Reset();
-    ASSERT_EQ(virtualScreenId, pair.first);
-    ASSERT_EQ(ScreenGroupChangeEvent::REMOVE_FROM_GROUP, pair.second);
+    CHECK_SCREEN_STATE_AFTER_DESTROY_VIRTUAL_SCREEN
+    CheckScreenGroupState(ScreenCombination::SCREEN_EXPAND, ScreenGroupChangeEvent::REMOVE_FROM_GROUP,
+        virtualScreenId, group, screenGroupChangeListener);
+    CheckScreenStateInGroup(false, group, groupId, virtualScreen, virtualScreenId);
     ScreenManager::GetInstance().UnregisterScreenListener(screenListener);
     ScreenManager::GetInstance().UnregisterScreenGroupListener(screenGroupChangeListener);
     sleep(TEST_SPEEP_S);
@@ -410,21 +460,14 @@ HWTEST_F(ScreenManagerTest, ScreenManager10, Function | MediumTest | Level2)
     ASSERT_TRUE(utils.CreateSurface());
     defaultOption_.surface_ = utils.psurface_;
     defaultOption_.isForShot_ = false;
-    sptr<ScreenChangeListener> screenListener = new ScreenChangeListener();
     for (uint32_t i = 0; i < execTimes_; i++) {
-        ScreenManager::GetInstance().RegisterScreenListener(screenListener);
+        CHECK_TEST_INIT_SCREEN_STATE
         ScreenId virtualScreenId = ScreenManager::GetInstance().CreateVirtualScreen(defaultOption_);
-        ASSERT_NE(SCREEN_ID_INVALID, virtualScreenId);
-        ScreenId screenId = screenListener->connectFuture_.GetResult(TIME_OUT);
-        screenListener->connectFuture_.Reset();
-        ASSERT_EQ(virtualScreenId, screenId);
-        auto screen = ScreenManager::GetInstance().GetScreenById(virtualScreenId);
-        ASSERT_EQ(virtualScreenId, screen->GetId());
-        ASSERT_EQ(SCREEN_ID_INVALID, screen->GetParentId());
+        CHECK_SCREEN_STATE_AFTER_CREATE_VIRTUAL_SCREEN
+        CheckScreenStateInGroup(false, group, groupId, virtualScreen, virtualScreenId);
         ASSERT_EQ(DMError::DM_OK, ScreenManager::GetInstance().DestroyVirtualScreen(virtualScreenId));
-        screenId = screenListener->disconnectFuture_.GetResult(TIME_OUT);
-        screenListener->disconnectFuture_.Reset();
-        ASSERT_EQ(virtualScreenId, screenId);
+        CHECK_SCREEN_STATE_AFTER_DESTROY_VIRTUAL_SCREEN
+        CheckScreenStateInGroup(false, group, groupId, virtualScreen, virtualScreenId);
         ScreenManager::GetInstance().UnregisterScreenListener(screenListener);
     }
 }
@@ -440,34 +483,28 @@ HWTEST_F(ScreenManagerTest, ScreenManager11, Function | MediumTest | Level2)
     ASSERT_TRUE(utils.CreateSurface());
     defaultOption_.surface_ = utils.psurface_;
     defaultOption_.isForShot_ = false;
-    sptr<ScreenChangeListener> screenListener = new ScreenChangeListener();
-    sptr<ScreenGroupChangeListener> screenGroupChangeListener = new ScreenGroupChangeListener();
     for (uint32_t i = 0; i < 10; i++) {
-        ScreenManager::GetInstance().RegisterScreenListener(screenListener);
-        ScreenManager::GetInstance().RegisterScreenGroupListener(screenGroupChangeListener);
+        CHECK_TEST_INIT_SCREEN_STATE
         ScreenId virtualScreenId = ScreenManager::GetInstance().CreateVirtualScreen(defaultOption_);
-        ASSERT_NE(SCREEN_ID_INVALID, virtualScreenId);
-        ScreenId screenId = screenListener->connectFuture_.GetResult(TIME_OUT);
-        screenListener->connectFuture_.Reset();
-        ASSERT_EQ(virtualScreenId, screenId);
+        CHECK_SCREEN_STATE_AFTER_CREATE_VIRTUAL_SCREEN
+        CheckScreenStateInGroup(false, group, groupId, virtualScreen, virtualScreenId);
+
         std::vector<ScreenId> mirrorIds;
         mirrorIds.push_back(virtualScreenId);
-        ScreenManager::GetInstance().MakeMirror(defaultScreenId_, mirrorIds);
-        auto pair = screenGroupChangeListener->changeFuture_.GetResult(TIME_OUT);
-        screenGroupChangeListener->changeFuture_.Reset();
-        ASSERT_EQ(virtualScreenId, pair.first);
-        ASSERT_EQ(ScreenGroupChangeEvent::ADD_TO_GROUP, pair.second);
+        auto mirrorGroup = ScreenManager::GetInstance().MakeMirror(defaultScreenId_, mirrorIds);
+        ASSERT_EQ(mirrorGroup, groupId);
+        CheckScreenGroupState(ScreenCombination::SCREEN_MIRROR, ScreenGroupChangeEvent::ADD_TO_GROUP,
+            virtualScreenId, group, screenGroupChangeListener);
+        CheckScreenStateInGroup(true, group, groupId, virtualScreen, virtualScreenId);
+
         auto screen = ScreenManager::GetInstance().GetScreenById(virtualScreenId);
         ASSERT_EQ(virtualScreenId, screen->GetId());
         ASSERT_NE(SCREEN_ID_INVALID, screen->GetParentId());
         ASSERT_EQ(DMError::DM_OK, ScreenManager::GetInstance().DestroyVirtualScreen(virtualScreenId));
-        screenId = screenListener->disconnectFuture_.GetResult(TIME_OUT);
-        screenListener->disconnectFuture_.Reset();
-        ASSERT_EQ(virtualScreenId, screenId);
-        pair = screenGroupChangeListener->changeFuture_.GetResult(TIME_OUT);
-        screenGroupChangeListener->changeFuture_.Reset();
-        ASSERT_EQ(virtualScreenId, pair.first);
-        ASSERT_EQ(ScreenGroupChangeEvent::REMOVE_FROM_GROUP, pair.second);
+        CHECK_SCREEN_STATE_AFTER_DESTROY_VIRTUAL_SCREEN
+        CheckScreenGroupState(ScreenCombination::SCREEN_MIRROR, ScreenGroupChangeEvent::REMOVE_FROM_GROUP,
+            virtualScreenId, group, screenGroupChangeListener);
+        CheckScreenStateInGroup(false, group, groupId, virtualScreen, virtualScreenId);
         ScreenManager::GetInstance().UnregisterScreenListener(screenListener);
         ScreenManager::GetInstance().UnregisterScreenGroupListener(screenGroupChangeListener);
     }
@@ -484,37 +521,27 @@ HWTEST_F(ScreenManagerTest, ScreenManager12, Function | MediumTest | Level2)
     ASSERT_TRUE(utils.CreateSurface());
     defaultOption_.surface_ = utils.psurface_;
     defaultOption_.isForShot_ = false;
-    sptr<ScreenChangeListener> screenListener = new ScreenChangeListener();
-    sptr<ScreenGroupChangeListener> screenGroupChangeListener = new ScreenGroupChangeListener();
-    ScreenManager::GetInstance().RegisterScreenListener(screenListener);
-    ScreenManager::GetInstance().RegisterScreenGroupListener(screenGroupChangeListener);
+    CHECK_TEST_INIT_SCREEN_STATE
     ScreenId virtualScreenId = ScreenManager::GetInstance().CreateVirtualScreen(defaultOption_);
-    ASSERT_NE(SCREEN_ID_INVALID, virtualScreenId);
-    ScreenId screenId = screenListener->connectFuture_.GetResult(TIME_OUT);
-    screenListener->connectFuture_.Reset();
-    ASSERT_EQ(virtualScreenId, screenId);
+    CHECK_SCREEN_STATE_AFTER_CREATE_VIRTUAL_SCREEN
+    CheckScreenStateInGroup(false, group, groupId, virtualScreen, virtualScreenId);
 
     std::vector<ScreenId> mirrorIds;
     mirrorIds.push_back(virtualScreenId);
-    ScreenManager::GetInstance().MakeMirror(defaultScreenId_, mirrorIds);
-    auto pair = screenGroupChangeListener->changeFuture_.GetResult(TIME_OUT);
-    screenGroupChangeListener->changeFuture_.Reset();
-    ASSERT_EQ(virtualScreenId, pair.first);
-    ASSERT_EQ(ScreenGroupChangeEvent::ADD_TO_GROUP, pair.second);
-    auto screen = ScreenManager::GetInstance().GetScreenById(virtualScreenId);
-    ASSERT_EQ(virtualScreenId, screen->GetId());
-    ASSERT_NE(SCREEN_ID_INVALID, screen->GetParentId());
+    auto mirrorGroup = ScreenManager::GetInstance().MakeMirror(defaultScreenId_, mirrorIds);
+    ASSERT_EQ(mirrorGroup, groupId);
+    CheckScreenGroupState(ScreenCombination::SCREEN_MIRROR, ScreenGroupChangeEvent::ADD_TO_GROUP,
+        virtualScreenId, group, screenGroupChangeListener);
+    CheckScreenStateInGroup(true, group, groupId, virtualScreen, virtualScreenId);
 
     ScreenManager::GetInstance().RemoveVirtualScreenFromGroup(mirrorIds);
-    pair = screenGroupChangeListener->changeFuture_.GetResult(TIME_OUT);
-    screenGroupChangeListener->changeFuture_.Reset();
-    ASSERT_EQ(virtualScreenId, pair.first);
-    ASSERT_EQ(ScreenGroupChangeEvent::REMOVE_FROM_GROUP, pair.second);
+    CheckScreenGroupState(ScreenCombination::SCREEN_MIRROR, ScreenGroupChangeEvent::REMOVE_FROM_GROUP,
+        virtualScreenId, group, screenGroupChangeListener);
+    CheckScreenStateInGroup(false, group, groupId, virtualScreen, virtualScreenId);
 
     ASSERT_EQ(DMError::DM_OK, ScreenManager::GetInstance().DestroyVirtualScreen(virtualScreenId));
-    screenId = screenListener->disconnectFuture_.GetResult(TIME_OUT);
-    screenListener->disconnectFuture_.Reset();
-    ASSERT_EQ(virtualScreenId, screenId);
+    CHECK_SCREEN_STATE_AFTER_DESTROY_VIRTUAL_SCREEN
+    CheckScreenStateInGroup(false, group, groupId, virtualScreen, virtualScreenId);
     ScreenManager::GetInstance().UnregisterScreenListener(screenListener);
     ScreenManager::GetInstance().UnregisterScreenGroupListener(screenGroupChangeListener);
 }
@@ -530,37 +557,30 @@ HWTEST_F(ScreenManagerTest, ScreenManager13, Function | MediumTest | Level2)
     ASSERT_TRUE(utils.CreateSurface());
     defaultOption_.surface_ = utils.psurface_;
     defaultOption_.isForShot_ = false;
-    sptr<ScreenChangeListener> screenListener = new ScreenChangeListener();
-    sptr<ScreenGroupChangeListener> screenGroupChangeListener = new ScreenGroupChangeListener();
-    ScreenManager::GetInstance().RegisterScreenListener(screenListener);
-    ScreenManager::GetInstance().RegisterScreenGroupListener(screenGroupChangeListener);
+    CHECK_TEST_INIT_SCREEN_STATE
     ScreenId virtualScreenId = ScreenManager::GetInstance().CreateVirtualScreen(defaultOption_);
-    ScreenId screenId = screenListener->connectFuture_.GetResult(TIME_OUT);
-    screenListener->connectFuture_.Reset();
-    ASSERT_EQ(virtualScreenId, screenId);
+    CHECK_SCREEN_STATE_AFTER_CREATE_VIRTUAL_SCREEN
+    CheckScreenStateInGroup(false, group, groupId, virtualScreen, virtualScreenId);
 
     std::vector<sptr<Screen>> screens = ScreenManager::GetInstance().GetAllScreens();
     sptr<Screen> DefaultScreen = screens.front();
     std::vector<ExpandOption> options = {{DefaultScreen->GetId(), 0, 0}, {virtualScreenId, defaultWidth_, 0}};
-    ScreenId expansionId = ScreenManager::GetInstance().MakeExpand(options);
-    ASSERT_NE(SCREEN_ID_INVALID, expansionId);
-    auto pair = screenGroupChangeListener->changeFuture_.GetResult(TIME_OUT);
-    screenGroupChangeListener->changeFuture_.Reset();
-    ASSERT_EQ(virtualScreenId, pair.first);
-    ASSERT_EQ(ScreenGroupChangeEvent::ADD_TO_GROUP, pair.second);
+    ScreenId expansionGroup = ScreenManager::GetInstance().MakeExpand(options);
+    ASSERT_NE(SCREEN_ID_INVALID, expansionGroup);
+    CheckScreenGroupState(ScreenCombination::SCREEN_EXPAND, ScreenGroupChangeEvent::ADD_TO_GROUP,
+        virtualScreenId, group, screenGroupChangeListener);
+    CheckScreenStateInGroup(true, group, groupId, virtualScreen, virtualScreenId);
 
     std::vector<ScreenId> cancelScreens;
     cancelScreens.emplace_back(virtualScreenId);
     ScreenManager::GetInstance().RemoveVirtualScreenFromGroup(cancelScreens);
-    pair = screenGroupChangeListener->changeFuture_.GetResult(TIME_OUT);
-    screenGroupChangeListener->changeFuture_.Reset();
-    ASSERT_EQ(virtualScreenId, pair.first);
-    ASSERT_EQ(ScreenGroupChangeEvent::REMOVE_FROM_GROUP, pair.second);
+    CheckScreenGroupState(ScreenCombination::SCREEN_EXPAND, ScreenGroupChangeEvent::REMOVE_FROM_GROUP,
+        virtualScreenId, group, screenGroupChangeListener);
+    CheckScreenStateInGroup(false, group, groupId, virtualScreen, virtualScreenId);
 
     ASSERT_EQ(DMError::DM_OK, ScreenManager::GetInstance().DestroyVirtualScreen(virtualScreenId));
-    screenId = screenListener->disconnectFuture_.GetResult(TIME_OUT);
-    screenListener->disconnectFuture_.Reset();
-    ASSERT_EQ(virtualScreenId, screenId);
+    CHECK_SCREEN_STATE_AFTER_DESTROY_VIRTUAL_SCREEN
+    CheckScreenStateInGroup(false, group, groupId, virtualScreen, virtualScreenId);
     ScreenManager::GetInstance().UnregisterScreenListener(screenListener);
     ScreenManager::GetInstance().UnregisterScreenGroupListener(screenGroupChangeListener);
 }
@@ -576,37 +596,34 @@ HWTEST_F(ScreenManagerTest, ScreenManager14, Function | MediumTest | Level2)
     ASSERT_TRUE(utils.CreateSurface());
     defaultOption_.surface_ = utils.psurface_;
     defaultOption_.isForShot_ = false;
-    sptr<ScreenChangeListener> screenListener = new ScreenChangeListener();
-    sptr<ScreenGroupChangeListener> screenGroupChangeListener = new ScreenGroupChangeListener();
-    ScreenManager::GetInstance().RegisterScreenListener(screenListener);
-    ScreenManager::GetInstance().RegisterScreenGroupListener(screenGroupChangeListener);
+    CHECK_TEST_INIT_SCREEN_STATE
     ScreenId virtualScreenId = ScreenManager::GetInstance().CreateVirtualScreen(defaultOption_);
-    ScreenId screenId = screenListener->connectFuture_.GetResult(TIME_OUT);
-    screenListener->connectFuture_.Reset();
-    ASSERT_EQ(virtualScreenId, screenId);
+    CHECK_SCREEN_STATE_AFTER_CREATE_VIRTUAL_SCREEN
+    CheckScreenStateInGroup(false, group, groupId, virtualScreen, virtualScreenId);
 
     std::vector<sptr<Screen>> screens = ScreenManager::GetInstance().GetAllScreens();
     sptr<Screen> DefaultScreen = screens.front();
     std::vector<ExpandOption> options = {{DefaultScreen->GetId(), 0, 0}, {virtualScreenId, defaultWidth_, 0}};
-    ScreenId expansionId = ScreenManager::GetInstance().MakeExpand(options);
-    ASSERT_NE(SCREEN_ID_INVALID, expansionId);
-    auto pair = screenGroupChangeListener->changeFuture_.GetResult(TIME_OUT);
-    screenGroupChangeListener->changeFuture_.Reset();
-    ASSERT_EQ(virtualScreenId, pair.first);
-    ASSERT_EQ(ScreenGroupChangeEvent::ADD_TO_GROUP, pair.second);
+    ScreenId expansionGroup = ScreenManager::GetInstance().MakeExpand(options);
+    ASSERT_EQ(expansionGroup, groupId);
+    CheckScreenGroupState(ScreenCombination::SCREEN_EXPAND, ScreenGroupChangeEvent::ADD_TO_GROUP,
+        virtualScreenId, group, screenGroupChangeListener);
+    CheckScreenStateInGroup(true, group, groupId, virtualScreen, virtualScreenId);
 
     std::vector<ScreenId> mirrorScreens;
     mirrorScreens.emplace_back(virtualScreenId);
-    ScreenManager::GetInstance().MakeMirror(defaultScreenId_, mirrorScreens);
-    pair = screenGroupChangeListener->changeFuture_.GetResult(TIME_OUT);
-    screenGroupChangeListener->changeFuture_.Reset();
-    ASSERT_EQ(virtualScreenId, pair.first);
-    ASSERT_EQ(ScreenGroupChangeEvent::CHANGE_GROUP, pair.second);
+    auto mirrorGroup = ScreenManager::GetInstance().MakeMirror(defaultScreenId_, mirrorScreens);
+    ASSERT_EQ(mirrorGroup, groupId);
+    CheckScreenGroupState(ScreenCombination::SCREEN_MIRROR, ScreenGroupChangeEvent::CHANGE_GROUP,
+        virtualScreenId, group, screenGroupChangeListener);
+    CheckScreenStateInGroup(true, group, groupId, virtualScreen, virtualScreenId);
 
     ASSERT_EQ(DMError::DM_OK, ScreenManager::GetInstance().DestroyVirtualScreen(virtualScreenId));
-    screenId = screenListener->disconnectFuture_.GetResult(TIME_OUT);
-    screenListener->disconnectFuture_.Reset();
-    ASSERT_EQ(virtualScreenId, screenId);
+    CHECK_SCREEN_STATE_AFTER_DESTROY_VIRTUAL_SCREEN
+    CheckScreenGroupState(ScreenCombination::SCREEN_MIRROR, ScreenGroupChangeEvent::REMOVE_FROM_GROUP,
+        virtualScreenId, group, screenGroupChangeListener);
+    CheckScreenStateInGroup(false, group, groupId, virtualScreen, virtualScreenId);
+
     ScreenManager::GetInstance().UnregisterScreenListener(screenListener);
     ScreenManager::GetInstance().UnregisterScreenGroupListener(screenGroupChangeListener);
 }
@@ -622,37 +639,35 @@ HWTEST_F(ScreenManagerTest, ScreenManager15, Function | MediumTest | Level2)
     ASSERT_TRUE(utils.CreateSurface());
     defaultOption_.surface_ = utils.psurface_;
     defaultOption_.isForShot_ = false;
-    sptr<ScreenChangeListener> screenListener = new ScreenChangeListener();
-    sptr<ScreenGroupChangeListener> screenGroupChangeListener = new ScreenGroupChangeListener();
-    ScreenManager::GetInstance().RegisterScreenListener(screenListener);
-    ScreenManager::GetInstance().RegisterScreenGroupListener(screenGroupChangeListener);
+
+    CHECK_TEST_INIT_SCREEN_STATE
     ScreenId virtualScreenId = ScreenManager::GetInstance().CreateVirtualScreen(defaultOption_);
-    ScreenId screenId = screenListener->connectFuture_.GetResult(TIME_OUT);
-    screenListener->connectFuture_.Reset();
-    ASSERT_EQ(virtualScreenId, screenId);
+    CHECK_SCREEN_STATE_AFTER_CREATE_VIRTUAL_SCREEN
+    CheckScreenStateInGroup(false, group, groupId, virtualScreen, virtualScreenId);
 
     std::vector<ScreenId> mirrorScreens;
     mirrorScreens.emplace_back(virtualScreenId);
-    ScreenManager::GetInstance().MakeMirror(defaultScreenId_, mirrorScreens);
-    auto pair = screenGroupChangeListener->changeFuture_.GetResult(TIME_OUT);
-    screenGroupChangeListener->changeFuture_.Reset();
-    ASSERT_EQ(virtualScreenId, pair.first);
-    ASSERT_EQ(ScreenGroupChangeEvent::ADD_TO_GROUP, pair.second);
+    auto mirrorGroup = ScreenManager::GetInstance().MakeMirror(defaultScreenId_, mirrorScreens);
+    ASSERT_EQ(mirrorGroup, groupId);
+    CheckScreenGroupState(ScreenCombination::SCREEN_MIRROR, ScreenGroupChangeEvent::ADD_TO_GROUP,
+        virtualScreenId, group, screenGroupChangeListener);
+    CheckScreenStateInGroup(true, group, groupId, virtualScreen, virtualScreenId);
 
     std::vector<sptr<Screen>> screens = ScreenManager::GetInstance().GetAllScreens();
-    sptr<Screen> DefaultScreen = screens.front();
-    std::vector<ExpandOption> options = {{DefaultScreen->GetId(), 0, 0}, {virtualScreenId, defaultWidth_, 0}};
-    ScreenId expansionId = ScreenManager::GetInstance().MakeExpand(options);
-    ASSERT_NE(SCREEN_ID_INVALID, expansionId);
-    pair = screenGroupChangeListener->changeFuture_.GetResult(TIME_OUT);
-    screenGroupChangeListener->changeFuture_.Reset();
-    ASSERT_EQ(virtualScreenId, pair.first);
-    ASSERT_EQ(ScreenGroupChangeEvent::CHANGE_GROUP, pair.second);
+    sptr<Screen> defaultScreen = screens.front();
+    std::vector<ExpandOption> options = {{defaultScreen->GetId(), 0, 0}, {virtualScreenId, defaultWidth_, 0}};
+    ScreenId expansionGroup = ScreenManager::GetInstance().MakeExpand(options);
+    ASSERT_EQ(expansionGroup, groupId);
+    CheckScreenGroupState(ScreenCombination::SCREEN_EXPAND, ScreenGroupChangeEvent::CHANGE_GROUP,
+        virtualScreenId, group, screenGroupChangeListener);
+    CheckScreenStateInGroup(true, group, groupId, virtualScreen, virtualScreenId);
 
     ASSERT_EQ(DMError::DM_OK, ScreenManager::GetInstance().DestroyVirtualScreen(virtualScreenId));
-    screenId = screenListener->disconnectFuture_.GetResult(TIME_OUT);
-    screenListener->disconnectFuture_.Reset();
-    ASSERT_EQ(virtualScreenId, screenId);
+    CHECK_SCREEN_STATE_AFTER_DESTROY_VIRTUAL_SCREEN
+    CheckScreenGroupState(ScreenCombination::SCREEN_EXPAND, ScreenGroupChangeEvent::REMOVE_FROM_GROUP,
+        virtualScreenId, group, screenGroupChangeListener);
+    CheckScreenStateInGroup(false, group, groupId, virtualScreen, virtualScreenId);
+
     ScreenManager::GetInstance().UnregisterScreenListener(screenListener);
     ScreenManager::GetInstance().UnregisterScreenGroupListener(screenGroupChangeListener);
 }
@@ -668,8 +683,12 @@ HWTEST_F(ScreenManagerTest, ScreenManager16, Function | MediumTest | Level2)
     auto display = DisplayManager::GetInstance().GetDefaultDisplay();
     uint32_t orientation = static_cast<uint32_t>(Orientation::VERTICAL);
     uint32_t end = static_cast<uint32_t>(Orientation::REVERSE_HORIZONTAL);
+    sptr<ScreenChangeListener> screenListener = new ScreenChangeListener();
+    ScreenManager::GetInstance().RegisterScreenListener(screenListener);
     for (; orientation <= end; ++orientation) {
         screens[0]->SetOrientation(static_cast<Orientation>(orientation));
+        ScreenId screenId = screenListener->changeFuture_.GetResult(TIME_OUT);
+        ASSERT_EQ(screenId, screens[0]->GetId());
         usleep(1E6);
         ASSERT_EQ(static_cast<uint32_t>(screens[0]->GetOrientation()), orientation);
         ASSERT_EQ(static_cast<uint32_t>(display->GetOrientation()), orientation);
@@ -677,6 +696,7 @@ HWTEST_F(ScreenManagerTest, ScreenManager16, Function | MediumTest | Level2)
     screens[0]->SetOrientation(Orientation::UNSPECIFIED);
     ASSERT_EQ(static_cast<uint32_t>(screens[0]->GetOrientation()), static_cast<uint32_t>(Orientation::UNSPECIFIED));
     ASSERT_EQ(static_cast<uint32_t>(display->GetOrientation()), static_cast<uint32_t>(Orientation::UNSPECIFIED));
+    ScreenManager::GetInstance().UnregisterScreenListener(screenListener);
 }
 }
 } // namespace Rosen

dmserver/include/abstract_screen.h

@@ -60,7 +60,7 @@ public:
     const std::string name_;
     const ScreenId dmsId_;
     const ScreenId rsId_;
-    bool canHasChild_ { false };
+    bool isScreenGroup_ { false };
     std::shared_ptr<RSDisplayNode> rsDisplayNode_;
     RSDisplayNodeConfig rSDisplayNodeConfig_;
     ScreenId groupDmsId_ { SCREEN_ID_INVALID };

dmserver/include/abstract_screen_controller.h

@@ -19,6 +19,7 @@
 #include <map>
 #include <vector>
 
+#include <event_handler.h>
 #include <refbase.h>
 #include <surface.h>
 #include <transaction/rs_interfaces.h>
@@ -58,7 +59,6 @@ public:
     DMError SetVirtualScreenSurface(ScreenId screenId, sptr<Surface> surface);
     bool SetOrientation(ScreenId screenId, Orientation orientation);
 
-    bool IsScreenGroup(ScreenId screenId) const;
     bool SetScreenActiveMode(ScreenId screenId, uint32_t modeId);
     std::shared_ptr<RSDisplayNode> GetRSDisplayNodeByScreenId(ScreenId dmsScreenId) const;
     void UpdateRSTree(ScreenId dmsScreenId, std::shared_ptr<RSSurfaceNode>& surfaceNode, bool isAdd);
@@ -66,7 +66,6 @@ public:
     bool MakeExpand(std::vector<ScreenId> screenIds, std::vector<Point> startPoints);
     void RemoveVirtualScreenFromGroup(std::vector<ScreenId> screens);
     void DumpScreenInfo() const;
-    void DumpScreenGroupInfo() const;
 
     // colorspace, gamut
     DMError GetScreenSupportedColorGamuts(ScreenId screenId, std::vector<ScreenColorGamut>& colorGamuts);
@@ -93,6 +92,12 @@ private:
         const std::vector<Point>& startPoints, bool filterScreen, ScreenCombination combination);
     void AddScreenToGroup(sptr<AbstractScreenGroup>, const std::vector<ScreenId>&,
         const std::vector<Point>&, std::map<ScreenId, bool>&);
+    void NotifyScreenConnected(sptr<ScreenInfo>) const;
+    void NotifyScreenDisconnected(ScreenId screenId) const;
+    void NotifyScreenChanged(sptr<ScreenInfo> screenInfo, ScreenChangeEvent event) const;
+    void NotifyScreenGroupChanged(const sptr<ScreenInfo>& screenInfo, ScreenGroupChangeEvent event) const;
+    void NotifyScreenGroupChanged(const std::vector<sptr<ScreenInfo>>& screenInfo, ScreenGroupChangeEvent event) const;
+    void DumpScreenGroupInfo() const;
 
     class ScreenIdManager {
     public:
@@ -114,12 +119,15 @@ private:
         std::map<ScreenId, ScreenId> dms2RsScreenIdMap_;
     };
 
+    const std::string CONTROLLER_THREAD_ID = "abstract_screen_controller_thread";
+
     std::recursive_mutex& mutex_;
     OHOS::Rosen::RSInterfaces& rsInterface_;
     ScreenIdManager screenIdManager_;
     std::map<ScreenId, sptr<AbstractScreen>> dmsScreenMap_;
     std::map<ScreenId, sptr<AbstractScreenGroup>> dmsScreenGroupMap_;
     sptr<AbstractScreenCallback> abstractScreenCallback_;
+    std::shared_ptr<AppExecFwk::EventHandler> controllerHandler_;
 };
 } // namespace OHOS::Rosen
 #endif // FOUNDATION_DMSERVER_ABSTRACT_SCREEN_CONTROLLER_H

dmserver/include/display_manager_agent_controller.h

@@ -36,7 +36,7 @@ public:
 
     void OnScreenConnect(sptr<ScreenInfo> screenInfo);
     void OnScreenDisconnect(ScreenId);
-    void OnScreenChange(const sptr<ScreenInfo>, ScreenChangeEvent);
+    void OnScreenChange(sptr<ScreenInfo>, ScreenChangeEvent);
     void OnScreenGroupChange(const sptr<ScreenInfo>&, ScreenGroupChangeEvent);
     void OnScreenGroupChange(const std::vector<sptr<ScreenInfo>>&, ScreenGroupChangeEvent);
     void OnDisplayCreate(sptr<DisplayInfo>);

dmserver/src/abstract_screen.cpp

@@ -200,7 +200,7 @@ void AbstractScreen::FillScreenInfo(sptr<ScreenInfo> info) const
     info->virtualHeight_ = height / virtualPixelRatio;
     info->virtualWidth_ = width / virtualPixelRatio;
     info->parent_ = groupDmsId_;
-    info->canHasChild_ = canHasChild_;
+    info->isScreenGroup_ = isScreenGroup_;
     info->rotation_ = rotation_;
     info->orientation_ = orientation_;
     info->type_ = type_;
@@ -250,7 +250,7 @@ AbstractScreenGroup::AbstractScreenGroup(sptr<AbstractScreenController> screenCo
     ScreenCombination combination) : AbstractScreen(screenController, "", dmsId, rsId), combination_(combination)
 {
     type_ = ScreenType::UNDEFINE;
-    canHasChild_ = true;
+    isScreenGroup_ = true;
 }
 
 AbstractScreenGroup::~AbstractScreenGroup()
@@ -358,6 +358,13 @@ bool AbstractScreenGroup::RemoveChild(sptr<AbstractScreen>& dmsScreen)
     }
     ScreenId screenId = dmsScreen->dmsId_;
     dmsScreen->groupDmsId_ = SCREEN_ID_INVALID;
+    if (rsDisplayNode_ != nullptr) {
+        rsDisplayNode_->RemoveFromTree();
+        auto transactionProxy = RSTransactionProxy::GetInstance();
+        if (transactionProxy != nullptr) {
+            transactionProxy->FlushImplicitTransaction();
+        }
+    }
     return abstractScreenMap_.erase(screenId);
 }
 

dmserver/src/abstract_screen_controller.cpp

@@ -23,17 +23,21 @@
 
 #include "display_manager_agent_controller.h"
 #include "display_manager_service.h"
+#include "event_runner.h"
 #include "window_manager_hilog.h"
 #include "wm_trace.h"
 
 namespace OHOS::Rosen {
 namespace {
     constexpr HiviewDFX::HiLogLabel LABEL = {LOG_CORE, HILOG_DOMAIN_DISPLAY, "AbstractScreenController"};
+    const std::string CONTROLLER_THREAD_ID = "abstract_screen_controller_thread";
 }
 
 AbstractScreenController::AbstractScreenController(std::recursive_mutex& mutex)
     : mutex_(mutex), rsInterface_(RSInterfaces::GetInstance())
 {
+    auto runner = AppExecFwk::EventRunner::Create(CONTROLLER_THREAD_ID);
+    controllerHandler_ = std::make_shared<AppExecFwk::EventHandler>(runner);
 }
 
 AbstractScreenController::~AbstractScreenController()
@@ -188,11 +192,17 @@ void AbstractScreenController::RegisterAbstractScreenCallback(sptr<AbstractScree
 void AbstractScreenController::OnRsScreenConnectionChange(ScreenId rsScreenId, ScreenEvent screenEvent)
 {
     WLOGFI("rs screen event. id:%{public}" PRIu64", event:%{public}u", rsScreenId, static_cast<uint32_t>(screenEvent));
-    std::lock_guard<std::recursive_mutex> lock(mutex_);
     if (screenEvent == ScreenEvent::CONNECTED) {
         ProcessScreenConnected(rsScreenId);
+        auto task = [this, rsScreenId] {
+            ProcessScreenConnected(rsScreenId);
+        };
+        controllerHandler_->PostTask(task, AppExecFwk::EventQueue::Priority::HIGH);
     } else if (screenEvent == ScreenEvent::DISCONNECTED) {
-        ProcessScreenDisconnected(rsScreenId);
+        auto task = [this, rsScreenId] {
+            ProcessScreenDisconnected(rsScreenId);
+        };
+        controllerHandler_->PostTask(task, AppExecFwk::EventQueue::Priority::HIGH);
     } else {
         WLOGE("unknown message:%{public}ud", static_cast<uint8_t>(screenEvent));
     }
@@ -219,6 +229,7 @@ void AbstractScreenController::ScreenConnectionInDisplayInit(sptr<AbstractScreen
 
 void AbstractScreenController::ProcessScreenConnected(ScreenId rsScreenId)
 {
+    std::lock_guard<std::recursive_mutex> lock(mutex_);
     if (!screenIdManager_.HasRsScreenId(rsScreenId)) {
         WLOGFD("connect new screen");
         auto absScreen = InitAndGetScreen(rsScreenId);
@@ -241,6 +252,7 @@ sptr<AbstractScreen> AbstractScreenController::InitAndGetScreen(ScreenId rsScree
         new(std::nothrow) AbstractScreen(this, DEFAULT_SCREEN_NAME, dmsScreenId, rsScreenId);
     if (absScreen == nullptr) {
         WLOGFE("new AbstractScreen failed.");
+        screenIdManager_.DeleteScreenId(dmsScreenId);
         return nullptr;
     }
     if (!FillAbstractScreen(absScreen, rsScreenId)) {
@@ -249,8 +261,7 @@ sptr<AbstractScreen> AbstractScreenController::InitAndGetScreen(ScreenId rsScree
         return nullptr;
     }
     dmsScreenMap_.insert(std::make_pair(dmsScreenId, absScreen));
-    // Switch threads to notify
-    DisplayManagerAgentController::GetInstance().OnScreenConnect(absScreen->ConvertToScreenInfo());
+    NotifyScreenConnected(absScreen->ConvertToScreenInfo());
     return absScreen;
 }
 
@@ -258,6 +269,7 @@ void AbstractScreenController::ProcessScreenDisconnected(ScreenId rsScreenId)
 {
     WLOGFI("disconnect screen, screenId=%{public}" PRIu64"", rsScreenId);
     ScreenId dmsScreenId;
+    std::lock_guard<std::recursive_mutex> lock(mutex_);
     if (!screenIdManager_.ConvertToDmsScreenId(rsScreenId, dmsScreenId)) {
         WLOGFE("disconnect screen, screenId=%{public}" PRIu64" is not in rs2DmsScreenIdMap_", rsScreenId);
         return;
@@ -268,17 +280,10 @@ void AbstractScreenController::ProcessScreenDisconnected(ScreenId rsScreenId)
             abstractScreenCallback_->onDisconnect_(dmsScreenMapIter->second);
         }
         RemoveFromGroupLocked(dmsScreenMapIter->second);
-        if (dmsScreenMapIter->second->rsDisplayNode_ != nullptr) {
-            dmsScreenMapIter->second->rsDisplayNode_->RemoveFromTree();
-            auto transactionProxy = RSTransactionProxy::GetInstance();
-            if (transactionProxy != nullptr) {
-                transactionProxy->FlushImplicitTransaction();
-            }
-        }
         dmsScreenMap_.erase(dmsScreenMapIter);
     }
     screenIdManager_.DeleteScreenId(dmsScreenId);
-    DisplayManagerAgentController::GetInstance().OnScreenDisconnect(dmsScreenId);
+    NotifyScreenDisconnected(dmsScreenId);
 }
 
 bool AbstractScreenController::FillAbstractScreen(sptr<AbstractScreen>& absScreen, ScreenId rsScreenId)
@@ -317,8 +322,7 @@ sptr<AbstractScreenGroup> AbstractScreenController::AddToGroupLocked(sptr<Abstra
         res = AddAsSuccedentScreenLocked(newScreen);
     }
     if (res != nullptr) {
-        DisplayManagerAgentController::GetInstance().OnScreenGroupChange(
-            newScreen->ConvertToScreenInfo(), ScreenGroupChangeEvent::ADD_TO_GROUP);
+        NotifyScreenGroupChanged(newScreen->ConvertToScreenInfo(), ScreenGroupChangeEvent::ADD_TO_GROUP);
     }
     return res;
 }
@@ -336,8 +340,7 @@ sptr<AbstractScreenGroup> AbstractScreenController::RemoveFromGroupLocked(sptr<A
     if (!RemoveChildFromGroup(screen, screenGroup)) {
         return nullptr;
     }
-    DisplayManagerAgentController::GetInstance().OnScreenGroupChange(
-        screen->ConvertToScreenInfo(), ScreenGroupChangeEvent::REMOVE_FROM_GROUP);
+    NotifyScreenGroupChanged(screen->ConvertToScreenInfo(), ScreenGroupChangeEvent::REMOVE_FROM_GROUP);
     return screenGroup;
 }
 
@@ -381,6 +384,7 @@ sptr<AbstractScreenGroup> AbstractScreenController::AddAsFirstScreenLocked(sptr<
         SCREEN_ID_INVALID, ScreenCombination::SCREEN_MIRROR);
     if (screenGroup == nullptr) {
         WLOGE("new AbstractScreenGroup failed");
+        screenIdManager_.DeleteScreenId(dmsGroupScreenId);
         return nullptr;
     }
     Point point;
@@ -442,6 +446,7 @@ ScreenId AbstractScreenController::CreateVirtualScreen(VirtualScreenOption optio
             sptr<SupportedScreenModes> info = new(std::nothrow) SupportedScreenModes();
             if (absScreen == nullptr || info == nullptr) {
                 WLOGFI("new AbstractScreen or SupportedScreenModes failed");
+                screenIdManager_.DeleteScreenId(dmsScreenId);
                 return SCREEN_ID_INVALID;
             }
             info->width_ = option.width_;
@@ -454,7 +459,7 @@ ScreenId AbstractScreenController::CreateVirtualScreen(VirtualScreenOption optio
             absScreen->activeIdx_ = 0;
             absScreen->type_ = ScreenType::VIRTUAL;
             dmsScreenMap_.insert(std::make_pair(dmsScreenId, absScreen));
-            DisplayManagerAgentController::GetInstance().OnScreenConnect(absScreen->ConvertToScreenInfo());
+            NotifyScreenConnected(absScreen->ConvertToScreenInfo());
         } else {
             WLOGI("CreateVirtualScreen is shot");
         }
@@ -471,7 +476,7 @@ DMError AbstractScreenController::DestroyVirtualScreen(ScreenId screenId)
     ScreenId rsScreenId = SCREEN_ID_INVALID;
     screenIdManager_.ConvertToRsScreenId(screenId, rsScreenId);
     if (rsScreenId != SCREEN_ID_INVALID && GetAbstractScreen(screenId) != nullptr) {
-        OnRsScreenConnectionChange(rsScreenId, ScreenEvent::DISCONNECTED);
+        ProcessScreenDisconnected(rsScreenId);
     }
     screenIdManager_.DeleteScreenId(screenId);
     if (rsScreenId != SCREEN_ID_INVALID) {
@@ -505,7 +510,7 @@ bool AbstractScreenController::SetOrientation(ScreenId screenId, Orientation new
         WLOGFE("fail to set orientation, cannot find screen %{public}" PRIu64"", screenId);
         return false;
     }
-    if (screen->canHasChild_) {
+    if (screen->isScreenGroup_) {
         WLOGE("cannot set orientation to the combination. screen: %{public}" PRIu64"", screenId);
         return false;
     }
@@ -531,8 +536,7 @@ bool AbstractScreenController::SetOrientation(ScreenId screenId, Orientation new
     screen->rotation_ = rotationAfter;
 
     // Notify rotation event to ScreenManager
-    DisplayManagerAgentController::GetInstance().OnScreenChange(
-        screen->ConvertToScreenInfo(), ScreenChangeEvent::UPDATE_ORIENTATION);
+    NotifyScreenChanged(screen->ConvertToScreenInfo(), ScreenChangeEvent::UPDATE_ORIENTATION);
     // Notify rotation event to AbstractDisplayController
     if (abstractScreenCallback_ != nullptr) {
         abstractScreenCallback_->onChange_(screen, DisplayChangeEvent::UPDATE_ORIENTATION);
@@ -595,12 +599,6 @@ DMError AbstractScreenController::SetScreenColorTransform(ScreenId screenId)
     return screen->SetScreenColorTransform();
 }
 
-bool AbstractScreenController::IsScreenGroup(ScreenId screenId) const
-{
-    std::lock_guard<std::recursive_mutex> lock(mutex_);
-    return dmsScreenGroupMap_.find(screenId) != dmsScreenGroupMap_.end();
-}
-
 bool AbstractScreenController::SetScreenActiveMode(ScreenId screenId, uint32_t modeId)
 {
     WLOGI("SetScreenActiveMode: RsScreenId: %{public}" PRIu64", modeId: %{public}u", screenId, modeId);
@@ -632,8 +630,7 @@ bool AbstractScreenController::SetScreenActiveMode(ScreenId screenId, uint32_t m
             ProcessScreenModeChanged(screenId);
             return;
         };
-        std::thread thread(func);
-        thread.detach();
+        controllerHandler_->PostTask(func, AppExecFwk::EventQueue::Priority::HIGH);
     }
     return true;
 }
@@ -661,8 +658,7 @@ void AbstractScreenController::ProcessScreenModeChanged(ScreenId dmsScreenId)
     if (absScreenCallback != nullptr) {
         absScreenCallback->onChange_(absScreen, DisplayChangeEvent::DISPLAY_SIZE_CHANGED);
     }
-    DisplayManagerAgentController::GetInstance().OnScreenChange(
-        absScreen->ConvertToScreenInfo(), ScreenChangeEvent::CHANGE_MODE);
+    NotifyScreenChanged(absScreen->ConvertToScreenInfo(), ScreenChangeEvent::CHANGE_MODE);
 }
 
 bool AbstractScreenController::MakeMirror(ScreenId screenId, std::vector<ScreenId> screens)
@@ -676,18 +672,15 @@ bool AbstractScreenController::MakeMirror(ScreenId screenId, std::vector<ScreenI
     WLOGFI("GetAbstractScreenGroup start");
     auto group = GetAbstractScreenGroup(screen->groupDmsId_);
     if (group == nullptr) {
-        WLOGFE("group is nullptr, try to get");
-        ScreenId defaultScreenId = GetDefaultAbstractScreenId();
-        auto defaultScreen = GetAbstractScreen(defaultScreenId);
-        if (defaultScreen == nullptr) {
-            WLOGFE("defaultScreen is nullptr");
-            return false;
-        }
-        group = GetAbstractScreenGroup(defaultScreen->groupDmsId_);
+        std::lock_guard<std::recursive_mutex> lock(mutex_);
+        sptr<AbstractScreenGroup> group = AddToGroupLocked(screen);
         if (group == nullptr) {
             WLOGFE("group is nullptr");
             return false;
         }
+        if (group != nullptr && abstractScreenCallback_ != nullptr) {
+            abstractScreenCallback_->onConnect_(screen);
+        }
     }
     WLOGFI("GetAbstractScreenGroup end");
     Point point;
@@ -706,6 +699,7 @@ void AbstractScreenController::ChangeScreenGroup(sptr<AbstractScreenGroup> group
     std::map<ScreenId, bool> removeChildResMap;
     std::vector<ScreenId> addScreens;
     std::vector<Point> addChildPos;
+    std::lock_guard<std::recursive_mutex> lock(mutex_);
     for (uint64_t i = 0; i != screens.size(); i++) {
         ScreenId screenId = screens[i];
         WLOGFI("ChangeScreenGroup: screenId: %{public}" PRIu64"", screenId);
@@ -761,14 +755,13 @@ void AbstractScreenController::AddScreenToGroup(sptr<AbstractScreenGroup> group,
         } else {
             WLOGFI("default, AddChild failed");
         }
-        abstractScreenCallback_->onConnect_(screen);
+        if (group != nullptr && abstractScreenCallback_ != nullptr) {
+            abstractScreenCallback_->onConnect_(screen);
+        }
     }
-    DisplayManagerAgentController::GetInstance().
-        OnScreenGroupChange(removeFromGroup, ScreenGroupChangeEvent::REMOVE_FROM_GROUP);
-    DisplayManagerAgentController::GetInstance().
-        OnScreenGroupChange(changeGroup, ScreenGroupChangeEvent::CHANGE_GROUP);
-    DisplayManagerAgentController::GetInstance().
-        OnScreenGroupChange(addToGroup, ScreenGroupChangeEvent::ADD_TO_GROUP);
+    NotifyScreenGroupChanged(removeFromGroup, ScreenGroupChangeEvent::REMOVE_FROM_GROUP);
+    NotifyScreenGroupChanged(changeGroup, ScreenGroupChangeEvent::CHANGE_GROUP);
+    NotifyScreenGroupChanged(addToGroup, ScreenGroupChangeEvent::ADD_TO_GROUP);
 }
 
 bool AbstractScreenController::MakeExpand(std::vector<ScreenId> screenIds, std::vector<Point> startPoints)
@@ -797,7 +790,7 @@ void AbstractScreenController::RemoveVirtualScreenFromGroup(std::vector<ScreenId
     std::vector<sptr<ScreenInfo>> removeFromGroup;
     for (ScreenId screenId : screens) {
         auto screen = GetAbstractScreen(screenId);
-        if (screen->type_ != ScreenType::VIRTUAL) {
+        if (screen == nullptr || screen->type_ != ScreenType::VIRTUAL) {
             continue;
         }
         auto originGroup = GetAbstractScreenGroup(screen->groupDmsId_);
@@ -811,12 +804,12 @@ void AbstractScreenController::RemoveVirtualScreenFromGroup(std::vector<ScreenId
         RemoveChildFromGroup(screen, originGroup);
         abstractScreenCallback_->onDisconnect_(screen);
     }
-    DisplayManagerAgentController::GetInstance().
-        OnScreenGroupChange(removeFromGroup, ScreenGroupChangeEvent::REMOVE_FROM_GROUP);
+    NotifyScreenGroupChanged(removeFromGroup, ScreenGroupChangeEvent::REMOVE_FROM_GROUP);
 }
 
 void AbstractScreenController::DumpScreenInfo() const
 {
+    std::lock_guard<std::recursive_mutex> lock(mutex_);
     WLOGI("-------- dump screen info begin---------");
     WLOGI("-------- the Screen Id Map Info---------");
     WLOGI("         DmsScreenId           RsScreenId");
@@ -959,4 +952,66 @@ ScreenId AbstractScreenController::ScreenIdManager::ConvertToDmsScreenId(ScreenI
     ConvertToDmsScreenId(dmsScreenId, dmsScreenId);
     return dmsScreenId;
 }
+
+void AbstractScreenController::NotifyScreenConnected(sptr<ScreenInfo> screenInfo) const
+{
+    if (screenInfo == nullptr) {
+        WLOGFE("NotifyScreenConnected error, screenInfo is nullptr.");
+        return;
+    }
+    auto task = [=] {
+        WLOGFI("NotifyScreenConnected,  screenId:%{public}" PRIu64"", screenInfo->GetScreenId());
+        DisplayManagerAgentController::GetInstance().OnScreenConnect(screenInfo);
+    };
+    controllerHandler_->PostTask(task, AppExecFwk::EventQueue::Priority::HIGH);
+}
+
+void AbstractScreenController::NotifyScreenDisconnected(ScreenId screenId) const
+{
+    auto task = [=] {
+        WLOGFI("NotifyScreenDisconnected,  screenId:%{public}" PRIu64"", screenId);
+        DisplayManagerAgentController::GetInstance().OnScreenDisconnect(screenId);
+    };
+    controllerHandler_->PostTask(task, AppExecFwk::EventQueue::Priority::HIGH);
+}
+
+void AbstractScreenController::NotifyScreenChanged(sptr<ScreenInfo> screenInfo, ScreenChangeEvent event) const
+{
+    if (screenInfo == nullptr) {
+        WLOGFE("NotifyScreenChanged error, screenInfo is nullptr.");
+        return;
+    }
+    auto task = [=] {
+        WLOGFI("NotifyScreenChanged,  screenId:%{public}" PRIu64"", screenInfo->GetScreenId());
+        DisplayManagerAgentController::GetInstance().OnScreenChange(screenInfo, event);
+    };
+    controllerHandler_->PostTask(task, AppExecFwk::EventQueue::Priority::HIGH);
+}
+
+void AbstractScreenController::NotifyScreenGroupChanged(
+    const sptr<ScreenInfo>& screenInfo, ScreenGroupChangeEvent event) const
+{
+    if (screenInfo == nullptr) {
+        WLOGFE("NotifyScreenGroupChanged error, screenInfo is nullptr.");
+        return;
+    }
+    auto task = [=] {
+        WLOGFI("NotifyScreenGroupChanged,  screenId:%{public}" PRIu64"", screenInfo->GetScreenId());
+        DisplayManagerAgentController::GetInstance().OnScreenGroupChange(screenInfo, event);
+    };
+    controllerHandler_->PostTask(task, AppExecFwk::EventQueue::Priority::HIGH);
+}
+
+void AbstractScreenController::NotifyScreenGroupChanged(
+    const std::vector<sptr<ScreenInfo>>& screenInfo, ScreenGroupChangeEvent event) const
+{
+    if (screenInfo.empty()) {
+        return;
+    }
+    auto task = [=] {
+        WLOGFI("NotifyScreenGroupChanged");
+        DisplayManagerAgentController::GetInstance().OnScreenGroupChange(screenInfo, event);
+    };
+    controllerHandler_->PostTask(task, AppExecFwk::EventQueue::Priority::HIGH);
+}
 } // namespace OHOS::Rosen

dmserver/src/display_manager_agent_controller.cpp

@@ -88,8 +88,7 @@ void DisplayManagerAgentController::OnScreenDisconnect(ScreenId screenId)
     }
 }
 
-void DisplayManagerAgentController::OnScreenChange(const sptr<ScreenInfo> screenInfo,
-    ScreenChangeEvent screenChangeEvent)
+void DisplayManagerAgentController::OnScreenChange(sptr<ScreenInfo> screenInfo, ScreenChangeEvent screenChangeEvent)
 {
     if (screenInfo == nullptr) {
         return;

dmserver/src/display_manager_stub.cpp

@@ -180,10 +180,6 @@ int32_t DisplayManagerStub::OnRemoteRequest(uint32_t code, MessageParcel &data,
         case TRANS_ID_GET_SCREEN_INFO_BY_ID: {
             ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
             auto screenInfo = GetScreenInfoById(screenId);
-            for (auto& mode : screenInfo->GetModes()) {
-                WLOGFI("info modes is width: %{public}u, height: %{public}u, refreshRate: %{public}u",
-                    mode->width_, mode->height_, mode->refreshRate_);
-            }
             reply.WriteStrongParcelable(screenInfo);
             break;
         }

interfaces/innerkits/dm/screen.h

@@ -52,7 +52,7 @@ struct VirtualScreenOption {
 };
 
 struct ExpandOption {
-    uint32_t screenId_;
+    ScreenId screenId_;
     uint32_t startX_;
     uint32_t startY_;
 };

interfaces/innerkits/dm/screen_group.h

@@ -43,7 +43,8 @@ public:
 private:
     // No more methods or variables can be defined here.
     ScreenGroup(sptr<ScreenGroupInfo> info);
-    void UpdateScreenGroupInfo(sptr<ScreenGroupInfo> info);
+    void UpdateScreenGroupInfo(sptr<ScreenGroupInfo> info) const;
+    void UpdateScreenGroupInfo() const;
     class Impl;
     sptr<Impl> pImpl_;
 };

utils/include/screen_info.h

@@ -41,13 +41,13 @@ public:
     DEFINE_VAR_DEFAULT_FUNC_GET(ScreenId, RsScreenId, rsId, SCREEN_ID_INVALID);
     DEFINE_VAR_DEFAULT_FUNC_GET(uint32_t, VirtualWidth, virtualWidth, 0);
     DEFINE_VAR_DEFAULT_FUNC_GET(uint32_t, VirtualHeight, virtualHeight, 0);
-    DEFINE_VAR_DEFAULT_FUNC_GET(float, VirtualPixelRatio, virtualPixelRatio, 0.0f);
-    DEFINE_VAR_DEFAULT_FUNC_GET(ScreenId, ParentId, parent, 0);
-    DEFINE_VAR_DEFAULT_FUNC_GET(bool, CanHasChild, canHasChild, false);
+    DEFINE_VAR_DEFAULT_FUNC_GET(float, VirtualPixelRatio, virtualPixelRatio, 1.0f);
+    DEFINE_VAR_DEFAULT_FUNC_GET(ScreenId, ParentId, parent, SCREEN_ID_INVALID);
+    DEFINE_VAR_DEFAULT_FUNC_GET(bool, IsScreenGroup, isScreenGroup, false);
     DEFINE_VAR_DEFAULT_FUNC_GET(Rotation, Rotation, rotation, Rotation::ROTATION_0);
     DEFINE_VAR_DEFAULT_FUNC_GET(Orientation, Orientation, orientation, Orientation::UNSPECIFIED);
-    DEFINE_VAR_DEFAULT_FUNC_GET(ScreenType, Type, type, ScreenType::REAL);
-    DEFINE_VAR_DEFAULT_FUNC_GET_SET(uint32_t, ModeId, modeId, 0);
+    DEFINE_VAR_DEFAULT_FUNC_GET(ScreenType, Type, type, ScreenType::UNDEFINE);
+    DEFINE_VAR_DEFAULT_FUNC_GET(uint32_t, ModeId, modeId, 0);
     DEFINE_VAR_FUNC_GET(std::vector<sptr<SupportedScreenModes>>, Modes, modes);
 protected:
     ScreenInfo() = default;

utils/src/screen_info.cpp

@@ -21,7 +21,7 @@ bool ScreenInfo::Marshalling(Parcel &parcel) const
     bool res = parcel.WriteString(name_) && parcel.WriteUint64(id_) && parcel.WriteUint64(rsId_) &&
         parcel.WriteUint32(virtualWidth_) && parcel.WriteUint32(virtualHeight_) &&
         parcel.WriteFloat(virtualPixelRatio_) && parcel.WriteUint64(parent_) &&
-        parcel.WriteBool(canHasChild_) && parcel.WriteUint32(static_cast<uint32_t>(rotation_)) &&
+        parcel.WriteBool(isScreenGroup_) && parcel.WriteUint32(static_cast<uint32_t>(rotation_)) &&
         parcel.WriteUint32(static_cast<uint32_t>(orientation_)) &&
         parcel.WriteUint32(static_cast<uint32_t>(type_)) &&
         parcel.WriteUint32(modeId_) && parcel.WriteUint32(static_cast<uint32_t>(modes_.size()));
@@ -60,7 +60,7 @@ bool ScreenInfo::InnerUnmarshalling(Parcel& parcel)
     bool res1 = parcel.ReadUint64(id_) && parcel.ReadUint64(rsId_) &&
         parcel.ReadUint32(virtualWidth_) && parcel.ReadUint32(virtualHeight_) &&
         parcel.ReadFloat(virtualPixelRatio_) && parcel.ReadUint64(parent_) &&
-        parcel.ReadBool(canHasChild_) && parcel.ReadUint32(rotation) &&
+        parcel.ReadBool(isScreenGroup_) && parcel.ReadUint32(rotation) &&
         parcel.ReadUint32(orientation) && parcel.ReadUint32(type) &&
         parcel.ReadUint32(modeId_) && parcel.ReadUint32(size);
     if (!res1) {