diff --git a/dm_lite/include/display_manager_adapter_lite.h b/dm_lite/include/display_manager_adapter_lite.h
index 1c89fc98165a0dd4c89651bb09344a578eb8e585..8536481355ede943da2a818d36c445d7b28d2d59 100644
--- a/dm_lite/include/display_manager_adapter_lite.h
+++ b/dm_lite/include/display_manager_adapter_lite.h
@@ -88,6 +88,7 @@ public:
     /*
      * used by powermgr
      */
+    virtual DMError GetPhysicalScreenIds(std::vector<ScreenId>& screenIds);
     virtual bool SetSpecifiedScreenPower(ScreenId screenId, ScreenPowerState state, PowerStateChangeReason reason);
     virtual bool SetScreenPowerForAll(ScreenPowerState state, PowerStateChangeReason reason);
     virtual ScreenPowerState GetScreenPower(ScreenId dmsScreenId);
diff --git a/dm_lite/include/display_manager_lite_proxy.h b/dm_lite/include/display_manager_lite_proxy.h
index 170267951b67d9155560e215bd9d680c938ecdb4..2437bd05feedbf94f31f8b3fa0b1591d4b49627f 100644
--- a/dm_lite/include/display_manager_lite_proxy.h
+++ b/dm_lite/include/display_manager_lite_proxy.h
@@ -72,6 +72,7 @@ public:
     bool SetScreenBrightness(uint64_t screenId, uint32_t level);
     uint32_t GetScreenBrightness(uint64_t screenId);
     std::vector<DisplayId> GetAllDisplayIds();
+    DMError GetPhysicalScreenIds(std::vector<ScreenId>& screenIds);
     DMError GetAllScreenInfos(std::vector<sptr<ScreenInfo>>& screenInfos);
     DMError SetSystemKeyboardStatus(bool isTpKeyboardOn = false);
     sptr<ScreenInfo> GetScreenInfoById(ScreenId screenId);
diff --git a/dm_lite/src/display_manager_adapter_lite.cpp b/dm_lite/src/display_manager_adapter_lite.cpp
index 6c224465898bc53ca8c6f9586d31abfcf2f38a09..d22f74827506f0cf426e273adedf94dbbbac6e45 100644
--- a/dm_lite/src/display_manager_adapter_lite.cpp
+++ b/dm_lite/src/display_manager_adapter_lite.cpp
@@ -299,6 +299,13 @@ DMError ScreenManagerAdapterLite::GetAllScreenInfos(std::vector<sptr<ScreenInfo>
     return displayManagerServiceProxy_->GetAllScreenInfos(screenInfos);
 }
 
+DMError ScreenManagerAdapterLite::GetPhysicalScreenIds(std::vector<ScreenId>& screenIds)
+{
+    INIT_PROXY_CHECK_RETURN(DMError::DM_ERROR_INIT_DMS_PROXY_LOCKED);
+
+    return displayManagerServiceProxy_->GetPhysicalScreenIds(screenIds);
+}
+
 DMSDeathRecipientLite::DMSDeathRecipientLite(BaseAdapterLite& adapter) : adapter_(adapter)
 {
 }
diff --git a/dm_lite/src/display_manager_lite_proxy.cpp b/dm_lite/src/display_manager_lite_proxy.cpp
index 1b64582103918b722237da45b6618568e11738c3..1810d8b547612533f587eefb2c03794cacf962bf 100644
--- a/dm_lite/src/display_manager_lite_proxy.cpp
+++ b/dm_lite/src/display_manager_lite_proxy.cpp
@@ -933,6 +933,46 @@ DMError DisplayManagerLiteProxy::GetAllScreenInfos(std::vector<sptr<ScreenInfo>>
 #endif
 }
 
