From 74f31bf083378aa49c76d95a50cab785069f6b64 Mon Sep 17 00:00:00 2001
From: lu <zhaolu2@huawei.com>
Date: Thu, 13 Jan 2022 21:18:06 +0800
Subject: [PATCH] Get Screen form RSScreen

Signed-off-by: lu <zhaolu2@huawei.com>
Change-Id: Ic6b05286f50d5db12d8a99c154500d0720e3bdeb
---
 dm/src/screen_group.cpp                       |   6 +-
 dm/src/screen_manager.cpp                     |   4 +
 .../include/abstract_display_controller.h     |  22 ++-
 dmserver/include/abstract_screen.h            |  32 ++++-
 dmserver/include/abstract_screen_controller.h |  35 +++--
 dmserver/include/display_manager_service.h    |   3 +-
 dmserver/src/abstract_display_controller.cpp  |  54 ++++++-
 dmserver/src/abstract_screen.cpp              |  32 +++++
 dmserver/src/abstract_screen_controller.cpp   | 133 +++++++++++++-----
 dmserver/src/display_manager_service.cpp      |  17 ++-
 interfaces/innerkits/dm/screen_group.h        |   4 +-
 interfaces/innerkits/dm/screen_manager.h      |   1 +
 wm/BUILD.gn                                   |   2 +
 13 files changed, 269 insertions(+), 76 deletions(-)

diff --git a/dm/src/screen_group.cpp b/dm/src/screen_group.cpp
index 6b8ee375f3..9ac0d71c0c 100644
--- a/dm/src/screen_group.cpp
+++ b/dm/src/screen_group.cpp
@@ -24,7 +24,7 @@ private:
 
     std::vector<sptr<Screen>> children_;
     std::vector<Point> position_;
-    ScreenType type_ { ScreenType::SCREEN_ALONE };
+    ScreenCombination combination_ { ScreenCombination::SCREEN_ALONE };
 };
 
 ScreenGroup::ScreenGroup()
@@ -36,9 +36,9 @@ ScreenGroup::~ScreenGroup()
 {
 }
 
-ScreenType ScreenGroup::GetType() const
+ScreenCombination ScreenGroup::GetCombination() const
 {
-    return pImpl_->type_;
+    return pImpl_->combination_;
 }
 
 std::vector<sptr<Screen>> ScreenGroup::GetChildren() const
diff --git a/dm/src/screen_manager.cpp b/dm/src/screen_manager.cpp
index 9278df3f0b..b8e076f884 100644
--- a/dm/src/screen_manager.cpp
+++ b/dm/src/screen_manager.cpp
@@ -48,6 +48,10 @@ std::vector<const sptr<Screen>> ScreenManager::GetAllScreens()
     return res;
 }
 
