diff --git a/window_scene/screen_session_manager/BUILD.gn b/window_scene/screen_session_manager/BUILD.gn
index d2f89128ab798ad8539db502c72c4ed038bd4485..fd617354e9e11efea38f8771a64b7bb0439ee87e 100644
--- a/window_scene/screen_session_manager/BUILD.gn
+++ b/window_scene/screen_session_manager/BUILD.gn
@@ -136,6 +136,7 @@ ohos_shared_library("screen_session_manager") {
     "init:libbeget_proxy",
     "ipc:ipc_core",
     "libxml2:libxml2",
+    "os_account:os_account_innerkits",
     "safwk:system_ability_fwk",
     "samgr:samgr_proxy",
     "screenlock_mgr:screenlock_client",
diff --git a/window_scene/screen_session_manager/include/fold_screen_controller/secondary_display_fold_policy.h b/window_scene/screen_session_manager/include/fold_screen_controller/secondary_display_fold_policy.h
index f135dc97634f31da30001e54233a90b477b206fa..d86637ec9f77d60136dba6ca84716dbfebd625ba 100644
--- a/window_scene/screen_session_manager/include/fold_screen_controller/secondary_display_fold_policy.h
+++ b/window_scene/screen_session_manager/include/fold_screen_controller/secondary_display_fold_policy.h
@@ -54,7 +54,8 @@ private:
     void SendPropertyChangeResult(sptr<ScreenSession> screenSession, ScreenId screenId,
         ScreenPropertyChangeReason reason, FoldDisplayMode displayMode);
     void SetStatusConditionalActiveRectAndTpFeature(ScreenProperty &screenProperty);
-    void SetStatusFullActiveRectAndTpFeature(const sptr<ScreenSession>& screenSession, ScreenProperty &screenProperty);
+    void SetStatusFullActiveRectAndTpFeature(const sptr<ScreenSession>& screenSession, ScreenProperty& screenProperty,
+        bool isNeedToSetSwitch = true);
     void SetStatusMainActiveRectAndTpFeature(const sptr<ScreenSession>& screenSession, ScreenProperty &screenProperty);
     void SetStatusGlobalFullActiveRectAndTpFeature(const sptr<ScreenSession>& screenSession,
         ScreenProperty &screenProperty);
diff --git a/window_scene/screen_session_manager/include/screen_edid_parse.h b/window_scene/screen_session_manager/include/screen_edid_parse.h
index 376b982c7deff081c51a5adac2881c549a5ecc3a..4efb7153cd631e699f183c468d403e18bf599bc7 100644
--- a/window_scene/screen_session_manager/include/screen_edid_parse.h
+++ b/window_scene/screen_session_manager/include/screen_edid_parse.h
@@ -73,6 +73,7 @@ using ParseEdidFunc = int32_t (*)(const uint8_t*, const uint32_t, struct BaseEdi
 bool LoadEdidPlugin(void);
 void UnloadEdidPlugin(void);
 bool GetEdid(ScreenId screenId, struct BaseEdid &edid);
+bool GetEdid(ScreenId rsScreenId, struct BaseEdid &edid);
 int32_t GetEdidCheckCode(const std::vector<uint8_t>& edidData);
 }
 }
diff --git a/window_scene/screen_session_manager/include/screen_scene_config.h b/window_scene/screen_session_manager/include/screen_scene_config.h
index 820fdfabfed64e415868d6a6fd755b61a4ecb66d..74a5627b4b8a590f5ceef4c3b32ab45043911295 100644
--- a/window_scene/screen_session_manager/include/screen_scene_config.h
+++ b/window_scene/screen_session_manager/include/screen_scene_config.h
@@ -24,6 +24,20 @@
 #include "libxml/parser.h"
 
 namespace OHOS::Rosen {
+struct DisplayFlag {
+    std::string type;
+    int value;
+};
+
+struct DisplayConfig {
+    ScreenId physicalDisplayId;
+    ScreenId logicalId;
+    std::string name;
+    int dpi;
+    DisplayFlag flag;
+    bool hasFlag = false;
+};
+
 class ScreenSceneConfig : public RefBase, public XmlConfigBase {
 public:
     ScreenSceneConfig() = delete;
@@ -34,7 +48,9 @@ public:
     static const std::map<std::string, std::vector<int>>& GetIntNumbersConfig();
     static const std::map<std::string, std::string>& GetStringConfig();
     static const std::map<std::string, std::vector<std::string>>& GetStringListConfig();
+    static const std::vector<DisplayConfig>& GetDisplayConfigs();
     static void DumpConfig();
+    static void DumpDisplaysConfigs();
     static std::vector<DMRect> GetCutoutBoundaryRect(uint64_t displayId);
     static std::vector<DMRect> GetSubCutoutBoundaryRect();
     static void SetCutoutSvgPath(uint64_t displayId, const std::string& svgPath);
@@ -52,6 +68,7 @@ public:
     static bool IsSupportOffScreenRendering();
     static uint32_t GetOffScreenPPIThreshold();
     static bool IsSupportDuringCall();
+    static bool IsConcurrentUser();
 
 private:
     static std::map<int32_t, std::string> xmlNodeMap_;
@@ -60,6 +77,7 @@ private:
     static std::map<std::string, std::string> stringConfig_;
     static std::map<uint64_t, std::vector<DMRect>> cutoutBoundaryRectMap_;
     static std::map<std::string, std::vector<std::string>> stringListConfig_;
+    static std::vector<DisplayConfig> displaysConfigs_;
     static std::vector<DMRect> subCutoutBoundaryRect_;
     static bool isWaterfallDisplay_;
     static bool isScreenCompressionEnableInLandscape_;
@@ -68,6 +86,7 @@ private:
     static std::map<FoldDisplayMode, ScrollableParam> scrollableParams_;
     static bool isSupportCapture_;
     static bool isSupportOffScreenRendering_;
+    static bool isConcurrentUser_;
     static uint32_t offScreenPPIThreshold_;
 
     static bool IsValidNode(const xmlNode& currNode);
@@ -83,6 +102,8 @@ private:
     static DMRect CalcCutoutBoundaryRect(const std::string svgPath);
     static void ReadPhysicalDisplayConfigInfo(const xmlNodePtr& currNode);
     static void ReadScrollableParam(const xmlNodePtr& currNode);
+    static void ParseDisplaysConfig(const xmlNodePtr& currPtr);
+    static bool ParseFlagsConfig(const xmlNodePtr& flagsNode, DisplayFlag& outFlags)
 };
 } // namespace OHOS::Rosen
 #endif // OHOS_ROSEN_SCREEN_SCENE_CONFIG_H
diff --git a/window_scene/screen_session_manager/include/screen_session_manager.h b/window_scene/screen_session_manager/include/screen_session_manager.h
index ca778ddaa5a972a7de6adc43323384c94651b94b..3754e7d1fe8a871cb869512c2dc39593b2c86551 100644
--- a/window_scene/screen_session_manager/include/screen_session_manager.h
+++ b/window_scene/screen_session_manager/include/screen_session_manager.h
@@ -515,6 +515,7 @@ private:
     void OnHgmRefreshRateChange(uint32_t refreshRate);
     sptr<ScreenSession> GetOrCreateScreenSession(ScreenId screenId);
     void CreateScreenProperty(ScreenId screenId, ScreenProperty& property);
+    static std::string GetScreenName(ScreenId screenId);
     void InitScreenProperty(ScreenId screenId, RSScreenModeInfo& screenMode,
         RSScreenCapability& screenCapability, ScreenProperty& property);
     RRect GetScreenBounds(ScreenId screenId, RSScreenModeInfo& screenMode);
@@ -563,6 +564,7 @@ private:
     ScreenRotation ConvertOffsetToCorrectRotation(int32_t phyOffset);
     Rotation ConvertIntToRotation(int32_t rotation);
     void MultiScreenModeChange(ScreenId mainScreenId, ScreenId secondaryScreenId, const std::string& operateType);
+    void SetClientInner(int32_t userId, const sptr<IScreenSessionManagerClient>& client);
     void OperateModeChange(ScreenId mainScreenId, ScreenId secondaryScreenId, sptr<ScreenSession>& firstSession,
         sptr<ScreenSession>& secondarySession, const std::string& operateMode);
     void SetClientInner(int32_t newUserId);
@@ -647,6 +649,14 @@ private:
     void SetGotScreenOffAndWakeUpBlock();
     void WakeUpPictureFrameBlock(DisplayEvent event);
 