+DMError DisplayManagerLiteProxy::GetPhysicalScreenIds(std::vector<ScreenId>& screenIds)
+{
+    sptr<IRemoteObject> remote = Remote();
+    if (remote == nullptr) {
+        TLOGW(WmsLogTag::DMS, "remote is nullptr");
+        return DMError::DM_ERROR_NULLPTR;
+    }
+    MessageParcel data;
+    MessageParcel reply;
+    MessageOption option;
+    if (!data.WriteInterfaceToken(GetDescriptor())) {
+        TLOGE(WmsLogTag::DMS, "WriteInterfaceToken failed");
+        return DMError::DM_ERROR_WRITE_INTERFACE_TOKEN_FAILED;
+    }
+    if (remote->SendRequest(static_cast<uint32_t>(DisplayManagerMessage::TRANS_ID_GET_PHYSICAL_SCREEN_IDS),
+        data, reply, option) != ERR_NONE) {
+        TLOGW(WmsLogTag::DMS, "SendRequest failed");
+        return DMError::DM_ERROR_IPC_FAILED;
+    }
+
+    DMError ret = static_cast<DMError>(reply.ReadInt32());
+    if (ret != DMError::DM_OK) {
+        return ret;
+    }
+
+    bool res = MarshallingHelper::UnmarshallingVectorObj<ScreenId>(reply, screenIds,
+        [](Parcel& parcel, ScreenId& screenId) {
+            uint64_t value;
+            bool res = parcel.ReadUint64(value);
+            screenId = static_cast<ScreenId>(value);
+            return res;
+        }
+    );
+    if (!res) {
+        TLOGW(WmsLogTag::DMS, "fail to read SystemBarRegionTints");
+        return DMError::DM_ERROR_IPC_FAILED;
+    }
+    return ret;
+}
+
 DMError DisplayManagerLiteProxy::SetSystemKeyboardStatus(bool isTpKeyboardOn)
 {
 #ifdef SCENE_BOARD_ENABLED
diff --git a/dm_lite/src/screen_manager_lite.cpp b/dm_lite/src/screen_manager_lite.cpp
index 624746b0086e592e4c8fdd400e6886a6eeb8ad8f..0d74dab2629cdbb70505704fa32256f96104164c 100644
--- a/dm_lite/src/screen_manager_lite.cpp
+++ b/dm_lite/src/screen_manager_lite.cpp
@@ -409,20 +409,14 @@ ScreenPowerState ScreenManagerLite::GetScreenPower()
     return SingletonContainer::Get<ScreenManagerAdapterLite>().GetScreenPower();
 }
 
-DMError ScreenManagerLite::GetPhysicalScreenIds(std::vector<uint64_t>& screenIds)
+DMError ScreenManagerLite::GetPhysicalScreenIds(std::vector<ScreenId>& screenIds)
 {
-    std::vector<sptr<ScreenInfo>> screenInfos;
-    DMError ret = SingletonContainer::Get<ScreenManagerAdapterLite>().GetAllScreenInfos(screenInfos);
+    TLOGI(WmsLogTag::DMS, "enter");
+    DMError ret = SingletonContainer::Get<ScreenManagerAdapterLite>().GetPhysicalScreenIds(screenIds);
     if (ret != DMError::DM_OK) {
+        TLOGE(WmsLogTag::DMS, "failed");
         return ret;
     }
-
-    for (const auto& screenInfo : screenInfos) {
-        auto id = screenInfo->GetScreenId();
-        if (screenInfo->GetType() == ScreenType::REAL && id != SCREEN_ID_INVALID) {
-            screenIds.push_back(id);
-        }
-    }
     return DMError::DM_OK;
 }
 