+void ScreenManager::RegisterScreenChangeListener(sptr<IScreenChangeListener> listener)
+{
+}
+
 sptr<ScreenGroup> ScreenManager::makeExpand(std::vector<ScreenId> screenId, std::vector<Point> startPoint)
 {
     return nullptr;
diff --git a/dmserver/include/abstract_display_controller.h b/dmserver/include/abstract_display_controller.h
index 67c8e53512..0ece7f31ac 100644
--- a/dmserver/include/abstract_display_controller.h
+++ b/dmserver/include/abstract_display_controller.h
@@ -19,29 +19,37 @@
 #include <map>
 #include <pixel_map.h>
 #include <surface.h>
+#include <transaction/rs_interfaces.h>
 
 #include "abstract_display.h"
-#include "wm_single_instance.h"
+#include "abstract_screen_controller.h"
 #include "transaction/rs_interfaces.h"
 #include "virtual_display_info.h"
 
 namespace OHOS::Rosen {
-class AbstractDisplayController {
-WM_DECLARE_SINGLE_INSTANCE_BASE(AbstractDisplayController);
+class AbstractDisplayController : public RefBase {
 public:
-    std::map<int32_t, sptr<AbstractDisplay>> abstractDisplayMap_;
+    AbstractDisplayController(std::recursive_mutex& mutex);
+    ~AbstractDisplayController();
 
+    void Init(sptr<AbstractScreenController> abstractScreenController);
     ScreenId GetDefaultScreenId();
     RSScreenModeInfo GetScreenActiveMode(ScreenId id);
     ScreenId CreateVirtualScreen(const VirtualDisplayInfo &virtualDisplayInfo, sptr<Surface> surface);
     bool DestroyVirtualScreen(ScreenId screenId);
     sptr<Media::PixelMap> GetScreenSnapshot(ScreenId screenId);
 
+    std::map<DisplayId, sptr<AbstractDisplay>> abstractDisplayMap_;
 private:
-    AbstractDisplayController();
-    ~AbstractDisplayController();
-    void parepareRSScreenManger();
+    void OnAbstractScreenConnected(sptr<AbstractScreen> absScreen);
+    void OnAbstractScreenDisconnected(sptr<AbstractScreen> absScreen);
+    void OnAbstractScreenChanged(sptr<AbstractScreen> absScreen);
+    void CreateAndBindDisplayLocked(sptr<AbstractScreen> absScreen);
 
+    std::recursive_mutex& mutex_;
+    volatile DisplayId displayCount_;
+    sptr<AbstractScreenController> abstractScreenController_;
+    sptr<AbstractScreenController::AbstractScreenCallback> abstractScreenCallback_;
     OHOS::Rosen::RSInterfaces *rsInterface_;
 };
 } // namespace OHOS::Rosen
diff --git a/dmserver/include/abstract_screen.h b/dmserver/include/abstract_screen.h
index 6c3112190e..9b9a0c3e60 100644
--- a/dmserver/include/abstract_screen.h
+++ b/dmserver/include/abstract_screen.h
@@ -16,29 +16,52 @@
 #ifndef FOUNDATION_DMSERVER_ABSTRACT_SCREEN_H
 #define FOUNDATION_DMSERVER_ABSTRACT_SCREEN_H
 
+#include <vector>
+
 #include <refbase.h>
 #include <screen_manager/screen_types.h>
 
 namespace OHOS::Rosen {
+constexpr static ScreenId SCREEN_ID_INVALID = INVALID_SCREEN_ID;
+
 struct Point {
     int32_t posX_;
     int32_t posY_;
 };
 
-enum class AbstractScreenType : uint32_t {
+enum class ScreenCombination : uint32_t {
     SCREEN_ALONE,
     SCREEN_EXPAND,
     SCREEN_MIRROR,
 };
 
+enum class ScreenType : uint32_t {
+    UNDEFINE,
+    REAL,
+    VIRTUAL
+};
+
+struct AbstractScreenInfo : public RefBase {
+    int32_t width_;
+    int32_t height_;
+    uint32_t freshRate_;
+};
+
+class AbstractScreenGroup;
 class AbstractScreen : public RefBase {
 public:
     AbstractScreen(ScreenId dmsId, ScreenId rsId);
     AbstractScreen() = delete;
     ~AbstractScreen();
 
+    sptr<AbstractScreenGroup> GetGroup() const;
+
     ScreenId dmsId_;
     ScreenId rsId_;
+    ScreenId groupDmsId_;
+    ScreenType type_ { ScreenType::REAL };
+    int32_t activeIdx_;
+    std::vector<sptr<AbstractScreenInfo>> infos_ = {};
 };
 
 class AbstractScreenGroup : public AbstractScreen {
@@ -47,9 +70,14 @@ public:
     AbstractScreenGroup() = delete;
     ~AbstractScreenGroup();
 
-    AbstractScreenType GetType() const;
+    void AddChild(ScreenCombination combination, sptr<AbstractScreen>& dmsScreen, Point& startPoint);
+    void AddChild(ScreenCombination combination,
+        std::vector<sptr<AbstractScreen>>& dmsScreens,
+        std::vector<Point>& startPoints);
     std::vector<sptr<AbstractScreen>> GetChildren() const;
     std::vector<Point> GetChildrenPosition() const;
+
+    ScreenCombination combination_ { ScreenCombination::SCREEN_ALONE };
 };
 } // namespace OHOS::Rosen
 #endif // FOUNDATION_DMSERVER_ABSTRACT_SCREEN_H
\ No newline at end of file
diff --git a/dmserver/include/abstract_screen_controller.h b/dmserver/include/abstract_screen_controller.h
index 394dcac4fc..4d5d185c3b 100644
--- a/dmserver/include/abstract_screen_controller.h
+++ b/dmserver/include/abstract_screen_controller.h
@@ -27,38 +27,43 @@
 
 namespace OHOS::Rosen {
 class AbstractScreenController : public RefBase {
-using OnAbstractScreenCallback = std::function<void(ScreenId)>;
-struct AbstractScreenCallback : public RefBase {
-    OnAbstractScreenCallback onConnected_;
-    OnAbstractScreenCallback onDisconnected_;
-    OnAbstractScreenCallback onChanged_;
-};
-
+using OnAbstractScreenCallback = std::function<void(sptr<AbstractScreen>)>;
 public:
+    struct AbstractScreenCallback : public RefBase {
+        OnAbstractScreenCallback onConnected_;
+        OnAbstractScreenCallback onDisconnected_;
+        OnAbstractScreenCallback onChanged_;
+    };
+
     AbstractScreenController(std::recursive_mutex& mutex);
     ~AbstractScreenController();
 
+    void Init();
     std::vector<ScreenId> GetAllScreenIds();
-    std::shared_ptr<std::vector<ScreenId>> ConvertToRsScreenId(ScreenId dmsScreenId);
-    std::shared_ptr<std::vector<ScreenId>> ConvertToDmsScreenId(ScreenId rsScreenId);
+    sptr<AbstractScreen> GetAbstractScreen(ScreenId dmsScreenId);
+    sptr<AbstractScreenGroup> GetAbstractScreenGroup(ScreenId dmsScreenId);
+    ScreenId ConvertToRsScreenId(ScreenId dmsScreenId);
+    ScreenId ConvertToDmsScreenId(ScreenId rsScreenId);
     void RegisterAbstractScreenCallback(sptr<AbstractScreenCallback> cb);
 
     std::map<ScreenId, sptr<AbstractScreen>> abstractDisplayMap_;
 
 private:
-    void PrepareRSScreenManger();
     void OnRsScreenChange(ScreenId rsScreenId, ScreenEvent screenEvent);
-    void AddToGroup(sptr<AbstractScreen> newScreen);
-    void AddAsFirstScreenLocked(sptr<AbstractScreen> newScreen);
+    bool FillAbstractScreen(sptr<AbstractScreen>& absScreen, ScreenId rsScreenId);
+    sptr<AbstractScreenGroup> AddToGroupLocked(sptr<AbstractScreen> newScreen);
+    sptr<AbstractScreenGroup> AddAsFirstScreenLocked(sptr<AbstractScreen> newScreen);
     void AddAsSuccedentScreenLocked(sptr<AbstractScreen> newScreen);
 
     std::recursive_mutex& mutex_;
     RSInterfaces& rsInterface_;
     volatile ScreenId dmsScreenCount_;
-    std::map<ScreenId, std::shared_ptr<std::vector<ScreenId>>> rs2DmsScreenIdMap_;
-    std::map<ScreenId, std::shared_ptr<std::vector<ScreenId>>> dms2RsScreenIdMap_;
+    // No AbstractScreenGroup
+    std::map<ScreenId, ScreenId> rs2DmsScreenIdMap_;
+    std::map<ScreenId, ScreenId> dms2RsScreenIdMap_;
     std::map<ScreenId, sptr<AbstractScreen>> dmsScreenMap_;
-    ScreenId defaultScreenId_ {INVALID_SCREEN_ID};
+    std::map<ScreenId, sptr<AbstractScreenGroup>> dmsScreenGroupMap_;
+    ScreenId defaultDmsScreenId_ { SCREEN_ID_INVALID };
     sptr<AbstractScreenCallback> abstractScreenCallback_;
 };
 } // namespace OHOS::Rosen
diff --git a/dmserver/include/display_manager_service.h b/dmserver/include/display_manager_service.h
index f1c17fa5f4..395a22c9e8 100644
--- a/dmserver/include/display_manager_service.h
+++ b/dmserver/include/display_manager_service.h
@@ -62,7 +62,8 @@ private:
     std::recursive_mutex mutex_;
     static inline SingletonDelegator<DisplayManagerService> delegator_;
     std::map<int32_t, sptr<AbstractDisplay>> abstractDisplayMap_;
-    AbstractScreenController screenController_ = AbstractScreenController(mutex_);
+    sptr<AbstractScreenController> abstractScreenController_;
+    sptr<AbstractDisplayController> abstractDisplayController_;
     DisplayPowerController displayPowerController_;
 };
 } // namespace OHOS::Rosen
diff --git a/dmserver/src/abstract_display_controller.cpp b/dmserver/src/abstract_display_controller.cpp
index 40f24ba2a1..d03bcec0fa 100644
--- a/dmserver/src/abstract_display_controller.cpp
+++ b/dmserver/src/abstract_display_controller.cpp
@@ -18,6 +18,7 @@
 #include <cinttypes>
 #include <surface.h>
 
+#include "display_manager_service.h"
 #include "window_manager_hilog.h"
 
 namespace OHOS::Rosen {
@@ -25,18 +26,29 @@ namespace {
     constexpr HiviewDFX::HiLogLabel LABEL = {LOG_CORE, 0, "AbstractDisplayController"};
 }
 
-AbstractDisplayController::AbstractDisplayController() : rsInterface_(&(RSInterfaces::GetInstance()))
+AbstractDisplayController::AbstractDisplayController(std::recursive_mutex& mutex)
+    : mutex_(mutex), rsInterface_(&(RSInterfaces::GetInstance()))
 {
-    parepareRSScreenManger();
 }
 
 AbstractDisplayController::~AbstractDisplayController()
 {
     rsInterface_ = nullptr;
+    abstractScreenController_ = nullptr;
 }
 
-void AbstractDisplayController::parepareRSScreenManger()
+void AbstractDisplayController::Init(sptr<AbstractScreenController> abstractScreenController)
 {
+    WLOGFD("display controller init");
+    displayCount_ = 0;
+    abstractScreenCallback_ = new AbstractScreenController::AbstractScreenCallback();
+    abstractScreenCallback_->onConnected_
+        = std::bind(&AbstractDisplayController::OnAbstractScreenConnected, this, std::placeholders::_1);
+    abstractScreenCallback_->onDisconnected_
+        = std::bind(&AbstractDisplayController::OnAbstractScreenDisconnected, this, std::placeholders::_1);
+    abstractScreenCallback_->onChanged_
+        = std::bind(&AbstractDisplayController::OnAbstractScreenChanged, this, std::placeholders::_1);
+    abstractScreenController->RegisterAbstractScreenCallback(abstractScreenCallback_);
 }
 
 ScreenId AbstractDisplayController::GetDefaultScreenId()
@@ -60,7 +72,7 @@ ScreenId AbstractDisplayController::CreateVirtualScreen(const VirtualDisplayInfo
     sptr<Surface> surface)
 {
     if (rsInterface_ == nullptr) {
-        return INVALID_SCREEN_ID;
+        return SCREEN_ID_INVALID;
     }
     ScreenId result = rsInterface_->CreateVirtualScreen(virtualDisplayInfo.name_, virtualDisplayInfo.width_,
         virtualDisplayInfo.height_, surface, virtualDisplayInfo.displayIdToMirror_, virtualDisplayInfo.flags_);
@@ -88,4 +100,38 @@ sptr<Media::PixelMap> AbstractDisplayController::GetScreenSnapshot(ScreenId scre
 
     return screenshot;
 }
+
+void AbstractDisplayController::OnAbstractScreenConnected(sptr<AbstractScreen> absScreen)
+{
+    WLOGI("connect new screen. id:%{public}" PRIu64"", absScreen->dmsId_);
+    std::lock_guard<std::recursive_mutex> lock(mutex_);
+    if (absScreen->type_ == ScreenType::REAL) {
+        sptr<AbstractScreenGroup> group = absScreen->GetGroup();
+        if (group == nullptr) {
+            WLOGE("the group information of the screen is wrong");
+            return;
+        }
+        if (group->combination_ == ScreenCombination::SCREEN_ALONE) {
+            CreateAndBindDisplayLocked(absScreen);
+        } else if (group->combination_ == ScreenCombination::SCREEN_MIRROR) {
+            
+        } else {
+            WLOGE("support in future. combination:%{public}ud", group->combination_);
+        }
+    }
+}
+
+void AbstractDisplayController::OnAbstractScreenDisconnected(sptr<AbstractScreen> absScreen)
+{
+}
+
+void AbstractDisplayController::OnAbstractScreenChanged(sptr<AbstractScreen> absScreen)
+{
+}
+
+void AbstractDisplayController::CreateAndBindDisplayLocked(sptr<AbstractScreen> absScreen)
+{
+    WLOGI("create display for new screen id:%{public}" PRIu64"", absScreen->dmsId_);
+    displayCount_++;
+}
 } // namespace OHOS::Rosen
\ No newline at end of file
diff --git a/dmserver/src/abstract_screen.cpp b/dmserver/src/abstract_screen.cpp
index 72c7b87869..5538b535c1 100644
--- a/dmserver/src/abstract_screen.cpp
+++ b/dmserver/src/abstract_screen.cpp
@@ -15,6 +15,8 @@
 
 #include "abstract_screen.h"
 
+#include "abstract_screen_controller.h"
+
 namespace OHOS::Rosen {
 AbstractScreen::AbstractScreen(ScreenId dmsId, ScreenId rsId)
     : dmsId_(dmsId), rsId_(rsId)
@@ -25,11 +27,41 @@ AbstractScreen::~AbstractScreen()
 {
 }
 
+sptr<AbstractScreenGroup> AbstractScreen::GetGroup() const
+{
+    //sptr<AbstractScreenGroup> group = AbstractScreenController::GetInstance().GetAbstractScreenGroup(groupDmsId_);
+    //return group;
+    return nullptr;
+}
+
 AbstractScreenGroup::AbstractScreenGroup(ScreenId dmsId, ScreenId rsId) : AbstractScreen(dmsId, rsId)
 {
+    type_ = ScreenType::UNDEFINE;
 }
 
 AbstractScreenGroup::~AbstractScreenGroup()
 {
 }
+
+void AbstractScreenGroup::AddChild(ScreenCombination type, sptr<AbstractScreen>& dmsScreen, Point& startPoint)
+{
+}
+
+void AbstractScreenGroup::AddChild(ScreenCombination type,
+    std::vector<sptr<AbstractScreen>>& dmsScreens,
+    std::vector<Point>& startPoints)
+{
+}
+
+std::vector<sptr<AbstractScreen>> AbstractScreenGroup::GetChildren() const
+{
+    std::vector<sptr<AbstractScreen>> tmp;
+    return tmp;
+}
+
+std::vector<Point> AbstractScreenGroup::GetChildrenPosition() const
+{
+    std::vector<Point> tmp;
+    return tmp;
+}
 } // namespace OHOS::Rosen
\ No newline at end of file
diff --git a/dmserver/src/abstract_screen_controller.cpp b/dmserver/src/abstract_screen_controller.cpp
index 8144c6da97..7b9c91952b 100644
--- a/dmserver/src/abstract_screen_controller.cpp
+++ b/dmserver/src/abstract_screen_controller.cpp
@@ -16,6 +16,7 @@
 #include "abstract_screen_controller.h"
 
 #include <cinttypes>
+#include <screen_manager/rs_screen_mode_info.h>
 #include <screen_manager/screen_types.h>
 #include <surface.h>
 
@@ -30,69 +31,90 @@ namespace {
 AbstractScreenController::AbstractScreenController(std::recursive_mutex& mutex)
     : mutex_(mutex), rsInterface_(RSInterfaces::GetInstance())
 {
-    dmsScreenCount_ = 0;
-    // TODO : PrepareRSScreenManger
 }
 
 AbstractScreenController::~AbstractScreenController()
 {
 }
 
+void AbstractScreenController::Init()
+{
+    WLOGFD("screen controller init");
+    dmsScreenCount_ = 0;
+    rsInterface_.SetScreenChangeCallback(
+        std::bind(&AbstractScreenController::OnRsScreenChange, this, std::placeholders::_1, std::placeholders::_2));
+}
+
 std::vector<ScreenId> AbstractScreenController::GetAllScreenIds()
 {
     std::vector<ScreenId> tmp;
     return tmp;
 }
 
-std::shared_ptr<std::vector<ScreenId>> AbstractScreenController::ConvertToRsScreenId(ScreenId dmsScreenId)
+sptr<AbstractScreen> AbstractScreenController::GetAbstractScreen(ScreenId dmsScreenId)
 {
-    std::lock_guard<std::recursive_mutex> lock(mutex_);
-    std::shared_ptr<std::vector<ScreenId>> empty = std::make_shared<std::vector<ScreenId>>();
-    return empty;
+    auto iter = dmsScreenMap_.find(dmsScreenId);
+    if (iter == dmsScreenMap_.end()) {
+        WLOGE("didnot find screen:%{public}" PRIu64"", dmsScreenId);
+        return nullptr;
+    }
+    sptr<AbstractScreen> screen = iter->second;
+    return screen;
+}
+
+sptr<AbstractScreenGroup> AbstractScreenController::GetAbstractScreenGroup(ScreenId dmsScreenId)
+{
+    auto iter = dmsScreenGroupMap_.find(dmsScreenId);
+    if (iter == dmsScreenGroupMap_.end()) {
+        WLOGE("didnot find screen:%{public}" PRIu64"", dmsScreenId);
+        return nullptr;
+    }
+    sptr<AbstractScreenGroup> screen = iter->second;
+    return screen;
 }
 
-std::shared_ptr<std::vector<ScreenId>> AbstractScreenController::ConvertToDmsScreenId(ScreenId rsScreenId)
+ScreenId AbstractScreenController::ConvertToRsScreenId(ScreenId dmsScreenId)
 {
     std::lock_guard<std::recursive_mutex> lock(mutex_);
-    std::shared_ptr<std::vector<ScreenId>> empty = std::make_shared<std::vector<ScreenId>>();
-    return empty;
+    return SCREEN_ID_INVALID;
 }
 
-void AbstractScreenController::RegisterAbstractScreenCallback(sptr<AbstractScreenCallback> cb)
+ScreenId AbstractScreenController::ConvertToDmsScreenId(ScreenId rsScreenId)
 {
     std::lock_guard<std::recursive_mutex> lock(mutex_);
-    abstractScreenCallback_ = cb;
+    return SCREEN_ID_INVALID;
 }
 
-void AbstractScreenController::PrepareRSScreenManger()
+void AbstractScreenController::RegisterAbstractScreenCallback(sptr<AbstractScreenCallback> cb)
 {
-    {
-        std::lock_guard<std::recursive_mutex> lock(mutex_);
-        defaultScreenId_ = rsInterface_.GetDefaultScreenId();
-    }
-    rsInterface_.SetScreenChangeCallback(
-        std::bind(&AbstractScreenController::OnRsScreenChange, this, std::placeholders::_1, std::placeholders::_2));
+    std::lock_guard<std::recursive_mutex> lock(mutex_);
+    abstractScreenCallback_ = cb;
 }
 
 void AbstractScreenController::OnRsScreenChange(ScreenId rsScreenId, ScreenEvent screenEvent)
 {
+    WLOGFI("rs screen event. id:%{public}" PRIu64", event:%{public}ud", rsScreenId, static_cast<uint32_t>(screenEvent));
     ScreenId dmsScreenId = INVALID_SCREEN_ID;
     std::lock_guard<std::recursive_mutex> lock(mutex_);
     if (screenEvent == ScreenEvent::CONNECTED) {
         auto iter = rs2DmsScreenIdMap_.find(rsScreenId);
         if (iter == rs2DmsScreenIdMap_.end()) {
-            dmsScreenId = dmsScreenCount_++;
-            std::shared_ptr<std::vector<ScreenId>> dmsVector = std::make_shared<std::vector<ScreenId>>();
-            dmsVector->push_back(dmsScreenId);
-            rs2DmsScreenIdMap_.insert(std::make_pair(rsScreenId, dmsVector));
-            std::shared_ptr<std::vector<ScreenId>> rsVector = std::make_shared<std::vector<ScreenId>>();
-            dmsVector->push_back(rsScreenId);
-            dms2RsScreenIdMap_.insert(std::make_pair(dmsScreenId, rsVector));
+            WLOGFD("connect new screen. dmsId:%{public}" PRIu64"", dmsScreenId);
+            dmsScreenId = dmsScreenCount_;
             sptr<AbstractScreen> absScreen = new AbstractScreen(dmsScreenId, rsScreenId);
+            if (!FillAbstractScreen(absScreen, rsScreenId)) {
+                return;
+            }
+            rs2DmsScreenIdMap_.insert(std::make_pair(rsScreenId, dmsScreenId));
+            dms2RsScreenIdMap_.insert(std::make_pair(dmsScreenId, rsScreenId));
             dmsScreenMap_.insert(std::make_pair(dmsScreenId, absScreen));
-            // TODO: rsInterface_.GetScreenActiveMode()
-            // TODO: rsInterface_.GetScreenSupportedModes()
-            AddToGroup(absScreen);
+            dmsScreenCount_++;
+            sptr<AbstractScreenGroup> screenGroup = AddToGroupLocked(absScreen);
+            if (screenGroup != nullptr && abstractScreenCallback_ != nullptr) {
+                abstractScreenCallback_->onConnected_(absScreen);
+            }
+        } else {
+            WLOGE("reconnect screen, screenId=%{public}" PRIu64"", rsScreenId);
         }
     } else if (screenEvent == ScreenEvent::DISCONNECTED) {
         WLOGI("connect screen");
@@ -101,22 +123,61 @@ void AbstractScreenController::OnRsScreenChange(ScreenId rsScreenId, ScreenEvent
     }
 }
 
-void AbstractScreenController::AddToGroup(sptr<AbstractScreen> newScreen)
+bool AbstractScreenController::FillAbstractScreen(sptr<AbstractScreen>& absScreen, ScreenId rsScreenId)
 {
-    std::lock_guard<std::recursive_mutex> lock(mutex_);
-    auto iter = dmsScreenMap_.find(defaultScreenId_);
-    if (iter == dmsScreenMap_.end()) {
-        WLOGE("did not find default screen screenId:%{public}" PRIu64"", defaultScreenId_);
-        AddAsFirstScreenLocked(newScreen);
+    std::vector<RSScreenModeInfo> allModes = rsInterface_.GetScreenSupportedModes(rsScreenId);
+    if (allModes.size() == 0) {
+        WLOGE("supported screen mode is 0, screenId=%{public}" PRIu64"", rsScreenId);
+        return false;
+    }
+    for (RSScreenModeInfo rsScreenModeInfo : allModes) {
+        sptr<AbstractScreenInfo> info = new AbstractScreenInfo();
+        info->width_ = rsScreenModeInfo.GetScreenWidth();
+        info->height_ = rsScreenModeInfo.GetScreenHeight();
+        info->freshRate_ = rsScreenModeInfo.GetScreenFreshRate();
+        absScreen->infos_.push_back(info);
+        WLOGD("fill screen w/h:%{public}d/%{public}d", info->width_, info->height_);
+    }
+    int32_t activeModeId = rsInterface_.GetScreenActiveMode(rsScreenId).GetScreenModeId();
+    WLOGD("fill screen activeModeId:%{public}d", activeModeId);
+    if (activeModeId >= allModes.size()) {
+        WLOGE("activeModeId exceed, screenId=%{public}" PRIu64", activeModeId:%{public}d/%{public}d",
+            rsScreenId, activeModeId, allModes.size());
+        return false;
+    }
+    absScreen->activeIdx_ = activeModeId;
+    return true;
+}
+
+sptr<AbstractScreenGroup> AbstractScreenController::AddToGroupLocked(sptr<AbstractScreen> newScreen)
+{
+    if (defaultDmsScreenId_ == SCREEN_ID_INVALID) {
+        WLOGE("connect the first screen");
+        return AddAsFirstScreenLocked(newScreen);
     } else {
-        sptr<AbstractScreen> defaultScreen = iter->second;
         AddAsSuccedentScreenLocked(newScreen);
+        return nullptr;
     }
 }
 
-void AbstractScreenController::AddAsFirstScreenLocked(sptr<AbstractScreen> newScreen)
+sptr<AbstractScreenGroup> AbstractScreenController::AddAsFirstScreenLocked(sptr<AbstractScreen> newScreen)
 {
     // TODO: Create default display
+    ScreenId dmsGroupScreenId = dmsScreenCount_++;
+    sptr<AbstractScreenGroup> sreenGroup = new AbstractScreenGroup(dmsGroupScreenId, SCREEN_ID_INVALID);
+    Point point;
+    sreenGroup->AddChild(ScreenCombination::SCREEN_ALONE, newScreen, point);
+    newScreen->groupDmsId_ = dmsGroupScreenId;
+    auto iter = dmsScreenGroupMap_.find(dmsGroupScreenId);
+    if (iter != dmsScreenGroupMap_.end()) {
+        WLOGE("group screen existed. id=%{public}" PRIu64"", dmsGroupScreenId);
+        dmsScreenGroupMap_.erase(iter);
+    }
+    dmsScreenGroupMap_.insert(std::make_pair(dmsGroupScreenId, sreenGroup));
+    dmsScreenMap_.insert(std::make_pair(dmsGroupScreenId, sreenGroup));
+    WLOGI("connect new group screen. id=%{public}" PRIu64"/%{public}" PRIu64", combination:%{public}ud",
+        newScreen->dmsId_, dmsGroupScreenId, newScreen->type_);
+    return sreenGroup;
 }
 
 void AbstractScreenController::AddAsSuccedentScreenLocked(sptr<AbstractScreen> newScreen)
diff --git a/dmserver/src/display_manager_service.cpp b/dmserver/src/display_manager_service.cpp
index 3825b07401..94791e6368 100644
--- a/dmserver/src/display_manager_service.cpp
+++ b/dmserver/src/display_manager_service.cpp
@@ -31,7 +31,10 @@ namespace {
 
 const bool REGISTER_RESULT = SystemAbility::MakeAndRegisterAbility(&SingletonContainer::Get<DisplayManagerService>());
 
-DisplayManagerService::DisplayManagerService() : SystemAbility(DISPLAY_MANAGER_SERVICE_SA_ID, true)
+DisplayManagerService::DisplayManagerService() : 
+    SystemAbility(DISPLAY_MANAGER_SERVICE_SA_ID, true),
+    abstractScreenController_(new AbstractScreenController(mutex_)),
+    abstractDisplayController_(new AbstractDisplayController(mutex_))
 {
 }
 
@@ -51,6 +54,8 @@ bool DisplayManagerService::Init()
         WLOGFW("DisplayManagerService::Init failed");
         return false;
     }
+    abstractScreenController_->Init();
+    abstractDisplayController_->Init(abstractScreenController_);
     WLOGFI("DisplayManagerService::Init success");
     return true;
 }
@@ -67,7 +72,7 @@ ScreenId DisplayManagerService::GetScreenIdFromDisplayId(DisplayId displayId)
 
 DisplayId DisplayManagerService::GetDefaultDisplayId()
 {
-    ScreenId screenId = AbstractDisplayController::GetInstance().GetDefaultScreenId();
+    ScreenId screenId = abstractDisplayController_->GetDefaultScreenId();
     WLOGFI("GetDefaultDisplayId %{public}" PRIu64"", screenId);
     return GetDisplayIdFromScreenId(screenId);
 }
@@ -76,7 +81,7 @@ DisplayInfo DisplayManagerService::GetDisplayInfoById(DisplayId displayId)
 {
     DisplayInfo displayInfo;
     ScreenId screenId = GetScreenIdFromDisplayId(displayId);
-    auto screenModeInfo = AbstractDisplayController::GetInstance().GetScreenActiveMode(screenId);
+    auto screenModeInfo = abstractDisplayController_->GetScreenActiveMode(screenId);
     displayInfo.id_ = displayId;
     displayInfo.width_ = screenModeInfo.GetScreenWidth();
     displayInfo.height_ = screenModeInfo.GetScreenHeight();
@@ -90,7 +95,7 @@ DisplayId DisplayManagerService::CreateVirtualDisplay(const VirtualDisplayInfo &
     WLOGFI("name %{public}s, width %{public}u, height %{public}u, mirrotId %{public}" PRIu64", flags %{public}d",
         virtualDisplayInfo.name_.c_str(), virtualDisplayInfo.width_, virtualDisplayInfo.height_,
         virtualDisplayInfo.displayIdToMirror_, virtualDisplayInfo.flags_);
-    ScreenId screenId = AbstractDisplayController::GetInstance().CreateVirtualScreen(virtualDisplayInfo, surface);
+    ScreenId screenId = abstractDisplayController_->CreateVirtualScreen(virtualDisplayInfo, surface);
     return GetDisplayIdFromScreenId(screenId);
 }
 
@@ -98,13 +103,13 @@ bool DisplayManagerService::DestroyVirtualDisplay(DisplayId displayId)
 {
     WLOGFI("DisplayManagerService::DestroyVirtualDisplay");
     ScreenId screenId = GetScreenIdFromDisplayId(displayId);
-    return AbstractDisplayController::GetInstance().DestroyVirtualScreen(screenId);
+    return abstractDisplayController_->DestroyVirtualScreen(screenId);
 }
 
 sptr<Media::PixelMap> DisplayManagerService::GetDispalySnapshot(DisplayId displayId)
 {
     ScreenId screenId = GetScreenIdFromDisplayId(displayId);
-    sptr<Media::PixelMap> screenSnapshot = AbstractDisplayController::GetInstance().GetScreenSnapshot(screenId);
+    sptr<Media::PixelMap> screenSnapshot = abstractDisplayController_->GetScreenSnapshot(screenId);
     return screenSnapshot;
 }
 
diff --git a/interfaces/innerkits/dm/screen_group.h b/interfaces/innerkits/dm/screen_group.h
index df7346d173..50e2a0d04b 100644
--- a/interfaces/innerkits/dm/screen_group.h
+++ b/interfaces/innerkits/dm/screen_group.h
@@ -21,7 +21,7 @@
 #include "screen.h"
 
 namespace OHOS::Rosen {
-enum class ScreenType : uint32_t {
+enum class ScreenCombination : uint32_t {
     SCREEN_ALONE,
     SCREEN_EXPAND,
     SCREEN_MIRROR,
@@ -29,7 +29,7 @@ enum class ScreenType : uint32_t {
 
 class ScreenGroup : public Screen {
 public:
-    ScreenType GetType() const;
+    ScreenCombination GetCombination() const;
     std::vector<sptr<Screen>> GetChildren() const;
     std::vector<Point> GetChildrenPosition() const;
 
diff --git a/interfaces/innerkits/dm/screen_manager.h b/interfaces/innerkits/dm/screen_manager.h
index ece342b836..7900ef8bc0 100644
--- a/interfaces/innerkits/dm/screen_manager.h
+++ b/interfaces/innerkits/dm/screen_manager.h
@@ -34,6 +34,7 @@ WM_DECLARE_SINGLE_INSTANCE_BASE(ScreenManager);
 public:
     sptr<Screen> GetScreenById(ScreenId id);
     std::vector<const sptr<Screen>> GetAllScreens();
+    void RegisterScreenChangeListener(sptr<IScreenChangeListener> listener);
     sptr<ScreenGroup> makeExpand(std::vector<ScreenId> screenId, std::vector<Point> startPoint);
     sptr<ScreenGroup> makeMirror(ScreenId mainScreenId, std::vector<ScreenId> mirrorScreenId);
     sptr<Screen> createVirtualScreen(VirtualScreenOption option);
diff --git a/wm/BUILD.gn b/wm/BUILD.gn
index cde38987b4..2dd8b71b0a 100644
--- a/wm/BUILD.gn
+++ b/wm/BUILD.gn
@@ -109,6 +109,8 @@ ohos_shared_library("libwm") {
     "../dm/src/display_manager.cpp",
     "../dm/src/display_manager_adapter.cpp",
     "../dm/src/screen.cpp",
+    "../dm/src/screen_group.cpp",
+    "../dm/src/screen_manager.cpp",
     "../dmserver/src/display_manager_proxy.cpp",
     "../wmserver/src/window_manager_proxy.cpp",
     "src/input_transfer_station.cpp",
-- 
Gitee