+    /**
+     * multi user concurrency
+     */
+    static bool GetConcurrentUser();
+    void ActiveUser(int32_t userId);
+    DisplayId GetUserDisplayId(int32_t userId);
+    int32_t GetActiveUserByDisplayId(DisplayId displayId);
+    ScreenId GenerateSmsScreenId(ScreenId rsScreenId);
     class ScreenIdManager {
     friend class ScreenSessionGroup;
     public:
@@ -685,6 +695,16 @@ private:
     int32_t currentScbPId_ { -1 };
     int32_t switchId_ { -1 };
     std::vector<int32_t> oldScbPids_ {};
+    std::map<int32_t, sptr<IScreenSessionManagerClient>> multiClientProxyMap_;
+
+    /*
+        example:
+        user100:    screen0 active=0
+        user101:    screen0 active=1
+        user102:    screen1 active=1
+    */
+    std::map<int32_t, std::pair<bool, ScreenId>> userScreenMap_;
+    std::mutex userScreenMapMutex_;
     std::map<int32_t, sptr<IScreenSessionManagerClient>> clientProxyMap_;
     FoldDisplayMode oldScbDisplayMode_ = FoldDisplayMode::UNKNOWN;
 
diff --git a/window_scene/screen_session_manager/src/fold_screen_controller/secondary_display_fold_policy.cpp b/window_scene/screen_session_manager/src/fold_screen_controller/secondary_display_fold_policy.cpp
index ba1892a016c58c59a65073209798ea32a67f35b2..d1b555fec9ae9c0d6c48b7aa44eeaae55b148a2d 100644
--- a/window_scene/screen_session_manager/src/fold_screen_controller/secondary_display_fold_policy.cpp
+++ b/window_scene/screen_session_manager/src/fold_screen_controller/secondary_display_fold_policy.cpp
@@ -43,7 +43,7 @@ const int32_t GLOBAL_FULL_STATUS_WIDTH = 2;
 const int32_t SCREEN_HEIGHT = 3;
 const int32_t FULL_STATUS_OFFSET_X = 4;
 constexpr uint32_t HALF_DIVIDER = 2;
-constexpr float MAIN_DISPLAY_ROTATION_DEGREE = 180;
+constexpr float MAIN_DISPLAY_ROTATION_DEGREE = -270;
 constexpr float ROTATION_TRANSLATE_X = 612;
 constexpr float ROTATION_TRANSLATE_Y = -612;
 constexpr float FULL_NODE_POSITION_Z = 0.0f;
@@ -501,12 +501,18 @@ void SecondaryDisplayFoldPolicy::SendPropertyChangeResult(sptr<ScreenSession> sc
 {
     std::lock_guard<std::recursive_mutex> lock_info(displayInfoMutex_);
     screenProperty_ = ScreenSessionManager::GetInstance().GetPhyScreenProperty(screenId);
+    bool isNeedNotifyFoldProperty = true;
+    bool isNeedToSetSwitch = true;
     switch (displayMode) {
         case FoldDisplayMode::FULL: {
             if (currentDisplayMode_ == FoldDisplayMode::COORDINATION) {
+                if (currentFoldStatus_ == FoldStatus::EXPAND) {
+                    isNeedToSetSwitch = false;
+                    isNeedNotifyFoldProperty = false;
+                }
                 CloseCoordinationScreen();
             }
-            SetStatusFullActiveRectAndTpFeature(screenSession, screenProperty_);
+            SetStatusFullActiveRectAndTpFeature(screenSession, screenProperty_, isNeedToSetSwitch);
             break;
         }
         case FoldDisplayMode::MAIN: {
@@ -526,6 +532,7 @@ void SecondaryDisplayFoldPolicy::SendPropertyChangeResult(sptr<ScreenSession> sc
         }
         case FoldDisplayMode::COORDINATION: {
             if (currentDisplayMode_ == FoldDisplayMode::FULL) {
+                isNeedNotifyFoldProperty = false;
                 ChangeScreenDisplayModeToCoordination();
                 SetStatusConditionalActiveRectAndTpFeature(screenProperty_);
             }
@@ -542,14 +549,20 @@ void SecondaryDisplayFoldPolicy::SendPropertyChangeResult(sptr<ScreenSession> sc
     if (displayMode == FoldDisplayMode::MAIN) {
         screenSession->SetRotationAndScreenRotationOnly(Rotation::ROTATION_0);
     }
-    screenSession->PropertyChange(oldScreenProperty, reason);
+
+    if (isNeedNotifyFoldProperty) {
+        screenSession->PropertyChange(oldScreenProperty, reason);
+    } else {
+        TLOGI(WmsLogTag::DMS, "PropertyChange...set displayModeChangeStatus");
+        SetSecondaryDisplayModeChangeStatus(false);
+    }
     TLOGI(WmsLogTag::DMS, "screenBounds : width_= %{public}f, height_= %{public}f",
         screenSession->GetScreenProperty().GetBounds().rect_.width_,
         screenSession->GetScreenProperty().GetBounds().rect_.height_);
 }
 
 void SecondaryDisplayFoldPolicy::SetStatusFullActiveRectAndTpFeature(const sptr<ScreenSession>& screenSession,
-    ScreenProperty &screenProperty)
+    ScreenProperty &screenProperty, bool isNeedToSetSwitch)
 {
     if (screenParams_.size() < FULL_STATUS_OFFSET_X + 1) {
         return;
@@ -566,7 +579,9 @@ void SecondaryDisplayFoldPolicy::SetStatusFullActiveRectAndTpFeature(const sptr<
         .h = screenParams_[FULL_STATUS_WIDTH],
     };
     if (!onBootAnimation_) {
-        RSInterfaces::GetInstance().NotifyScreenSwitched();
+        if (isNeedToSetSwitch) {
+            RSInterfaces::GetInstance().NotifyScreenSwitched();
+        }
         auto response = RSInterfaces::GetInstance().SetScreenActiveRect(0, rectCur);
         TLOGI(WmsLogTag::DMS, "rs response is %{public}ld", static_cast<long>(response));
     }
diff --git a/window_scene/screen_session_manager/src/screen_edid_parse.cpp b/window_scene/screen_session_manager/src/screen_edid_parse.cpp
index c44c90911886c1da2f62a36da465c1c2751c8e62..407af35d3e9bfdb0f2cc9160806e663a298c176f 100644
--- a/window_scene/screen_session_manager/src/screen_edid_parse.cpp
+++ b/window_scene/screen_session_manager/src/screen_edid_parse.cpp
@@ -55,11 +55,11 @@ void UnloadEdidPlugin(void)
     }
 }
 
-bool GetEdid(ScreenId screenId, struct BaseEdid &edid)
+bool GetEdid(ScreenId rsScreenId, struct BaseEdid &edid)
 {
     std::vector<uint8_t> edidData;
     uint8_t outPort;
-    int getEdidFromRS = RSInterfaces::GetInstance().GetDisplayIdentificationData(screenId, outPort, edidData);
+    int getEdidFromRS = RSInterfaces::GetInstance().GetDisplayIdentificationData(rsScreenId, outPort, edidData);
     if (getEdidFromRS != 0) {
         TLOGE(WmsLogTag::DMS, "get EDID from RS failed.");
         return false;
diff --git a/window_scene/screen_session_manager/src/screen_scene_config.cpp b/window_scene/screen_session_manager/src/screen_scene_config.cpp
index 55b5bed497ca4fbd49a1caeaeb6514a2af94ffc9..fbb6ddd345e22bb880168c3fdd1608338787719d 100644
--- a/window_scene/screen_session_manager/src/screen_scene_config.cpp
+++ b/window_scene/screen_session_manager/src/screen_scene_config.cpp
@@ -31,6 +31,7 @@
 #include "include/core/SkPath.h"
 #include "include/core/SkPathMeasure.h"
 #include "include/utils/SkParsePath.h"
+#include "screen_session_manager.h"
 #include "window_manager_hilog.h"
 
 namespace OHOS::Rosen {
@@ -45,6 +46,7 @@ enum XmlNodeElement {
     CURVED_SCREEN_BOUNDARY,
     CURVED_AREA_IN_LANDSCAPE,
     IS_CURVED_COMPRESS_ENABLED,
+    IS_CON_CURRENT_USER,
     BUILD_IN_DEFAULT_ORIENTATION,
     DEFAULT_DEVICE_ROTATION_OFFSET,
     DEFAULT_DISPLAY_CUTOUT_PATH,
@@ -77,17 +79,20 @@ std::map<std::string, std::vector<std::string>> ScreenSceneConfig::stringListCon
 std::map<uint64_t, std::vector<DMRect>> ScreenSceneConfig::cutoutBoundaryRectMap_;
 std::vector<DisplayPhysicalResolution> ScreenSceneConfig::displayPhysicalResolution_;
 std::map<FoldDisplayMode, ScrollableParam> ScreenSceneConfig::scrollableParams_;
+std::vector<DisplayConfig> ScreenSceneConfig::displaysConfigs_;
 std::vector<DMRect> ScreenSceneConfig::subCutoutBoundaryRect_;
 bool ScreenSceneConfig::isWaterfallDisplay_ = false;
 bool ScreenSceneConfig::isSupportCapture_ = false;
 bool ScreenSceneConfig::isScreenCompressionEnableInLandscape_ = false;
 bool ScreenSceneConfig::isSupportOffScreenRendering_ = false;
+bool ScreenSceneConfig::isConcurrentUser_ = false;
 uint32_t ScreenSceneConfig::curvedAreaInLandscape_ = 0;
 uint32_t ScreenSceneConfig::offScreenPPIThreshold_ = 0;
 std::map<int32_t, std::string> ScreenSceneConfig::xmlNodeMap_ = {
     {DPI, "dpi"},
     {SUB_DPI, "subDpi"},
     {IS_WATERFALL_DISPLAY, "isWaterfallDisplay"},
+    {IS_CON_CURRENT_USER, "concurrentUser"},
     {CURVED_SCREEN_BOUNDARY, "curvedScreenBoundary"},
     {CURVED_AREA_IN_LANDSCAPE, "waterfallAreaCompressionSizeWhenHorzontal"},
     {IS_CURVED_COMPRESS_ENABLED, "isWaterfallAreaCompressionEnableWhenHorizontal"},
@@ -115,7 +120,6 @@ std::map<int32_t, std::string> ScreenSceneConfig::xmlNodeMap_ = {
     {SUPPORT_DURING_CALL, "supportDuringCall"}
 };
 
-
 std::vector<std::string> ScreenSceneConfig::Split(std::string str, std::string pattern)
 {
     std::vector<std::string> result;
@@ -151,9 +155,10 @@ std::string ScreenSceneConfig::GetConfigPath(const std::string& configFileName)
     char* configPath = GetOneCfgFile(configFileName.c_str(), buf, PATH_MAX + 1);
     char tmpPath[PATH_MAX + 1] = { 0 };
     if (!configPath || strlen(configPath) == 0 || strlen(configPath) > PATH_MAX || !realpath(configPath, tmpPath)) {
-        TLOGI(WmsLogTag::DMS, "can not get customization config file");
+        TLOGW(WmsLogTag::DMS, "can not get customization config file");
         return "/system/" + configFileName;
     }
+    TLOGW(WmsLogTag::DMS, "get customization config file success");
     return std::string(tmpPath);
 }
 
@@ -183,6 +188,12 @@ bool ScreenSceneConfig::LoadConfigXml()
             continue;
         }
         ParseNodeConfig(curNodePtr);
+        if (xmlStrcmp(currNodePtr->name, reinterpret_cast<const xmlChar*>("displays")) != 0) {
+            ParseNodeConfig(curNodePtr);
+        } else {
+            TLOGI(WmsLogTag::DMS, "find displays keyword, reading the nested content of XML");
+            ParseDisplaysConfig(curNodePtr);
+        }
     }
     xmlFreeDoc(docPtr);
     return true;
@@ -195,6 +206,7 @@ void ScreenSceneConfig::ParseNodeConfig(const xmlNodePtr& currNode)
         (xmlNodeMap_[IS_CURVED_COMPRESS_ENABLED] == nodeName) ||
         (xmlNodeMap_[IS_RIGHT_POWER_BUTTON] == nodeName) ||
         (xmlNodeMap_[IS_SUPPORT_CAPTURE] == nodeName) ||
+        (xmlNodeMap_[IS_CON_CURRENT_USER] == nodeName) ||
         (xmlNodeMap_[SUPPORT_ROTATE_WITH_SCREEN] == nodeName)||
         (xmlNodeMap_[IS_SUPPORT_OFFSCREEN_RENDERING] == nodeName) ||
         (xmlNodeMap_[SUPPORT_DURING_CALL] == nodeName);
@@ -232,6 +244,63 @@ void ScreenSceneConfig::ParseNodeConfig(const xmlNodePtr& currNode)
     }
 }
 
+void ScreenSceneConfig::ParseDisplaysConfig(const xmlNodePtr& currNode)
+{
+    for (xmlNodePtr displayNode = currNode->xmlChildrenNode; displayNode != nullptr; displayNode = displayNode->next) {
+        if (!IsValidNode(*displayNode) ||
+            xmlStrcmp(displayNode->name, reinterpret_cast<const xmlChar*>("display")) != 0) {
+            continue;
+        }
+        DisplayConfig config;
+        TLOGI(WmsLogTag::DMS, "start parse displays config");
+        for (xmlNodePtr fileNode = displayNode->xmlChildrenNode; fileNode != nullptr; fileNode = fileNode->next) {
+            if (!IsValidNode(*fileNode)) {
+                continue;
+            }
+            const char* nodeName = reinterpret_cast<const char*>(fileNode->name);
+            xmlChar* context = xmlNodeGetContent(fileNode);
+            if (strcmp(nodeName, "physicalId") == 0) {
+                config.physicalDisplayId = static_cast<ScreenId>(std::stoull(reinterpret_cast<const char*>(context)));
+            } else if (strcmp(nodeName, "logicalId") == 0) {
+                config.logicalId = static_cast<ScreenId>(std::stoull(reinterpret_cast<const char*>(context)));
+            } else if (strcmp(nodeName, "name") == 0) {
+                config.name = reinterpret_cast<const char*>(context);
+            } else if (strcmp(nodeName, "dpi") == 0) {
+                config.dpi = atoi(reinterpret_cast<const char*>(context));
+            } else if (strcmp(nodeName, "flag") == 0) {
+                if (ParseFlagConfig(fileNode, config.flag)) {
+                    config.hasFlag = true;
+                } else {
+                    config.hasFlag = false;
+                }
+            }
+            if (content) xmlFree(content);
+        }
+        displaysConfigs_.push_back(config);
+    }
+}
+
+bool ScreenSceneConfig::ParseFlagsConfig(const xmlNodePtr& flagsNode, DisplayFlag& outFlag)
+{
+    bool foundFlag = false;
+    for (xmlNodePtr flagNode = flagsNode->xmlChildrenNode; flagNode != nullptr; flagNode = flagNode->next) {
+        if (!IsValidNode(*flagNode) || xmlStrcmp(flagNode->name, reinterpret_cast<const xmlChar*>("flag")) != 0) {
+            continue;
+        }
+        xmlChar* typeAttr = xmlGetProp(flagNode, reinterpret_cast<const xmlChar*>("type"));
+        xmlChar* valueAttr = xmlGetProp(flagNode, reinterpret_cast<const xmlChar*>("value"));
+        if (typeAttr && valueAttr) {
+            outFlag.type = reinterpret_cast<const char*>(typeAttr);
+            outFlag.value = atoi(reinterpret_cast<const char*>(valueAttr));
+            foundFlag = true;
+            break;
+        }
+        if (typeAttr) xmlFree(typeAttr);
+        if (valueAttr) xmlFree(valueAttr);
+    }
+    return foundFlag;
+}
+
 bool ScreenSceneConfig::IsValidNode(const xmlNode& currNode)
 {
     if (currNode.name == nullptr || currNode.type == XML_COMMENT_NODE) {
@@ -409,6 +478,8 @@ void ScreenSceneConfig::ReadEnableConfigInfo(const xmlNodePtr& currNode)
             isSupportCapture_ = true;
         } else if (xmlNodeMap_[IS_SUPPORT_OFFSCREEN_RENDERING] == nodeName) {
             isSupportOffScreenRendering_ = true;
+        } else if (xmlNodeMap_[IS_CONCURRENT_USER] == nodeName) {
+            isConcurrentUser_ = true;
         }
     } else {
         enableConfig_[nodeName] = false;
@@ -478,6 +549,11 @@ const std::map<std::string, std::vector<std::string>>& ScreenSceneConfig::GetStr
     return stringListConfig_;
 }
 
+const std::vector<DisplayConfig>& ScreenSceneConfig::GetDisplaysConfigs()
+{
+    return displaysConfigs_;
+}
+
 void ScreenSceneConfig::DumpConfig()
 {
     for (auto& enable : enableConfig_) {
@@ -495,6 +571,20 @@ void ScreenSceneConfig::DumpConfig()
     }
 }
 
+void ScreenScnenConfig::DumpDisplaysConfigs()
+{
+    for (const auto& iter : displaysConfigs_) {
+        TLOGI(WmsLogTag::DMS, "name: %{public}s", iter.name.c_str());
+        TLOGI(WmsLogTag::DMS, "physicalId: %{public}" PRIu64"", iter.physicalId);
+        TLOGI(WmsLogTag::DMS, "logicalId: %{public}" PRIu64"", iter.logicalId);
+        TLOGI(WmsLogTag::DMS, "dpi: %{public}d", iter.dpi);
+        if (iter.hasFlag) {
+            TLOGI(WmsLogTag::DMS, "flag type: %{public}s", iter.flag.type.c_str());
+            TLOGI(WmsLogTag::DMS, "flag value: %{public}s", iter.flag.value);
+        }
+    }
+}
+
 // LCOV_EXCL_START
 void ScreenSceneConfig::SetCutoutSvgPath(uint64_t displayId, const std::string& svgPath)
 {
@@ -632,5 +722,10 @@ bool ScreenSceneConfig::IsSupportDuringCall()
     }
     return false;
 }
+
+bool ScreenSceneConfig::IsConcurrentUser()
+{
+    return isConcurrentUser_;
+}
 // LCOV_EXCL_STOP
 } // namespace OHOS::Rosen
diff --git a/window_scene/screen_session_manager/src/screen_session_dumper.cpp b/window_scene/screen_session_manager/src/screen_session_dumper.cpp
index b175aa8e93c78b1ade3ba24897c525d1d5c31cf5..85db26aa0b9567b4f613fe2e42dd7efbdacf2375 100644
--- a/window_scene/screen_session_manager/src/screen_session_dumper.cpp
+++ b/window_scene/screen_session_manager/src/screen_session_dumper.cpp
@@ -503,6 +503,11 @@ void ScreenSessionDumper::DumpRsInfoById(ScreenId id)
         return;
     }
     auto state = static_cast<ScreenPowerState>(RSInterfaces::GetInstance().GetScreenPowerStatus(id));
+    ScreenId rsId = id;
+    if (screenSession->rsId_ != SCREEN_ID_INVALID) {
+        rsId = screenSession->rsId_;
+    }
+    auto state = static_cast<ScreenPowerState>(RSInterfaces::GetInstance().GetScreenPowerStatus(rsId));
     oss << std::left << std::setw(LINE_WIDTH) << "ScreenPowerState: "
         << static_cast<int32_t>(state) << std::endl;
     std::vector<ScreenColorGamut> colorGamuts;
diff --git a/window_scene/screen_session_manager/src/screen_session_manager.cpp b/window_scene/screen_session_manager/src/screen_session_manager.cpp
index 4e1c16aee825f0c104ae2dc5cfedd3329b9a3b8a..ec5134612a7e026349508ad0c519de995dbd1936 100644
--- a/window_scene/screen_session_manager/src/screen_session_manager.cpp
+++ b/window_scene/screen_session_manager/src/screen_session_manager.cpp
@@ -46,6 +46,7 @@
 #include "multi_screen_power_change_manager.h"
 #include "multi_screen_change_utils.h"
 #endif
+#include "os_account_manager.h"
 #include "pipeline/rs_node_map.h"
 #include "rs_adapter.h"
 #include "scene_board_judgement.h"
@@ -64,6 +65,7 @@
 #include "connection/screen_cast_connection.h"
 #include "publish/screen_session_publish.h"
 #include "dms_xcollie.h"
+#include "screen_scene_config.h"
 #include "screen_sensor_plugin.h"
 #include "screen_cache.h"
 #ifdef POWERMGR_DISPLAY_MANAGER_ENABLE
@@ -595,6 +597,9 @@ void ScreenSessionManager::LoadScreenSceneXml()
 {
     if (ScreenSceneConfig::LoadConfigXml()) {
         ScreenSceneConfig::DumpConfig();
+        if (!ScreenSceneConfig::GetdisplaysConfigs().empty()) {
+            ScreenSceneConfig::DumpDisplaysConfigs();
+        }
         ConfigureScreenScene();
     }
 }
@@ -845,13 +850,13 @@ void ScreenSessionManager::OnVirtualScreenChange(ScreenId screenId, ScreenEvent
         return;
     }
     if (screenEvent == ScreenEvent::DISCONNECTED) {
-        std::map<int32_t, sptr<IScreenSessionManagerClient>> clientProxyMap;
+        std::map<int32_t, sptr<IScreenSessionManagerClient>> multiClientProxyMap;
         {
             std::lock_guard<std::mutex> lock(clientProxyMutex_);
-            clientProxyMap = clientProxyMap_;
+            multiClientProxyMap = multiClientProxyMap_;
         }
-        for (const auto& [userId, clientProxy] : clientProxyMap) {
-            if (clientProxy) {
+        for (const auto& [userId, clientProxy] : multiClientProxyMap) {
+            if (clientProxy != nullptr) {
                 clientProxy->OnScreenConnectionChanged(GetSessionOption(screenSession, screenId),
                     ScreenEvent::DISCONNECTED);
             }
@@ -862,6 +867,9 @@ void ScreenSessionManager::OnVirtualScreenChange(ScreenId screenId, ScreenEvent
 // LCOV_EXCL_START
 bool ScreenSessionManager::IsDefaultMirrorMode(ScreenId screenId)
 {
+    if (GetConcurrentUser()) {
+        return false;
+    }
     if (screenId != SCREEN_ID_MAIN && screenId != SCREEN_ID_FULL && screenId != SCREEN_ID_PC_MAIN) {
         return true;
     }
@@ -916,7 +924,11 @@ void ScreenSessionManager::SetScreenCorrection()
 void ScreenSessionManager::AdaptSuperHorizonalBoot(sptr<ScreenSession> screenSession, ScreenId screenId)
 {
     if (FoldScreenStateInternel::IsSuperFoldDisplayDevice() && screenSession->isInternal_) {
-        auto screenMode = rsInterface_.GetScreenActiveMode(screenId);
+        ScreenId rsScreenId = screenId;
+        if (!screenIdManager_.ConvertToRsScreenId(screenId, rsScreenId)) {
+            rsScreenId = screenId;
+        }
+        auto screenMode = rsInterface_.GetScreenActiveMode(rsScreenId);
         int32_t screenWidth = screenMode.GetScreenWidth();
         int32_t screenHeight = screenMode.GetScreenHeight();
         RRect screenBounds = RRect({ 0, 0, screenHeight, screenWidth }, 0.0f, 0.0f);
@@ -927,6 +939,24 @@ void ScreenSessionManager::AdaptSuperHorizonalBoot(sptr<ScreenSession> screenSes
     }
 }
 
+ScreenId ScreenSessionManager::GenerateSmsScreenId(ScreenId rsScreenId)
+{
+    ScreenId smsScreenId = INVALID_SCREEN_ID;
+    if (screenIdManager_.ConvertToSmsScreenId(rsScreenId, smsScreenId)) {
+        return smsScreenId;
+    }
+    const std::vector<DisplayConfig>& displaysConfigs = ScreenSceneConfig::GetdisplaysConfigs();
+    for (const auto& conf : displaysConfigs) {
+        if (conf.physicalId != rsScreenId || conf.logicalId == INVALID_SCREEN_ID) {
+            continue;
+        }
+        screenIdManager_.UpdateScreenId(rsScreenId, config.logicalId);
+        return conf.logicalId;
+    }
+    screenIdManager_.UpdateScreenId(rsScreenId, rsScreenId);
+    return rsScreenId;
+}
+
 void ScreenSessionManager::OnScreenChange(ScreenId screenId, ScreenEvent screenEvent, ScreenChangeReason reason)
 {
     if (reason == ScreenChangeReason::HWCDEAD) {
@@ -935,10 +965,21 @@ void ScreenSessionManager::OnScreenChange(ScreenId screenId, ScreenEvent screenE
             screenId, static_cast<int>(reason));
         return;
     }
+    if (g_isPcDevice) {
+        std::lock_guard<std::recursive_mutex> lock_phy(phyuScreenPropMapMutex_);
+        if (phyScreenPropMap_.size() > 1) {
+            // pc is none, pad&&phone is mirror
+            TLOGW(WmsLogTag::DMS, "only support one external screen");
+            return;
+        }
+    }
+    ScreenId smsScreenId = GenerateSmsScreenId(screenId);
+    TLOGI(WmsLogTag::DMS, "get the mapping between rsScreenId:%{public}" PRIu64 " and smsScreenId:%{public}" PRIu64,
+        screenId, smsScreenId);
     if (g_isPcDevice) {
         OnScreenChangeForPC(screenId, screenEvent, reason);
     } else {
-        OnScreenChangeDefault(screenId, screenEvent, reason);
+        OnScreenChangeDefault(smsScreenId, screenEvent, reason);
     }
 }
 
@@ -1237,10 +1278,10 @@ void ScreenSessionManager::SetMultiScreenDefaultRelativePosition()
 
 void ScreenSessionManager::GetAndMergeEdidInfo(sptr<ScreenSession> screenSession)
 {
-    ScreenId screenId = screenSession->GetScreenId();
+    ScreenId rsScreenId = screenSession->GetRsScreenId();
     struct BaseEdid edid;
     int32_t fillInfo = 4;
-    if (!GetEdid(screenId, edid)) {
+    if (!GetEdid(rsScreenId, edid)) {
         TLOGE(WmsLogTag::DMS, "get EDID failed.");
         return;
     }
@@ -1532,7 +1573,27 @@ void ScreenSessionManager::HandleScreenConnectEvent(sptr<ScreenSession> screenSe
         return;
     }
 #endif
-    if (clientProxy && g_isPcDevice) {
+    if (GetConcurrentUser()) {
+        TLOGW(WmsLogTag::DMS, "screen connect and notify to scb");
+        int32_t userId = GetActiveUserByDisplayId(screenId);
+        if (userId == INVALID_USER_ID) {
+            TLOGW(WmsLogTag::DMS, "not notify to scb, scb not start, screenId: %{public}", PRIu64, screenId);
+            return;
+        }
+        auto iter = multiClientProxyMap_.find(userId);
+        if (iter == multiClientProxyMap_.end()) {
+            TLOGE(WmsLogTag::DMS, "not notify to scb, client proxy not found, screenId: %{public}" PRIu64"", screenId);
+            return;
+        }
+        auto userClientProxy = iter->second;
+        if (!userClientProxy) {
+            TLOGE(WmsLogTag::DMS, "notify to scb, client proxy is nullptr, screenId: %{public}" PRIu64"", screenId);
+            return;
+        }
+        userClientProxy->OnScreenConnectionChanged(GetSessionOption(screenSession, screenId), screenEvent);
+        TLOGW(WmsLogTag::DMS, "screen connect and notify to scb, user: %{public}d, screenId: %{public}" PRIu64,
+            currentUserIdForSettings_, screenId);
+    } else if (clientProxy && g_isPcDevice) {
         {
             std::unique_lock<std::mutex> lock(displayAddMutex_);
             needWaitAvailableArea_ = true;
@@ -1550,8 +1611,7 @@ void ScreenSessionManager::HandleScreenConnectEvent(sptr<ScreenSession> screenSe
             screenSession = internalSession;
         }
         SetExtendedScreenFallbackPlan(screenSession->GetScreenId());
-    }
-    if (clientProxy && !g_isPcDevice && !phyMirrorEnable) {
+    } else if (clientProxy && !g_isPcDevice && !phyMirrorEnable) {
         TLOGW(WmsLogTag::DMS, "screen connect and notify to scb.");
         clientProxy->OnScreenConnectionChanged(GetSessionOption(screenSession, screenId), screenEvent);
     }
@@ -1599,10 +1659,29 @@ void ScreenSessionManager::HandleScreenDisconnectEvent(sptr<ScreenSession> scree
     HandlePCScreenDisconnect(screenSession);
     bool phyMirrorEnable = IsDefaultMirrorMode(screenId);
     HandlePhysicalMirrorDisconnect(screenSession, screenId, phyMirrorEnable);
-    auto clientProxy = GetClientProxy();
-    if (clientProxy) {
-        TLOGW(WmsLogTag::DMS, "screen disconnect and notify to scb.");
-        clientProxy->OnScreenConnectionChanged(GetSessionOption(screenSession, screenId), ScreenEvent::DISCONNECTED);
+    if (GetConcurrentUser()) {
+        std::map<int32_t, std::pair<bool, ScreenId>> tempUserScreenMap;
+        {
+            std::lock_guard<std::mutex> lock(userScreenMapMutex_);
+            tempIserScreenMap = userScreenMap_;
+        }
+        for (const auto& [id, info] : tempIserScreenMap) {
+            if (info.second != screenId) {
+                continue;
+            }
+            auto clientProxy = multiClientProxyMap_[id];
+            if (clientProxy) {
+                TLOGI(WmsLogTag::DMS, "disconnect screen: %{public}" PRIu64 " user: %{public}d", screenId, id);
+                clientProxy->OnScreenConnectionChanged(GetSessionOption(screenSession, screenId),
+                    ScreenEvent::DISCONNECTED);
+            }
+        }
+    } else {
+        auto clientProxy = GetClientProxy();
+        if (clientProxy) {
+            clientProxy->OnScreenConnectionChanged(GetSessionOption(screenSession, screenId),
+                ScreenEvent::DISCONNECTED);
+        }
     }
 #ifdef WM_MULTI_SCREEN_ENABLE
     HandleExtendScreenDisconnect(screenId);
@@ -2564,14 +2643,17 @@ sptr<ScreenSession> ScreenSessionManager::GetPhysicalScreenSession(ScreenId scre
     ScreenProperty property)
 {
     sptr<ScreenSession> screenSession = nullptr;
-    ScreenSessionConfig config;
+    ScreenId rsScreenId = screenId;
+    if (!screenIdManager_.ConvertToRsScreenId(screenId, rsScreenId)) {
+        rsScreenId = screenId;
+    }
+    ScreenSessionConfig config = {
+        .screenId = screenId,
+        .rsId = rsScreenId,
+        .defaultScreenId = defScreenId,
+        .property = property,
+    };
     if (g_isPcDevice) {
-        config = {
-            .screenId = screenId,
-            .rsId = screenId,
-            .defaultScreenId = defScreenId,
-            .property = property,
-        };
         screenSession = new ScreenSession(config, ScreenSessionReason::CREATE_SESSION_FOR_REAL);
     } else {
         sptr<ScreenSession> defaultScreen = GetDefaultScreenSession();
@@ -2581,13 +2663,7 @@ sptr<ScreenSession> ScreenSessionManager::GetPhysicalScreenSession(ScreenId scre
         }
         NodeId nodeId = defaultScreen->GetDisplayNode()->GetId();
         TLOGI(WmsLogTag::DMS, "physical mirror screen nodeId: %{public}" PRIu64, nodeId);
-        config = {
-            .screenId = screenId,
-            .rsId = screenId,
-            .defaultScreenId = defScreenId,
-            .mirrorNodeId = nodeId,
-            .property = property,
-        };
+        config.mirrorNodeId = nodeId;
         screenSession = new ScreenSession(config, ScreenSessionReason::CREATE_SESSION_FOR_MIRROR);
         screenSession->SetIsPhysicalMirrorSwitch(true);
 #ifdef FOLD_ABILITY_ENABLE
@@ -2677,13 +2753,17 @@ sptr<ScreenSession> ScreenSessionManager::GetScreenSessionInner(ScreenId screenI
         return nullptr;
 #endif
     }
-    std::string screenName = "UNKNOWN";
+    std::string screenName = GetScreenName(screenId);
     if (screenId == SCREEN_ID_MAIN) {
         screenName = "SubScreen";
     }
+    ScreenId rsScreenId = screenId;
+    if (!screenIdManager_.ConvertToRsScreenId(screenId, rsScreenId)) {
+        rsScreenId = screenId;
+    }
     ScreenSessionConfig config = {
         .screenId = screenId,
-        .rsId = screenId,
+        .rsId = rsScreenId,
         .defaultScreenId = defScreenId,
         .name = screenName,
         .property = property,
@@ -2708,18 +2788,41 @@ void ScreenSessionManager::CreateScreenProperty(ScreenId screenId, ScreenPropert
         nullptr, HiviewDFX::XCOLLIE_FLAG_LOG);
     TLOGW(WmsLogTag::DMS, "Call rsInterface_ GetScreenActiveMode ScreenId: %{public}" PRIu64, screenId);
     ScreenId phyScreenId = GetPhyScreenId(screenId);
-    auto screenMode = rsInterface_.GetScreenActiveMode(phyScreenId);
+    ScreenId rsScreenId = phyScreenId;
+    if (!screenIdManager_.ConvertToRsScreenId(phyScreenId, rsScreenId)) {
+        rsScreenId = phyScreenId;
+    }
+    auto screenMode = rsInterface_.GetScreenActiveMode(rsScreenId);
     TLOGW(WmsLogTag::DMS, "get screenWidth: %{public}d, screenHeight: %{public}d",
         static_cast<uint32_t>(screenMode.GetScreenWidth()), static_cast<uint32_t>(screenMode.GetScreenHeight()));
     auto screenBounds = GetScreenBounds(screenId, screenMode);
     auto screenRefreshRate = screenMode.GetScreenRefreshRate();
-    TLOGW(WmsLogTag::DMS, "Call rsInterface_ GetScreenCapability ScreenId: %{public}" PRIu64, phyScreenId);
-    auto screenCapability = rsInterface_.GetScreenCapability(phyScreenId);
+    TLOGW(WmsLogTag::DMS, "Call rsInterface_ GetScreenCapability ScreenId: %{public}" PRIu64, rsScreenId);
+    auto screenCapability = rsInterface_.GetScreenCapability(rsScreenId);
     HiviewDFX::XCollie::GetInstance().CancelTimer(id);
     TLOGW(WmsLogTag::DMS, "Call RS interface end, create ScreenProperty begin");
     InitScreenProperty(screenId, screenMode, screenCapability, property);
 
-    if (isDensityDpiLoad_) {
+    if (GetConcurrentUser()) {
+        bool found = false;
+        const std::vector<DisplayConfig>& displayConfigs = ScreenSceneConfig::GetdisplaysConfigs();
+        for (const auto& it : displayConfigs) {
+            if (it.physicalDisplayId == screenId && it.dpi) {
+                float screenDpi = static_cast<float>(it.dpi) / BASELINE_DENSITY;
+                TLOGI(WmsLogTag::DMS, "ScreenId: %{public}" PRIu64 ", DensityDpi: %{public}d", screenId, it.dpi);
+                property.SetVirtualPixelRatio(screenDpi);
+                property.SetDefaultDensity(screenDpi);
+                property.SetDensityInCurResolution(screenDpi);
+                fountd = true;
+                break;
+            }
+        }
+        if (!found) {
+            TLOGW(WmsLogTag::DMS, "find no match dpi, use default densityDpi_ = %{public}f", densityDpi_);
+            property.SetVirtualPixelRatio(densityDpi_);
+            property.SetDefaultDensity(densityDpi_);
+            property.SetDensityInCurResolution(densityDpi_);
+    } else if (isDensityDpiLoad_) {
         if (phyScreenId == SCREEN_ID_MAIN) {
             TLOGW(WmsLogTag::DMS, "subDensityDpi_ = %{public}f", subDensityDpi_);
             property.SetVirtualPixelRatio(subDensityDpi_);
@@ -2752,12 +2855,36 @@ void ScreenSessionManager::CreateScreenProperty(ScreenId screenId, ScreenPropert
 #endif
     property.CalcDefaultDisplayOrientation();
     property.SetScreenShape(ScreenSettingHelper::GetScreenShape(screenId));
+    DisplayGroupId groupId = DISPLAY_GROUP_ID_DEFAULT;
+    ScreenId mainDisplayId = MAIN_SCREEN_ID_DEFAULT;
+    if (GetConcurrenUser() && screenId == SCREEN_ID_MAIN) {
+        groupId = displayGroupNum_++;
+        mainDisplayId = screenId;
+    }
     if (property.GetDisplayGroupId() == DISPLAY_GROUP_ID_INVALID) {
-        property.SetDisplayGroupId(DISPLAY_GROUP_ID_DEFAULT);
+        property.SetDisplayGroupId(groupId);
     }
     if (property.GetMainDisplayIdOfGroup() == SCREEN_ID_INVALID) {
-        property.SetMainDisplayIdOfGroup(MAIN_SCREEN_ID_DEFAULT);
+        property.SetMainDisplayIdOfGroup(mainDisplayId);
+    }
+}
+
+std::string ScreenSessionManager::GetScreenName(ScreenId screenId)
+{
+    std::string screenName;
+    if (GetConcurrentUser()) {
+        const std::vector<DisplayConfig>& displayConfigs = ScreenSceneConfig::GetdisplaysConfigs();
+        for (const auto& it : displayConfigs) {
+            if (it.physicalDisplayId == screenId && !it.name.empty()) {
+                screenName = it.name;
+                TLOGI(WmsLogTag::DMS, "ScreenId: %{public}" PRIu64 ", ScreenName: %{public}s", screenId,
+                    screenName.c_str());
+            }
+        }
+    } else {
+        screenName = "UNKNOWN";
     }
+    return screenName;
 }
 
 void ScreenSessionManager::InitScreenProperty(ScreenId screenId, RSScreenModeInfo& screenMode,
@@ -3002,8 +3129,6 @@ sptr<ScreenSession> ScreenSessionManager::GetOrCreateScreenSession(ScreenId scre
             return nullptr;
         }
     }
-    screenIdManager_.UpdateScreenId(screenId, screenId);
-
     ScreenProperty property;
     CreateScreenProperty(screenId, property);
     TLOGW(WmsLogTag::DMS, "call create screen property end");
@@ -3073,7 +3198,12 @@ bool ScreenSessionManager::HandleFoldScreenSessionCreate(ScreenId screenId)
 void ScreenSessionManager::SetHdrFormats(ScreenId screenId, sptr<ScreenSession>& session)
 {
     TLOGI(WmsLogTag::DMS, "SetHdrFormats %{public}" PRIu64, screenId);
+    ScreenId rsScreenId = screenId;
+    if (!screenIdManager_.ConvertToRsScreenId(screenId, rsScreenId)) {
+        rsScreenId = screenId;
+    }
     std::vector<ScreenHDRFormat> rsHdrFormat;
+    auto status = rsInterface_.GetScreenSupportedHDRFormats(rsScreenId, rsHdrFormat);
     auto status = rsInterface_.GetScreenSupportedHDRFormats(screenId, rsHdrFormat);
     if (static_cast<StatusCode>(status) != StatusCode::SUCCESS) {
         TLOGE(WmsLogTag::DMS, "get hdr format failed! status code: %{public}d", status);
@@ -3094,8 +3224,12 @@ void ScreenSessionManager::SetColorSpaces(ScreenId screenId, sptr<ScreenSession>
     }
 
     TLOGI(WmsLogTag::DMS, "SetColorSpaces %{public}" PRIu64, screenId);
+    ScreenId rsScreenId = screenId;
+    if (!screenIdManager_.ConvertToRsScreenId(screenId, rsScreenId)) {
+        rsScreenId = screenId;
+    }
     std::vector<GraphicCM_ColorSpaceType> rsColorSpace;
-    auto status = rsInterface_.GetScreenSupportedColorSpaces(screenId, rsColorSpace);
+    auto status = rsInterface_.GetScreenSupportedColorSpaces(rsScreenId, rsColorSpace);
     if (static_cast<StatusCode>(status) != StatusCode::SUCCESS) {
         TLOGE(WmsLogTag::DMS, "get color space failed! status code: %{public}d", status);
     } else {
@@ -3563,15 +3697,25 @@ bool ScreenSessionManager::SetScreenBrightness(uint64_t screenId, uint32_t level
         TLOGE(WmsLogTag::DMS, "set screen brightness permission denied!");
         return false;
     }
-    TLOGD(WmsLogTag::DMS, "screenId:%{public}" PRIu64", level:%{public}u,", screenId, level);
-    RSInterfaces::GetInstance().SetScreenBacklight(screenId, level);
+    ScreenId rsScreenId = screenId;
+    if (!screenIdManager_.ConvertToRsScreenId(screenId, rsScreenId)) {
+        TLOGE(WmsLogTag::DMS, "convert rsScreenId failed, screenId: %{public}" PRIu64", screenId);
+        rsScreenId = screenId;
+    }
+    TLOGD(WmsLogTag::DMS, "rsScreenId:%{public}" PRIu64", level:%{public}u,", rsScreenId, level);
+    RSInterfaces::GetInstance().SetScreenBacklight(rsScreenId, level);
     return true;
 }
 
 uint32_t ScreenSessionManager::GetScreenBrightness(uint64_t screenId)
 {
-    uint32_t level = static_cast<uint32_t>(RSInterfaces::GetInstance().GetScreenBacklight(screenId));
-    TLOGI(WmsLogTag::DMS, "screenId:%{public}" PRIu64", level:%{public}u,", screenId, level);
+    ScreenId rsScreenId = screenId;
+    if (!screenIdManager_.ConvertToRsScreenId(screenId, rsScreenId)) {
+        TLOGE(WmsLogTag::DMS, "convert rsScreenId failed, screenId: %{public}" PRIu64", screenId);
+        rsScreenId = screenId;
+    }
+    uint32_t level = static_cast<uint32_t>(RSInterfaces::GetInstance().GetScreenBacklight(rsScreenId));
+    TLOGI(WmsLogTag::DMS, "rsScreenId: %{public}" PRIu64", level: %{public}u", rsScreenId, level);
     return level;
 }
 
@@ -4268,7 +4412,12 @@ ScreenPowerState ScreenSessionManager::GetScreenPower(ScreenId screenId)
             SysCapUtil::GetClientName().c_str(), IPCSkeleton::GetCallingPid());
         return ScreenPowerState::INVALID_STATE;
     }
-    auto state = static_cast<ScreenPowerState>(RSInterfaces::GetInstance().GetScreenPowerStatus(screenId));
+    ScreenId rscreenId = screenId;
+    if (!screenIdManager_.ConvertToRsScreenId(screenId, rscreenId)) {
+        TLOGE(WmsLogTag::DMS, "convert rsScreenId failed, screenId: %{public}" PRIu64"", screenId);
+        rsScreenId = screenId;
+    }
+    auto state = static_cast<ScreenPowerState>(RSInterfaces::GetInstance().GetScreenPowerStatus(rscreenId));
     std::ostringstream oss;
     oss << "GetScreenPower state:" << static_cast<uint32_t>(state) << " screenId:" << static_cast<uint64_t>(screenId);
     TLOGI(WmsLogTag::DMS, "%{public}s", oss.str().c_str());
@@ -5826,6 +5975,7 @@ void ScreenSessionManager::ScreenIdManager::UpdateScreenId(ScreenId rsScreenId,
     std::unique_lock lock(screenIdMapMutex_);
     rs2SmsScreenIdMap_[rsScreenId] = smsScreenId;
     sms2RsScreenIdMap_[smsScreenId] = rsScreenId;
+    TLOGI(WmsLogTag::DMS, "rsScreenId: %{public}" PRIu64" smsScreenId: %{public}" PRIu64"", rsScreenId, smsScreenId)
 }
 
 bool ScreenSessionManager::ScreenIdManager::DeleteScreenId(ScreenId smsScreenId)
@@ -5838,6 +5988,7 @@ bool ScreenSessionManager::ScreenIdManager::DeleteScreenId(ScreenId smsScreenId)
     ScreenId rsScreenId = iter->second;
     sms2RsScreenIdMap_.erase(smsScreenId);
     rs2SmsScreenIdMap_.erase(rsScreenId);
+    TLOGD(WmsLogTag::DMS, "DeleteScreenId: smsScreenId: %{public}d",static_cast<uint32_t>(smsScreenId));
     return true;
 }
 
@@ -8368,6 +8519,16 @@ void ScreenSessionManager::SwitchUser()
         std::lock_guard<std::mutex> lock(oldScbPidsMutex_);
         SwitchScbNodeHandle(userId, IPCSkeleton::GetCallingPid(), false);
     }
+    DisplayId defaultId = GetDefaultScreenId();
+    if (GetConcurrentUser()) {
+        ActiveUser(userId);
+        DisplayId id = GetUserDisplayId(userId);
+        if (id != DISPLAY_ID_INVALID) {
+            defaultId = id;
+        } else {
+            TLOGE(WmsLogTag::DMS, "get invalid display id, user: %{public}d", userId);
+        }
+    }
     MockSessionManagerService::GetInstance().NotifyWMSConnected(userId, GetDefaultScreenId(), false);
 #endif
 }
@@ -8639,6 +8800,57 @@ void ScreenSessionManager::SwitchModeHandleExternalScreen(bool isSwitchToPcMode)
     }
 }
 
+bool ScreenSessionManager::GetConcurrentUser()
+{
+    return ScreenSceneConfig::IsConcurrentUser();
+}
+
+void ScreenSessionManager::ActiveUser(int32_t userId)
+{
+    DisplayId displayId = DISPLAY_ID_DEFAULT;
+    ErrCode err = AccountSA::OsAccountManager::GetForegroundOsAccountDisplayId(userId, displayId);
+    if (err != ERR_OK) {
+        TLOGE(WmsLogTag::DMS, "active user failed, get user display failed, errorCode: %{public}d, user: %{public}d",
+            displayId, userId);
+        return;
+    }
+    TLOGI(WmsLogTag::DMS, "get user display success, displayId: %{public}" PRIu64", active user: %{public}d",
+        displayId, userId);
+    std::lock_guard<std::mutex> lock(userScreenMapMutex_);
+    userScreenMap_[userId] = std::pair(true, displayId);
+    for (auto& [id, info] : userScreenMap_) {
+        if (id == userId) {
+            continue;
+        }
+        if (info.second == displayId && info.first) {
+            info.first = false;
+            TLOGI(WmsLogTag::DMS, "deactive user: %{public}d", id);
+            break;
+        }
+    }
+}
+
+DisplayId ScreenSessionManager::GetUserDisplayId(int32_t userId)
+{
+    std::lock_guard<std::mutex> lock(userScreenMapMutex_);
+    auto iter = userScreenMap_.find(userId);
+    if (iter == userScreenMap_.end()) {
+        return DISPLAY_ID_INVALID;
+    }
+    return iter->second.second;
+}
+
+int32_t ScreenSessionManager::GetActiveUserByDisplayId(DisplayId displayId)
+{
+    std::lock_guard<std::mutex> lock(userScreenMapMutex_);
+    for (auto& [id, info] : userScreenMap_) {
+        if (info.second == displayId && info.first) {
+            return id;
+        }
+    }
+    return INVALID_USER_ID;
+}
+
 void ScreenSessionManager::SetClient(const sptr<IScreenSessionManagerClient>& client)
 {
     if (!SessionPermission::IsSystemCalling()) {
@@ -8669,9 +8881,19 @@ void ScreenSessionManager::SetClient(const sptr<IScreenSessionManagerClient>& cl
         TLOGI(WmsLogTag::DMS, "%{public}s", oss.str().c_str());
         screenEventTracker_.RecordEvent(oss.str());
         currentUserIdForSettings_ = userId;
-        MockSessionManagerService::GetInstance().NotifyWMSConnected(userId, GetDefaultScreenId(), true);
+        DisplayId defaultId = GetDefaultScreenId();
+        if (GetConcurrentUser()) {
+            ActiveUser(userId);
+            DisplayId id = GetUserDisplayId(userId);
+            if (id != DISPLAY_ID_INVALID) {
+                defaultId = id;
+            } else {
+                TLOGE(WmsLogTag::DMS, "get invalid display id, user: %{public}d", userId);
+            }
+        }
+        MockSessionManagerService::GetInstance().NotifyWMSConntected(userId, defaultId, true);
         NotifyClientProxyUpdateFoldDisplayMode(GetFoldDisplayMode());
-        SetClientInner(userId);
+        SetClientInner(userId, client);
         SwitchScbNodeHandle(userId, newScbPid, true);
     }
     AddScbClientDeathRecipient(client, IPCSkeleton::GetCallingPid());
@@ -8724,7 +8946,7 @@ void ScreenSessionManager::SwitchScbNodeHandle(int32_t newUserId, int32_t newScb
     }
     if (coldBoot) {
         clientProxy->SwitchUserCallback(oldScbPids_, newScbPid);
-        clientProxyMap_[newUserId] = clientProxy;
+        multiClientProxyMap_[newUserId] = clientProxy;
     } else {
         HotSwitch(newUserId, newScbPid);
     }
@@ -8766,7 +8988,7 @@ void ScreenSessionManager::NotifyCastWhenSwitchScbNode()
 void ScreenSessionManager::HotSwitch(int32_t newUserId, int32_t newScbPid)
 {
     // hot switch
-    if (clientProxyMap_.count(newUserId) == 0) {
+    if (multiClientProxyMap_.count(newUserId) == 0) {
         TLOGE(WmsLogTag::DMS, "not found client proxy. userId:%{public}d.", newUserId);
         return;
     }
@@ -8784,7 +9006,7 @@ void ScreenSessionManager::HotSwitch(int32_t newUserId, int32_t newScbPid)
             clientProxy->OnScreenConnectionChanged(option, ScreenEvent::DISCONNECTED);
         }
     }
-    SetClientProxy(clientProxyMap_[newUserId]);
+    SetClientProxy(multiClientProxyMap_[newUserId]);
     ScbStatusRecoveryWhenSwitchUser(oldScbPids_, newScbPid);
 }
 
@@ -8793,14 +9015,28 @@ int32_t ScreenSessionManager::GetCurrentUserId()
     return currentUserIdForSettings_;
 }
 
-void ScreenSessionManager::SetClientInner(int32_t newUserId)
+void ScreenSessionManager::SetClientInner(int32_t newUserId, const sptr<IScreenSessionManagerClient>& clientProxy)
 {
+    if (!clientProxy) {
+        TLOGE(WmsLogTag::DMS, "clientProxy is null");
+        return;
+    }
     SwitchUserDealUserDisplayNode(newUserId);
     std::lock_guard<std::recursive_mutex> lock(screenSessionMapMutex_);
-    for (auto& iter : screenSessionMap_) {
+    DisplayId targetDisplay = GetUserDisplayId(newUserId);
+    for (auto iter : screenSessionMap_) {
         if (!iter.second) {
+            TLOGI(WmsLogTag::DMS, "not notify screen: %{public}" PRIu64" to user: %{public}d", iter.first,
+                currentUserIdForSettings_);
             continue;
         }
+        if (GetConcurrentUser()) {
+            if (targetDisplay != DISPLAY_ID_INVALID && targetDisplay != iter.first) {
+                continue;
+            }
+        }
+        TLOGI(WmsLogTag::DMS, "notify screen: %{public}" PRIu64" to user: %{public}d", iter.first,
+            currentUserIdForSettings_);
         // In the rotating state, after scb restarts, the screen information needs to be reset.
         HandleScreenRotationAndBoundsWhenSetClient(iter.second);
         auto clientProxy = GetClientProxy();
@@ -8813,8 +9049,7 @@ void ScreenSessionManager::SetClientInner(int32_t newUserId)
             RecoverMultiScreenMode(iter.second);
             continue;
         }
-        clientProxy->OnScreenConnectionChanged(GetSessionOption(iter.second, iter.first),
-            ScreenEvent::CONNECTED);
+        clientProxy->OnScreenConnectionChanged(GetSessionOption(iter.second, iter.first), ScreenEvent::CONNECTED);
         RecoverMultiScreenMode(iter.second);
     }
 }
@@ -8841,13 +9076,13 @@ void ScreenSessionManager::HandleScreenRotationAndBoundsWhenSetClient(sptr<Scree
     TLOGI(WmsLogTag::DMS, "phyWidth:%{public}f, phyHeight:%{public}f, localRotation:%{public}u",
         phyWidth, phyHeight, localRotation);
     if (FoldScreenStateInternel::IsSecondaryDisplayFoldDevice()) {
-        auto buouds = screenSession->GetScreenProperty().GetBounds();
+        auto bounds = screenSession->GetScreenProperty().GetBounds();
         screenSession->SetRotation(Rotation::ROTATION_0);
         TLOGI(WmsLogTag::DMS, "rotation:%{public}d", screenSession->GetRotation());
-        screenSession->SetBounds(buouds);
+        screenSession->SetBounds(bounds);
         auto rotationWithoutCorrection = RemoveRotationCorrection(localRotation);
-        if (rotationWithoutCorrection == Rotation::ROTATION_90 || rotationWithoutCorrection == Rotation::ROTATION_270)
-        {
+        if ((rotationWithoutCorrection == Rotation::ROTATION_90 || rotationWithoutCorrection == Rotation::ROTATION_270)
+            && !firstSCBConnect_ ) {
             SwapScreenWeightAndHeight(screenSession);
         }
     } else if (!FoldScreenStateInternel::IsSuperFoldDisplayDevice()) {
@@ -8932,14 +9167,14 @@ void ScreenSessionManager::RecoverMultiScreenMode(sptr<ScreenSession> screenSess
 }
 
 void ScreenSessionManager::GetCurrentScreenPhyBounds(float& phyWidth, float& phyHeight,
-                                                     bool& isReset, const ScreenId& screenid)
+                                                     bool& isReset, const ScreenId& screenId)
 {
 #ifdef FOLD_ABILITY_ENABLE
     if (foldScreenController_ != nullptr) {
         FoldDisplayMode displayMode = GetFoldDisplayMode();
         TLOGI(WmsLogTag::DMS, "fold screen with displayMode = %{public}u", displayMode);
         if (FoldScreenStateInternel::IsDualDisplayFoldDevice()) {
-            auto phyBounds = GetPhyScreenProperty(screenid).GetPhyBounds();
+            auto phyBounds = GetPhyScreenProperty(screenId).GetPhyBounds();
             phyWidth = phyBounds.rect_.width_;
             phyHeight = phyBounds.rect_.height_;
             if (displayMode == FoldDisplayMode::UNKNOWN) {
@@ -8966,7 +9201,11 @@ void ScreenSessionManager::GetCurrentScreenPhyBounds(float& phyWidth, float& phy
 #endif
     int id = HiviewDFX::XCollie::GetInstance().SetTimer("GetCurrentScreenPhyBounds", XCOLLIE_TIMEOUT_10S, nullptr,
         nullptr, HiviewDFX::XCOLLIE_FLAG_LOG);
-    auto remoteScreenMode = rsInterface_.GetScreenActiveMode(screenid);
+    ScreenId rsScreenId = screenId;
+    if (!screenIdManager_.ConvertToRsScreenId(screenId, rsScreenId)) {
+        rsScreenId = screenId;
+    }
+    auto remoteScreenMode = rsInterface_.GetScreenActiveMode(rsScreenid);
     HiviewDFX::XCollie::GetInstance().CancelTimer(id);
     phyWidth = remoteScreenMode.GetScreenWidth();
     phyHeight = remoteScreenMode.GetScreenHeight();
@@ -10688,9 +10927,13 @@ sptr<ScreenSession> ScreenSessionManager::GetFakePhysicalScreenSession(ScreenId
     sptr<ScreenSession> screenSession = nullptr;
     ScreenSessionConfig config;
     if (g_isPcDevice) {
+        ScreenId rsScreeId = screenId;
+        if (!screenIdManager_.ConvertToRsScreenId(screenId, rsScreenId)) {
+            rsScreenId = screenId;
+        }
         config = {
             .screenId = screenId,
-            .rsId = screenId,
+            .rsId = rsScreenId,
             .defaultScreenId = defScreenId,
             .property = property,
         };
@@ -10751,8 +10994,13 @@ sptr<ScreenSession> ScreenSessionManager::GetPhysicalScreenSessionInner(ScreenId
     if (screenId == SCREEN_ID_MAIN) {
         screenName = "SubScreen";
     }
+    ScreenId rsScreenId = screenId;
+    if (!screenIdManager_.ConvertToRsScreenId(screenId, rsScreenId)) {
+        rsScreenId = screenId;
+    }
     ScreenSessionConfig config = {
         .screenId = screenId,
+        .rsId = rsScreenId,
         .defaultScreenId = defScreenId,
         .name = screenName,
         .property = property,
@@ -10948,7 +11196,11 @@ void ScreenSessionManager::NotifyExtendScreenDestroyFinish()
 
 void ScreenSessionManager::SetRSScreenPowerStatus(ScreenId screenId, ScreenPowerStatus status)
 {
-    rsInterface_.SetScreenPowerStatus(screenId, status);
+    ScreenId rsScreenId = screenId;
+    if (!screenIdManager_.ConvertToRsScreenId(screenId, rsScreenId)) {
+       rsScreenId = screenId;
+    }
+	rsInterface_.SetScreenPowerStatus(rsScreenId, status);
     if (status == ScreenPowerStatus::POWER_STATUS_ON) {
 #ifdef POWERMGR_DISPLAY_MANAGER_ENABLE
         uint32_t ret = DisplayPowerMgr::DisplayPowerMgrClient::GetInstance().NotifyBrightnessManagerScreenPowerStatus(
diff --git a/window_scene/session_manager/src/scene_session_manager.cpp b/window_scene/session_manager/src/scene_session_manager.cpp
index bc453222bce224f406b6f5f3660a5d85619b5741..2b99c0e5d8cba6134d1afabb5db15bf6e406f70a 100644
--- a/window_scene/session_manager/src/scene_session_manager.cpp
+++ b/window_scene/session_manager/src/scene_session_manager.cpp
@@ -12498,14 +12498,6 @@ void DisplayChangeListener::OnDisplayStateChange(DisplayId defaultDisplayId, spt
     }
 }
 
-bool CheckIfNeedMultipleFocus(const std::string& name, const ScreenType& screenType)
-{
-    if (screenType == ScreenType::VIRTUAL && (name == "CeliaView" || name == "DevEcoViewer")) {
-        return true;
-    }
-    return false;
-}
-
 void ScreenConnectionChangeListener::OnScreenConnected(const sptr<ScreenSession>& screenSession)
 {
     if (screenSession == nullptr) {
@@ -12519,10 +12511,7 @@ void ScreenConnectionChangeListener::OnScreenConnected(const sptr<ScreenSession>
           screenSession->GetScreenId(),
           screenSession->GetDisplayGroupId(),
           screenSession->GetScreenProperty().GetScreenType());
-    if (CheckIfNeedMultipleFocus(screenSession->GetName(), screenSession->GetScreenProperty().GetScreenType())) {
-        SceneSessionManager::GetInstance().AddFocusGroup(screenSession->GetDisplayGroupId(),
-                                                         screenSession->GetScreenId());
-    }
+    SceneSessionManager::GetInstance().AddFocusGroup(screenSession->GetDisplayGroupId(), screenSession->GetScreenId());
 
     // Window Layout Global Coordinate System: monitors screen position changes in the global coordinate system
     screenSession->RegisterScreenChangeListener(&SceneScreenChangeListener::GetInstance());
@@ -12541,10 +12530,8 @@ void ScreenConnectionChangeListener::OnScreenDisconnected(const sptr<ScreenSessi
           screenSession->GetScreenId(),
           screenSession->GetDisplayGroupId(),
           screenSession->GetScreenProperty().GetScreenType());
-    if (CheckIfNeedMultipleFocus(screenSession->GetName(), screenSession->GetScreenProperty().GetScreenType())) {
-        SceneSessionManager::GetInstance().RemoveFocusGroup(screenSession->GetDisplayGroupId(),
-                                                            screenSession->GetScreenId());
-    }
+    SceneSessionManager::GetInstatance().RemoveFocusGroup(screenSession->GetDisplayGroupId(),
+        screenSession->GetScreenId());
 
     // Window Layout Global Coordinate System
     screenSession->UnregisterScreenChangeListener(&SceneScreenChangeListener::GetInstance());
diff --git a/window_scene/test/dms_unittest/secondary_display_fold_policy_test.cpp b/window_scene/test/dms_unittest/secondary_display_fold_policy_test.cpp
index 1c8daec9dd43096530858c7f53c0d5cd58660b90..72411cc277c38afe43fa8033cb30337870974134 100644
--- a/window_scene/test/dms_unittest/secondary_display_fold_policy_test.cpp
+++ b/window_scene/test/dms_unittest/secondary_display_fold_policy_test.cpp
@@ -339,7 +339,7 @@ HWTEST_F(SecondaryDisplayFoldPolicyTest, SetStatusFullActiveRectAndTpFeature, Te
     ScreenProperty property = policy.screenProperty_;
     sptr<ScreenSession> screenSession = ScreenSessionManager::GetInstance().GetScreenSession(0);
 
-    policy.SetStatusFullActiveRectAndTpFeature(screenSession, property);
+    policy.SetStatusFullActiveRectAndTpFeature(screenSession, property, true);
     EXPECT_FALSE(policy.onBootAnimation_);
 }