diff --git a/dm_lite/test/unittest/display_manager_adapter_lite_test.cpp b/dm_lite/test/unittest/display_manager_adapter_lite_test.cpp
index 960d5d0e378b86f7f7928d97dad5d78306e42ca2..693522b6dc3c2b9253227159324ff758ff144e2f 100644
--- a/dm_lite/test/unittest/display_manager_adapter_lite_test.cpp
+++ b/dm_lite/test/unittest/display_manager_adapter_lite_test.cpp
@@ -194,6 +194,18 @@ HWTEST_F(DisplayManagerAdapterLiteTest, SetSystemKeyboardStatus02, TestSize.Leve
     auto ret = SingletonContainer::Get<DisplayManagerAdapterLite>().SetSystemKeyboardStatus(false);
     ASSERT_NE(ret, DMError::DM_OK);
 }
+
+/**
+ * @tc.name: GetPhysicalScreenIds
+ * @tc.desc: GetPhysicalScreenIds
+ * @tc.type: FUNC
+ */
+HWTEST_F(DisplayManagerAdapterLiteTest, GetPhysicalScreenIds, TestSize.Level1)
+{
+    std::vector<ScreenId> screenIds;
+    auto ret = SingletonContainer::Get<ScreenManagerAdapterLite>().GetPhysicalScreenIds(screenIds);
+    EXPECT_NE(ret, DMError::DM_OK);
+}
 }
 }
 }
diff --git a/dm_lite/test/unittest/screen_manager_lite_test.cpp b/dm_lite/test/unittest/screen_manager_lite_test.cpp
index 35e5e45922e358c7519a0cdfb30ca20dd588a208..a75a21daab07e5b98b602c5473c1376a81e0dd20 100644
--- a/dm_lite/test/unittest/screen_manager_lite_test.cpp
+++ b/dm_lite/test/unittest/screen_manager_lite_test.cpp
@@ -60,6 +60,18 @@ HWTEST_F(ScreenManagerLiteTest, GetScreenInfoById, TestSize.Level1)
     ret = sml_.GetScreenInfoById(0);
     ASSERT_NE(ret, nullptr);
 }
+
+/**
+ * @tc.name: GetPhysicalScreenIds
+ * @tc.desc: GetPhysicalScreenIds
+ * @tc.type: FUNC
+ */
+HWTEST_F(ScreenManagerLiteTest, GetPhysicalScreenIds, TestSize.Level1)
+{
+    std::vector<ScreenId> screenIds;
+    auto ret = sml_.GetPhysicalScreenIds(screenIds);
+    EXPECT_EQ(ret, DMError::DM_OK);
+}
 }
 } // namespace Rosen
 } // namespace OHOS
\ No newline at end of file
diff --git a/dmserver/include/display_manager_interface_code.h b/dmserver/include/display_manager_interface_code.h
index 5fed47ac68e9c62ffd2f56fb6c41c1daacb27c47..27c54744cc4541aafb517b5e03a13fdf8e36ab8d 100644
--- a/dmserver/include/display_manager_interface_code.h
+++ b/dmserver/include/display_manager_interface_code.h
@@ -53,6 +53,7 @@ enum class DisplayManagerMessage : unsigned int {
     TRANS_ID_GET_SCREEN_GROUP_INFO_BY_ID,
     TRANS_ID_SET_SCREEN_ACTIVE_MODE,
     TRANS_ID_GET_ALL_SCREEN_INFOS,
+    TRANS_ID_GET_PHYSICAL_SCREEN_IDS,
     TRANS_ID_SET_ORIENTATION,
     TRANS_ID_SET_VIRTUAL_PIXEL_RATIO,
     TRANS_ID_SET_VIRTUAL_PIXEL_RATIO_SYSTEM,
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 f9c75a5050ec04ae99165f4e4b20eb9b110dd5f8..e431e56026dde34a8c053452e454c6fc801f531e 100644
--- a/window_scene/screen_session_manager/include/screen_session_manager.h
+++ b/window_scene/screen_session_manager/include/screen_session_manager.h
@@ -157,6 +157,7 @@ public:
     virtual DMError GetAllScreenInfos(std::vector<sptr<ScreenInfo>>& screenInfos) override;
     virtual DMError GetScreenSupportedColorGamuts(ScreenId screenId,
         std::vector<ScreenColorGamut>& colorGamuts) override;
+    DMError GetPhysicalScreenIds(std::vector<ScreenId>& screenIds) override;
     DMError IsScreenRotationLocked(bool& isLocked) override;
     DMError SetScreenRotationLocked(bool isLocked) override;
     DMError SetScreenRotationLockedFromJs(bool isLocked) override;
diff --git a/window_scene/screen_session_manager/include/zidl/screen_session_manager_interface.h b/window_scene/screen_session_manager/include/zidl/screen_session_manager_interface.h
index 112c9b1307e914fe227942b63e8130c4af6e46de..52a229c0df6d7d57e21a20ef237451e28595a907 100644
--- a/window_scene/screen_session_manager/include/zidl/screen_session_manager_interface.h
+++ b/window_scene/screen_session_manager/include/zidl/screen_session_manager_interface.h
@@ -240,6 +240,7 @@ public:
     virtual void SetFoldStatusExpandAndLocked(bool locked) {}
 
     virtual FoldDisplayMode GetFoldDisplayMode() { return FoldDisplayMode::UNKNOWN; }
+    virtual DMError GetPhysicalScreenIds(std::vector<ScreenId>& screenIds) { return DMError::DM_OK; }
 
     virtual bool IsFoldable() { return false; }
     virtual bool IsCaptured() { return false; }
diff --git a/window_scene/screen_session_manager/include/zidl/screen_session_manager_proxy.h b/window_scene/screen_session_manager/include/zidl/screen_session_manager_proxy.h
index 9c17c00a63d11d37c868b88298d218c0df503d22..6abb0ab038bccd58d5365618b3519569ec9984f2 100644
--- a/window_scene/screen_session_manager/include/zidl/screen_session_manager_proxy.h
+++ b/window_scene/screen_session_manager/include/zidl/screen_session_manager_proxy.h
@@ -156,6 +156,7 @@ public:
     void SetFoldStatusExpandAndLocked(bool locked) override;
 
     FoldDisplayMode GetFoldDisplayMode() override;
+    DMError GetPhysicalScreenIds(std::vector<ScreenId>& screenIds) override;
 
     bool IsFoldable() override;
     bool IsCaptured() override;
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 505684ee2376f631afa9a5e22baf7e7ef1cac2e9..fd492333ce03226026f90f35a3101338b27c4338 100644
--- a/window_scene/screen_session_manager/src/screen_session_manager.cpp
+++ b/window_scene/screen_session_manager/src/screen_session_manager.cpp
@@ -3834,6 +3834,31 @@ std::vector<ScreenId> ScreenSessionManager::GetAllScreenIds()
     return res;
 }
 
+DMError ScreenSessionManager::GetPhysicalScreenIds(std::vector<ScreenId>& screenIds)
+{
+    TLOGI(WmsLogTag::DMS, "enter");
+    if (!SessionPermission::IsSystemCalling() && !SessionPermission::IsStartByHdcd()) {
+        TLOGE(WmsLogTag::DMS, "permission denied! calling: %{public}s, pid: %{public}d",
+            SysCapUtil::GetClientName().c_str(), IPCSkeleton::GetCallingPid());
+        return DMError::DM_ERROR_NOT_SYSTEM_APP;
+    }
+
+    std::lock_guard<std::recursive_mutex> lock(screenSessionMapMutex_);
+    for (const auto& iter : screenSessionMap_) {
+        auto screenSession = iter.second;
+        auto screenId = iter.first;
+        if (screenSession == nullptr) {
+            TLOGE(WmsLogTag::DMS, "screensession is nullptr, screenId: %{public}" PRIu64, screenId);
+            continue;
+        }
+        if (screenSession->GetScreenProperty().GetScreenType() == ScreenType::REAL
+            && screenId != SCREEN_ID_INVALID) {
+            screenIds.emplace_back(screenId);
+        }
+    }
+    return DMError::DM_OK;
+}
+
 DisplayState ScreenSessionManager::GetDisplayState(DisplayId displayId)
 {
     return sessionDisplayPowerController_->GetDisplayState(displayId);
diff --git a/window_scene/screen_session_manager/src/zidl/screen_session_manager_proxy.cpp b/window_scene/screen_session_manager/src/zidl/screen_session_manager_proxy.cpp
index cca620812b1794df7eeeba66c19a24b2f2e24180..4261265ae8ef17c8a8b17e02c39d36d9b46658b8 100644
--- a/window_scene/screen_session_manager/src/zidl/screen_session_manager_proxy.cpp
+++ b/window_scene/screen_session_manager/src/zidl/screen_session_manager_proxy.cpp
@@ -2056,6 +2056,45 @@ DMError ScreenSessionManagerProxy::GetScreenSupportedColorGamuts(ScreenId screen
     return ret;
 }
 
+DMError ScreenSessionManagerProxy::GetPhysicalScreenIds(std::vector<ScreenId>& screenIds)
+{
+    sptr<IRemoteObject> remote = Remote();
+    if (remote == nullptr) {
+        TLOGE(WmsLogTag::DMS, "remote is nullptr");
+        return DMError::DM_ERROR_NULLPTR;
+    }
+
+    MessageParcel data;
+    MessageParcel reply;
+    MessageOption option;
+    if (!data.WriteInterfaceToken(GetDescriptor())) {
+        TLOGW(WmsLogTag::DMS, "WriteInterfaceToken failed");
+        return DMError::DM_ERROR_WRITE_INTERFACE_TOKEN_FAILED;
+    }
+    if (remote->SendRequest(static_cast<uint32_t>(DisplayManagerMessage::TRANS_ID_GET_PHYSICAL_SCREEN_IDS),
+        data, reply, option) != ERR_NONE) {
+        TLOGW(WmsLogTag::DMS, "SendRequest failed");
+        return DMError::DM_ERROR_IPC_FAILED;
+    }
+    DMError ret = static_cast<DMError>(reply.ReadInt32());
+    if (ret != DMError::DM_OK) {
+        return ret;
+    }
+    bool res = MarshallingHelper::UnmarshallingVectorObj<ScreenId>(reply, screenIds,
+        [](Parcel& parcel, ScreenId& screenId) {
+            uint64_t value;
+            bool res = parcel.ReadUint64(value);
+            screenId = static_cast<ScreenId>(value);
+            return res;
+        }
+    );
+    if (!res) {
+        TLOGE(WmsLogTag::DMS, "fail to unmarshalling screenIds in stub.");
+        return DMError::DM_ERROR_IPC_FAILED;
+    }
+    return ret;
+}
+
 DMError OHOS::Rosen::ScreenSessionManagerProxy::SetOrientation(ScreenId screenId, Orientation orientation)
 {
     sptr<IRemoteObject> remote = Remote();
diff --git a/window_scene/screen_session_manager/src/zidl/screen_session_manager_stub.cpp b/window_scene/screen_session_manager/src/zidl/screen_session_manager_stub.cpp
index e16a3ad9a4bda2fe0cfc7f2f47a07f96a3884865..24a78009ebe2e8b2c50b887141dc653816751813 100644
--- a/window_scene/screen_session_manager/src/zidl/screen_session_manager_stub.cpp
+++ b/window_scene/screen_session_manager/src/zidl/screen_session_manager_stub.cpp
@@ -188,6 +188,21 @@ int32_t ScreenSessionManagerStub::OnRemoteRequest(uint32_t code, MessageParcel&
             }
             break;
         }
+        case DisplayManagerMessage::TRANS_ID_GET_PHYSICAL_SCREEN_IDS: {
+            std::vector<ScreenId> screenIds;
+            DMError ret  = GetPhysicalScreenIds(screenIds);
+            reply.WriteInt32(static_cast<int32_t>(ret));
+            bool res = MarshallingHelper::MarshallingVectorObj<ScreenId>(reply, screenIds,
+                [](Parcel& parcel, const ScreenId& screenId) {
+                    return parcel.WriteUint64(static_cast<uint64_t>(screenId));
+                }
+            );
+            if (!res) {
+                TLOGE(WmsLogTag::DMS, "fail to marshalling screenIds in stub.");
+                break;
+            }
+            break;
+        }
         case DisplayManagerMessage::TRANS_ID_SCREEN_GET_SUPPORTED_COLOR_GAMUTS: {
             ScreenId screenId = static_cast<ScreenId>(data.ReadUint64());
             std::vector<ScreenColorGamut> colorGamuts;
diff --git a/window_scene/test/dms_unittest/screen_session_manager_proxy_test.cpp b/window_scene/test/dms_unittest/screen_session_manager_proxy_test.cpp
index 464f693ed27af7bb58a9e87c80616031430a38a2..3e23e63b5dc535fc8844df5be2bfa6e6f4a8517b 100644
--- a/window_scene/test/dms_unittest/screen_session_manager_proxy_test.cpp
+++ b/window_scene/test/dms_unittest/screen_session_manager_proxy_test.cpp
@@ -25,6 +25,7 @@
 #include "screen_session_manager/include/screen_session_manager.h"
 #include "session_manager/include/scene_session_manager.h"
 #include "zidl/screen_session_manager_proxy.h"
+#include "mock_message_parcel.h"
 
 using namespace testing;
 using namespace testing::ext;
@@ -1793,5 +1794,43 @@ HWTEST_F(ScreenSessionManagerProxyTest, SetPrimaryDisplaySystemDpi, Function | S
     auto ret = screenSessionManagerProxy->SetPrimaryDisplaySystemDpi(dpi);
     EXPECT_EQ(DMError::DM_OK, ret);
 }
+
+/**
+ * @tc.name: GetPhysicalScreenIds
+ * @tc.desc: GetPhysicalScreenIds
+ * @tc.type: FUNC
+ */
+HWTEST_F(ScreenSessionManagerProxyTest, GetPhysicalScreenIds, Function | SmallTest | Level1)
+{
+    std::vector<ScreenId> screenIds;
+    sptr<IRemoteObject> impl;
+    auto ret = screenSessionManagerProxy->GetPhysicalScreenIds(screenIds);
+    EXPECT_EQ(DMError::DM_ERROR_IPC_FAILED, ret);
+
+    if (SceneBoardJudgement::IsSceneBoardEnabled()) {
+        ASSERT_NE(SingletonContainer::Get<ScreenManagerAdapter>().screenSessionManagerServiceProxy_, nullptr);
+        impl = SingletonContainer::Get<ScreenManagerAdapter>().screenSessionManagerServiceProxy_->AsObject();
+    } else {
+        ASSERT_NE(SingletonContainer::Get<ScreenManagerAdapter>().displayManagerServiceProxy_, nullptr);
+        impl = SingletonContainer::Get<ScreenManagerAdapter>().displayManagerServiceProxy_->AsObject();
+    }
+
+    screenSessionManagerProxy = new (std::nothrow) ScreenSessionManagerProxy(impl);
+    ASSERT_NE(screenSessionManagerProxy, nullptr);
+
+    MockMessageParcel::ClearAllErrorFlag();
+    MockMessageParcel::SetWriteInterfaceTokenErrorFlag(true);
+    ret = screenSessionManagerProxy->GetPhysicalScreenIds(screenIds);
+    EXPECT_EQ(DMRect::DM_ERROR_WRITE_INTERFACE_TOKEN_FAILED, ret);
+    
+    MockMessageParcel::SetWriteInterfaceTokenErrorFlag(false);
+    MockMessageParcel::SetReadInt32ErrorFlag(true);
+    ret = screenSessionManagerProxy->GetPhysicalScreenIds(screenIds);
+    EXPECT_EQ(DMRect::DM_ERROR_IPC_FAILED, ret);
+
+    MockMessageParcel::SetReadInt32ErrorFlag(false);
+    ret = screenSessionManagerProxy->GetPhysicalScreenIds(screenIds);
+    EXPECT_EQ(DMRect::DM_OK, ret);
+}
 }
 }
diff --git a/window_scene/test/dms_unittest/screen_session_manager_stub_test.cpp b/window_scene/test/dms_unittest/screen_session_manager_stub_test.cpp
index 5f8a40e324c036b96bba9efd1d92145d96ac5d65..e9d857d18840ce0020a32d3657e7fb768eec91e7 100644
--- a/window_scene/test/dms_unittest/screen_session_manager_stub_test.cpp
+++ b/window_scene/test/dms_unittest/screen_session_manager_stub_test.cpp
@@ -3288,6 +3288,24 @@ HWTEST_F(ScreenSessionManagerStubTest, ProcSetPrimaryDisplaySystemDpi, Function
     int res = stub_->OnRemoteRequest(code, data, reply, option);
     EXPECT_EQ(res, 0);
 }
+
+/**
+ * @tc.name: GetPhysicalScreenIds
+ * @tc.desc: normal function, GetPhysicalScreenIds test
+ * @tc.type: FUNC
+ */
+HWTEST_F(ScreenSessionManagerStubTest, GetPhysicalScreenIds, Function | SmallTest | Level2)
+{
+    MessageParcel data;
+    MessageParcel reply;
+    MessageOption option;
+    std::vector<ScreenId> screenIds;
+
+    data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
+    uint32_t code = static_cast<uint32_t>(DisplayManagerMessage::TRANS_ID_GET_PHYSICAL_SCREEN_IDS);
+    int res = stub_->OnRemoteRequest(code, data, reply, option);
+    EXPECT_EQ(res, 0);
+}
 }
 }
 }
\ No newline at end of file
diff --git a/window_scene/test/dms_unittest/screen_session_manager_test2.cpp b/window_scene/test/dms_unittest/screen_session_manager_test2.cpp
index 1f7db2934ef267e5cfa4b967474dc69a7c142002..0b96b3ae0052f23fd725a86e9ee16d1b50f81007 100644
--- a/window_scene/test/dms_unittest/screen_session_manager_test2.cpp
+++ b/window_scene/test/dms_unittest/screen_session_manager_test2.cpp
@@ -853,6 +853,26 @@ HWTEST_F(ScreenSessionManagerTest, ConvertIntToRotation, Function | SmallTest |
     targetRotation = ssm_->ConvertIntToRotation(rotation);
     EXPECT_EQ(targetRotation, Rotation::ROTATION_270);
 }
+
+/**
+ * @tc.name: GetPhysicalScreenIds
+ * @tc.desc: GetPhysicalScreenIds
+ * @tc.type: FUNC
+ */
+HWTEST_F(ScreenSessionManagerTest, GetPhysicalScreenIds, Function | SmallTest | Level3)
+{
+    ASSERT_NE(ssm_, nullptr);
+    std::vector<ScreenId> screenIds;
+    auto ret = ssm_->GetPhysicalScreenIds(screenIds);
+    EXPECT_EQ(ret, DMError::DM_OK);
+
+    ScreenId screenId = 11;
+    sptr<ScreenSession> screenSession = nullptr;
+    ssm_->screenSessionMap_.insert(std::make_pair(screenId, screenSession));
+    std::vector<ScreenId> screenIds1;
+    auto ret1 = ssm_->GetPhysicalScreenIds(screenIds1);
+    EXPECT_EQ(ret, DMError::DM_OK);
+}
 }
 }
 }
\ No newline at end of file