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 bc2ba00bf0d90731c3f1fa9e3f568246ff0e497f..db87d87496b3bdefd7870e5028fb7c43065dcfa1 100644
--- a/window_scene/screen_session_manager/include/screen_session_manager.h
+++ b/window_scene/screen_session_manager/include/screen_session_manager.h
@@ -497,6 +497,8 @@ public:
     Rotation GetConfigCorrectionByDisplayMode(FoldDisplayMode displayMode);
     Rotation RemoveRotationCorrection(Rotation rotation);
     void NotifySwitchUserAnimationFinish() override;
+    // mirror screen
+    bool HandleResolutionEffectChange();
 
 protected:
     ScreenSessionManager();
@@ -925,6 +927,16 @@ private:
     void WaitSwitchUserAnimateFinish(int32_t newUserId, bool isColdSwitch);
     void MakeMirrorAfterSwitchUser();
 
+    // mirror screen
+    bool SetResolutionEffect(ScreenId screenId,  uint32_t width, uint32_t height);
+    bool RecoveryResolutionEffect();
+    void RegisterSettingResolutionEffectObserver();
+    void SetResolutionEffectFromSettingData();
+    std::mutex setResolutionEffectFlagMutex_;
+    bool curResolutionEffectEnable_ = false;
+    bool GetResolutionEffectFlag();
+    void SetResolutionEffectFlag(bool enable);
+
 private:
     class ScbClientListenerDeathRecipient : public IRemoteObject::DeathRecipient {
         public:
diff --git a/window_scene/screen_session_manager/include/screen_setting_helper.h b/window_scene/screen_session_manager/include/screen_setting_helper.h
index 95b64bad1ad509c1110b0c8bb2181d0e0bf413e5..bb48061a49a76ef72bbecf4d32837a3cab47acd9 100644
--- a/window_scene/screen_session_manager/include/screen_setting_helper.h
+++ b/window_scene/screen_session_manager/include/screen_setting_helper.h
@@ -67,7 +67,10 @@ public:
     static bool GetSettingExtendScreenDpi(float& coef, const std::string& key = SETTING_EXTEND_DPI_KEY);
     static bool ConvertStrToUint64(const std::string& str, uint64_t& num);
     static bool ConvertStrToInt32(const std::string& str, int32_t& num);
-
+    static bool GetResolutionEffect(bool& enable,
+        const std::string& key = SETTING_RESOLUTION_EFFECT_KEY);
+    static void RegisterSettingResolutionEffectObserver(SettingObserver::UpdateFunc func);
+    static void UnregisterSettingResolutionEffectObserver();
 private:
     static const constexpr char* SETTING_DPI_KEY {"user_set_dpi_value"};
     static const constexpr char* SETTING_CAST_KEY {"huaweicast.data.privacy_projection_state"};
@@ -76,6 +79,7 @@ private:
     static const constexpr char* SETTING_SCREEN_MODE_KEY {"user_set_screen_mode_edid"};
     static const constexpr char* SETTING_EXTEND_DPI_KEY {"user_set_dpi_extend"};
     static const constexpr char* SETTING_DURING_CALL_KEY {"during_call_state"};
+    static const constexpr char* SETTING_RESOLUTION_EFFECT_KEY {"user_set_resolution_effect_select"};
     static const constexpr uint32_t BASE_TEN = 10;
     static sptr<SettingObserver> dpiObserver_;
     static sptr<SettingObserver> castObserver_;
@@ -83,6 +87,7 @@ private:
     static sptr<SettingObserver> wireCastObserver_;
     static sptr<SettingObserver> extendScreenDpiObserver_;
     static sptr<SettingObserver> duringCallStateObserver_;
+    static sptr<SettingObserver> resolutionEffectObserver_;
 };
 } // namespace Rosen
 } // namespace OHOS
diff --git a/window_scene/screen_session_manager/src/fold_screen_controller/super_fold_state_manager.cpp b/window_scene/screen_session_manager/src/fold_screen_controller/super_fold_state_manager.cpp
index f41cb52549a2ce21389366d84c9a267da7cb3831..e656ef56438d2364580097228b103fbeafa90b08 100644
--- a/window_scene/screen_session_manager/src/fold_screen_controller/super_fold_state_manager.cpp
+++ b/window_scene/screen_session_manager/src/fold_screen_controller/super_fold_state_manager.cpp
@@ -578,7 +578,9 @@ DMError SuperFoldStateManager::RefreshMirrorRegionInner(
         mirrorRegion.height_ = mainScreenProperty.GetScreenRealHeight();
     }
     mainScreenSession->UpdateMirrorWidth(mirrorRegion.width_);
-    mainScreenSession->UpdateMirrorHeight(mirrorRegion.height_);
+    mainScreenSession->UpdateMirrorHeight(mainScreenProperty.GetScreenRealHeight());
+    secondarySession->UpdateMirrorWidth(mirrorRegion.width_);
+    secondarySession->UpdateMirrorHeight(mirrorRegion.height_);
     secondarySession->SetMirrorScreenRegion(secondarySession->GetScreenId(), mirrorRegion);
     secondarySession->SetIsPhysicalMirrorSwitch(true);
     secondarySession->EnableMirrorScreenRegion();
diff --git a/window_scene/screen_session_manager/src/multi_screen_manager.cpp b/window_scene/screen_session_manager/src/multi_screen_manager.cpp
index 9e1acac5b0d8d1c4b0ebcd98bd0ec52c435787a4..b8dd9780d41f3bc9903b37279d37eaa3a51f781e 100644
--- a/window_scene/screen_session_manager/src/multi_screen_manager.cpp
+++ b/window_scene/screen_session_manager/src/multi_screen_manager.cpp
@@ -364,6 +364,7 @@ void MultiScreenManager::MultiScreenModeChange(sptr<ScreenSession> firstSession,
     } else {
         TLOGW(WmsLogTag::DMS, "multi screen operate type change failed.");
     }
+    ScreenSessionManager::GetInstance().HandleResolutionEffectChange();
 }
 
 void MultiScreenManager::DoFirstMainChangeExtend(sptr<IScreenSessionManagerClient> scbClient,
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 7bdfa57ee82451f7f682a0af89d97f960d65ef45..84527df53773133d67771caf8937ba8f51bc2b50 100644
--- a/window_scene/screen_session_manager/src/screen_session_manager.cpp
+++ b/window_scene/screen_session_manager/src/screen_session_manager.cpp
@@ -1745,6 +1745,7 @@ void ScreenSessionManager::HandlePhysicalMirrorDisconnect(sptr<ScreenSession> sc
     bool phyMirrorEnable)
 {
     if (phyMirrorEnable) {
+        RecoveryResolutionEffect();
         NotifyCastWhenScreenConnectChange(false);
         FreeDisplayMirrorNodeInner(screenSession);
         isPhyScreenConnected_ = false;
@@ -2599,6 +2600,152 @@ DMError ScreenSessionManager::SetResolution(ScreenId screenId, uint32_t width, u
     return DMError::DM_OK;
 }
 
+bool ScreenSessionManager::GetResolutionEffectFlag()
+{
+    std::lock_guard<std::mutex> lock(setResolutionEffectFlagMutex_);
+    return curResolutionEffectEnable_;
+}
+
+void ScreenSessionManager::SetResolutionEffectFlag(bool enable) {
+    std::lock_guard<std::mutex> lock(setResolutionEffectFlagMutex_);
+    curResolutionEffectEnable_ = enable;
+}
+
+bool ScreenSessionManager::HandleResolutionEffectChange()
+{
+    TLOGI(WmsLogTag::DMS, "start");
+    if (!g_isPcDevice || FoldScreenStateInternel::IsSuperFoldDisplayDevice()) {
+        TLOGI(WmsLogTag::DMS, "not support");
+        return false;
+    }
+    sptr<ScreenSession> internalSession = nullptr;
+    sptr<ScreenSession> externalSession = nullptr;
+    bool effectFlag = false;
+    ScreenSettingHelper::GetResolutionEffect(effectFlag);
+    GetInternalAndExternalSession(internalSession, externalSession);
+    if (!internalSession || !externalSession ||
+        externalSession->GetScreenCombination() != ScreenCombination::SCREEN_MIRROR) {
+        TLOGI(WmsLogTag::DMS, "Session null or not mirror");
+        RecoveryResolutionEffect();
+        return false;
+    }
+
+    uint32_t innerWidth = internalSession->GetScreenProperty().GetScreenRealWidth();
+    uint32_t innerHeight = internalSession->GetScreenProperty().GetScreenRealHeight();
+    uint32_t externalWidth = externalSession->GetScreenProperty().GetScreenRealWidth();
+    uint32_t externalHeight = externalSession->GetScreenProperty().GetScreenRealHeight();
+    uint32_t toWidth = innerWidth;
+    uint32_t toHeight = innerHeight;
+    if (innerHeight == 0 || externalHeight == 0) {
+        return false;
+    }
+    float innerResolution = static_cast<float>(innerWidth) / innerHeight;
+    float externalResolution = static_cast<float>(externalWidth) / externalHeight;
+    float diffResolution = innerResolution - externalResolution;
+
+    if (effectFlag && std::fabs(diffResolution) >= FLT_EPSILON) {
+        if (externalResolution > innerResolution ) {
+            toHeight = static_cast<uint32_t>(innerWidth / externalResolution);
+        } else {
+            toWidth = static_cast<uint32_t>(innerHeight * externalResolution);
+        }
+        SetResolutionEffectFlag(true);
+    } else {
+        SetResolutionEffectFlag(false);
+    }
+    SetResolutionEffect(internalSession->GetScreenId(), toWidth, toHeight);
+    return true;
+}
+
+bool ScreenSessionManager::SetResolutionEffect(ScreenId screenId,  uint32_t width, uint32_t height)
+{
+    TLOGI(WmsLogTag::DMS, "change resolution according to extend screen when in mirror screen combination: "
+        "%{public}" PRIu64 " %{public}d %{public}d", screenId, width, height);
+    if (!g_isPcDevice || FoldScreenStateInternel::IsSuperFoldDisplayDevice()) {
+        TLOGI(WmsLogTag::DMS, "not support");
+        return false;
+    }
+    sptr<ScreenSession> internalSession = nullptr;
+    sptr<ScreenSession> externalSession = nullptr;
+    GetInternalAndExternalSession(internalSession, externalSession);
+    if (!externalSession ||
+        externalSession->GetScreenCombination() != ScreenCombination::SCREEN_MIRROR) {
+        return false;
+    }
+    if (!internalSession || internalSession->GetScreenId() != screenId) {
+        TLOGI(WmsLogTag::DMS, "only internal session valid");
+        return false;
+    }
+    uint32_t realWidth = internalSession->GetScreenProperty().GetScreenRealWidth();
+    uint32_t realHeight = internalSession->GetScreenProperty().GetScreenRealHeight();
+    // 居中显示
+    DMRect toRect = {
+        std::floor((realWidth - width) / 2),
+        std::floor((realHeight - height) / 2),
+        width,
+        height
+    };
+    TLOGI(WmsLogTag::DMS, "toRect %{public}d %{public}d %{public}d %{public}d",
+        toRect.posX_, toRect.posY_, toRect.width_, toRect.height_);
+    // 内屏显示区域设置
+    internalSession->UpdatePropertyByResolution(toRect);
+    internalSession->PropertyChange(internalSession->GetScreenProperty(), ScreenPropertyChangeReason::CHANGE_MODE);
+    NotifyScreenChanged(internalSession->ConvertToScreenInfo(), ScreenChangeEvent::CHANGE_MODE);
+    NotifyDisplayChanged(internalSession->ConvertToDisplayInfo(), DisplayChangeEvent::DISPLAY_SIZE_CHANGED);
+    //无效区域填黑
+    auto displaynode = internalSession->GetDisplayNode();
+    displaynode->SetClipToBounds(true);
+    RSTransactionAdapter::FlushImplicitTransaction(internalSession->GetRSUIContext());
+    //RS侧SLR未适配，外屏显示会偏移需设置外屏投屏区域，适配后会下掉
+    OHOS::Rect rsRect = {toRect.posX_, toRect.posY_, width, height};
+    if (!GetResolutionEffectFlag()) {
+        rsRect = {0, 0, 0, 0};
+    }
+    rsInterface_.SetMirrorScreenVisibleRect(externalSession->GetScreenId(), rsRect);
+    // 多模光标需要的参数
+    externalSession->UpdateMirrorWidth(toRect.width_);
+    externalSession->UpdateMirrorHeight(toRect.height_);
+    NotifyScreenModeChange();
+    return true;
+}
+
+bool ScreenSessionManager::RecoveryResolutionEffect()
+{
+    TLOGI(WmsLogTag::DMS, "recovery inner and external screen resolution");
+    if (!g_isPcDevice || FoldScreenStateInternel::IsSuperFoldDisplayDevice()) {
+        TLOGI(WmsLogTag::DMS, "not support");
+        return false;
+    }
+    sptr<ScreenSession> internalSession = nullptr;
+    sptr<ScreenSession> externalSession = nullptr;
+    GetInternalAndExternalSession(internalSession, externalSession);
+    if (!GetResolutionEffectFlag() || !internalSession) {
+        return false;
+    }
+    DMRect RealResolutionRect = { 0, 0,
+        internalSession->GetScreenProperty().GetScreenRealWidth(),
+        internalSession->GetScreenProperty().GetScreenRealHeight()};
+    TLOGI(WmsLogTag::DMS, "RealResolutionRect %{public}d %{public}d %{public}d %{public}d",
+        RealResolutionRect.posX_, RealResolutionRect.posY_, RealResolutionRect.width_, RealResolutionRect.height_);  
+    internalSession->UpdatePropertyByResolution(RealResolutionRect);
+    internalSession->PropertyChange(internalSession->GetScreenProperty(), ScreenPropertyChangeReason::CHANGE_MODE);
+    NotifyScreenChanged(internalSession->ConvertToScreenInfo(), ScreenChangeEvent::CHANGE_MODE);
+    NotifyDisplayChanged(internalSession->ConvertToDisplayInfo(), DisplayChangeEvent::DISPLAY_SIZE_CHANGED);
+    auto displaynode = internalSession->GetDisplayNode();
+    displaynode->SetClipToBounds(false);
+    RSTransactionAdapter::FlushImplicitTransaction(internalSession->GetRSUIContext());
+
+    if (externalSession) {
+        OHOS::Rect rsRect = {0, 0, 0, 0};
+        rsInterface_.SetMirrorScreenVisibleRect(externalSession->GetScreenId(), rsRect);
+        externalSession->UpdateMirrorWidth(externalSession->GetScreenProperty().GetScreenRealWidth());
+        externalSession->UpdateMirrorHeight(externalSession->GetScreenProperty().GetScreenRealHeight());
+    }
+    NotifyScreenModeChange();
+    SetResolutionEffectFlag(false);
+    return true;
+}
+
 DMError ScreenSessionManager::GetDensityInCurResolution(ScreenId screenId, float& virtualPixelRatio)
 {
     DmsXcollie dmsXcollie("DMS:GetDensityInCurResolution", XCOLLIE_TIMEOUT_10S);
@@ -4260,6 +4407,7 @@ void ScreenSessionManager::BootFinishedCallback(const char *key, const char *val
             that.foldScreenPowerInit_();
         }
         that.RegisterSettingRotationObserver();
+        that.RegisterSettingResolutionEffectObserver();
         if (that.defaultDpi) {
             auto ret = ScreenSettingHelper::SetSettingDefaultDpi(that.defaultDpi, SET_SETTING_DPI_KEY);
             if (!ret) {
@@ -4312,6 +4460,22 @@ void ScreenSessionManager::SetRotateLockedFromSettingData()
     }
 }
 
+void ScreenSessionManager::RegisterSettingResolutionEffectObserver()
+{
+    TLOGI(WmsLogTag::DMS, "Register Setting Observer");
+    SettingObserver::UpdateFunc updateFunc = [&](const std::string& key) { SetResolutionEffectFromSettingData(); };
+    ScreenSettingHelper::RegisterSettingResolutionEffectObserver(updateFunc);
+}
+
+void ScreenSessionManager::SetResolutionEffectFromSettingData()
+{
+    TLOGI(WmsLogTag::DMS, "update");
+    bool enable = false;
+    ScreenSettingHelper::GetResolutionEffect(enable);
+    TLOGI(WmsLogTag::DMS, "update ResolutionEffect enable: %{public}u", enable);
+    HandleResolutionEffectChange();
+}
+
 void ScreenSessionManager::RegisterSettingDpiObserver()
 {
     TLOGI(WmsLogTag::DMS, "Register Setting Dpi Observer");
@@ -9033,6 +9197,8 @@ void ScreenSessionManager::SwitchScbNodeHandle(int32_t newUserId, int32_t newScb
     }
     currentUserId_ = newUserId;
     currentScbPId_ = newScbPid;
+    ScreenSettingHelper::UnregisterSettingResolutionEffectObserver();
+    RegisterSettingResolutionEffectObserver();
     scbSwitchCV_.notify_all();
     oldScbDisplayMode_ = GetFoldDisplayMode();
 #endif
diff --git a/window_scene/screen_session_manager/src/screen_setting_helper.cpp b/window_scene/screen_session_manager/src/screen_setting_helper.cpp
index 95e960d45f7502d4a4751d9e1d961a0421052637..8dfc6a3567644c40e3cbc071b18f51682a958885 100644
--- a/window_scene/screen_session_manager/src/screen_setting_helper.cpp
+++ b/window_scene/screen_session_manager/src/screen_setting_helper.cpp
@@ -33,6 +33,7 @@ sptr<SettingObserver> ScreenSettingHelper::rotationObserver_;
 sptr<SettingObserver> ScreenSettingHelper::wireCastObserver_;
 sptr<SettingObserver> ScreenSettingHelper::extendScreenDpiObserver_;
 sptr<SettingObserver> ScreenSettingHelper::duringCallStateObserver_;
+sptr<SettingObserver> ScreenSettingHelper::resolutionEffectObserver_;
 constexpr int32_t PARAM_NUM_TEN = 10;
 constexpr uint32_t EXPECT_SCREEN_MODE_SIZE = 2;
 constexpr uint32_t EXPECT_RELATIVE_POSITION_SIZE = 3;
@@ -56,6 +57,7 @@ constexpr float EXTEND_SCREEN_DPI_ZERO_PARAMETER = 0.85f;
 constexpr float EXTEND_SCREEN_DPI_ONE_PARAMETER = 1.00f;
 const std::string SCREEN_SHAPE = system::GetParameter("const.window.screen_shape", "0:0");
 constexpr int32_t INDEX_EXTEND_SCREEN_DPI_POSITION = -1;
+constexpr int32_t ENABLE_RESOLUTION_EFFECT = 1;
 
 void ScreenSettingHelper::RegisterSettingDpiObserver(SettingObserver::UpdateFunc func)
 {
@@ -677,5 +679,51 @@ bool ScreenSettingHelper::SetSettingDuringCallState(const std::string& key, bool
     TLOGI(WmsLogTag::DMS, "put during call state is %{public}d", value);
     return true;
 }
+
+void ScreenSettingHelper::RegisterSettingResolutionEffectObserver(SettingObserver::UpdateFunc func)
+{
+    if (resolutionEffectObserver_) {
+        TLOGE(WmsLogTag::DMS, "setting observer is registered");
+        return;
+    }
+    SettingProvider& provider = SettingProvider::GetInstance(DISPLAY_MANAGER_SERVICE_SA_ID);
+    resolutionEffectObserver_ = provider.CreateObserver(SETTING_RESOLUTION_EFFECT_KEY, func);
+    if (resolutionEffectObserver_ == nullptr) {
+        TLOGE(WmsLogTag::DMS, "create observer failed");
+        return;
+    }
+    ErrCode ret = provider.RegisterObserver(resolutionEffectObserver_);
+    if (ret != ERR_OK) {
+        TLOGW(WmsLogTag::DMS, "failed, ret=%{public}d", ret);
+        resolutionEffectObserver_ = nullptr;
+    }
+}
+
+void ScreenSettingHelper::UnregisterSettingResolutionEffectObserver()
+{
+    if (resolutionEffectObserver_ == nullptr) {
+        TLOGD(WmsLogTag::DMS, "setting observer is nullptr");
+        return;
+    }
+    SettingProvider& provider = SettingProvider::GetInstance(DISPLAY_MANAGER_SERVICE_SA_ID);
+    ErrCode ret = provider.UnregisterObserver(resolutionEffectObserver_);
+    if (ret != ERR_OK) {
+        TLOGW(WmsLogTag::DMS, "failed, ret=%{public}d", ret);
+    }
+    resolutionEffectObserver_ = nullptr;
+}
+
+bool ScreenSettingHelper::GetResolutionEffect(bool& enable, const std::string& key)
+{
+    int value = 0;
+    SettingProvider& settingProvider = SettingProvider::GetInstance(DISPLAY_MANAGER_SERVICE_SA_ID);
+    ErrCode ret = settingProvider.GetIntValue(key, value);
+    if (ret != ERR_OK) {
+        TLOGE(WmsLogTag::DMS, "failed, ret=%{public}d", ret);
+        return false;
+    }
+    enable = (value == ENABLE_RESOLUTION_EFFECT);
+    return true;
+}
 } // namespace Rosen
 } // namespace OHOS
diff --git a/window_scene/screen_session_manager/src/setting_provider.cpp b/window_scene/screen_session_manager/src/setting_provider.cpp
index 06397eac273f59f65f8427006d9af5a75ad9f645..b9793185ad0062be89b4c99758846b913908fe11 100644
--- a/window_scene/screen_session_manager/src/setting_provider.cpp
+++ b/window_scene/screen_session_manager/src/setting_provider.cpp
@@ -36,6 +36,7 @@ const std::string SETTING_COLUMN_KEYWORD = "KEYWORD";
 const std::string SETTING_COLUMN_VALUE = "VALUE";
 const std::string SETTING_URI_PROXY = "datashare:///com.ohos.settingsdata/entry/settingsdata/SETTINGSDATA?Proxy=true";
 const std::string WALL_KEY = "wallpaperAodDisplay";
+const std::string SETTING_RESOLUTION_EFFECT_KEY = "user_set_resolution_effect_select";
 const std::string DURING_CALL_KEY = "during_call_state";
 const std::string SETTING_MULTI_USER_URI = "datashare:///com.ohos.settingsdata/entry/settingsdata/";
 const std::string SETTING_MULTI_USER_TABLE = "USER_SETTINGSDATA_";
@@ -136,7 +137,8 @@ ErrCode SettingProvider::RegisterObserver(const sptr<SettingObserver>& observer)
         return ERR_NO_INIT;
     }
     std::string callingIdentity = IPCSkeleton::ResetCallingIdentity();
-    Uri uri = (observer->GetKey() == DURING_CALL_KEY) ?
+    Uri uri = ((observer->GetKey() == DURING_CALL_KEY ||
+        observer->GetKey() == SETTING_RESOLUTION_EFFECT_KEY )) ?
         AssembleUriMultiUser(observer->GetKey()) : AssembleUri(observer->GetKey());
     auto helper = CreateDataShareHelper();
     if (helper == nullptr) {
@@ -198,7 +200,8 @@ ErrCode SettingProvider::GetStringValue(const std::string& key, std::string& val
     std::vector<std::string> columns = {SETTING_COLUMN_VALUE};
     DataShare::DataSharePredicates predicates;
     predicates.EqualTo(SETTING_COLUMN_KEYWORD, key);
-    Uri uri = (key == WALL_KEY || key == DURING_CALL_KEY) ? AssembleUriMultiUser(key) : AssembleUri(key);
+    Uri uri = (key == WALL_KEY || key == DURING_CALL_KEY || key == SETTING_RESOLUTION_EFFECT_KEY) ?
+        AssembleUriMultiUser(key) : AssembleUri(key);
     auto resultSet = helper->Query(uri, predicates, columns);
     ReleaseDataShareHelper(helper);
     if (resultSet == nullptr) {
diff --git a/window_scene/session/screen/include/screen_property.h b/window_scene/session/screen/include/screen_property.h
index 0f4ccde8a5bc0f5c2adccb7010afa983353ae7fa..77298f1f5d8bb3b4897e7320d4109272c6d97987 100644
--- a/window_scene/session/screen/include/screen_property.h
+++ b/window_scene/session/screen/include/screen_property.h
@@ -214,6 +214,7 @@ public:
     int32_t GetInputOffsetY();
 
     void SetInputOffsetY();
+    void SetInputOffset(int32_t x, int32_t y);
     void SetMirrorWidth(uint32_t mirrorWidth);
     uint32_t GetMirrorWidth() const;
     void SetMirrorHeight(uint32_t mirrorHeight);
diff --git a/window_scene/session/screen/include/screen_session.h b/window_scene/session/screen/include/screen_session.h
index 5ab1768dd6cad1e4c19fd7fdee6b927f8075481e..6b538af22593984ab4dea84766b7c77cacd2afa3 100644
--- a/window_scene/session/screen/include/screen_session.h
+++ b/window_scene/session/screen/include/screen_session.h
@@ -208,6 +208,7 @@ public:
     void UpdateRefreshRate(uint32_t refreshRate);
     uint32_t GetRefreshRate();
     void UpdatePropertyByResolution(uint32_t width, uint32_t height);
+    void UpdatePropertyByResolution(const DMRect& rect);
     void UpdatePropertyByFakeBounds(uint32_t width, uint32_t height);
     void SetName(std::string name);
     void SetInnerName(std::string innerName);
diff --git a/window_scene/session/screen/src/screen_property.cpp b/window_scene/session/screen/src/screen_property.cpp
index 8edb52dbf968b01d71a157874091064a614a8bf9..9078bae8954fcc7998b8af093361496d902e88ad 100644
--- a/window_scene/session/screen/src/screen_property.cpp
+++ b/window_scene/session/screen/src/screen_property.cpp
@@ -664,6 +664,12 @@ void ScreenProperty::SetInputOffsetY()
     }
 }
 
+void ScreenProperty::SetInputOffset(int32_t x, int32_t y)
+{
+    inputOffsetX_ = x;
+    inputOffsetY_ = y;
+}
+
 float ScreenProperty::CalculatePPI()
 {
     int32_t phywidth = GetPhyWidth();
diff --git a/window_scene/session/screen/src/screen_session.cpp b/window_scene/session/screen/src/screen_session.cpp
index 859ba32099af129ca04d0ad6833faf2751c9b9fa..cc4ed28b798eb63621ee122c8738256151c2a633 100644
--- a/window_scene/session/screen/src/screen_session.cpp
+++ b/window_scene/session/screen/src/screen_session.cpp
@@ -724,6 +724,26 @@ void ScreenSession::UpdatePropertyByResolution(uint32_t width, uint32_t height)
     property_.SetBounds(screenBounds);
 }
 
+void ScreenSession::UpdatePropertyByResolution(const DMRect& rect)
+{
+    auto screenBounds = property_.GetBounds();
+    screenBounds.rect_.left_ = rect.posX_;
+    screenBounds.rect_.top_ = rect.posY_;
+    screenBounds.rect_.width_ = rect.width_;
+    screenBounds.rect_.height_ = rect.height_;
+    property_.SetBounds(screenBounds);
+    // 多模触屏判断是否是有效区域用
+    property_.SetValidWidth(rect.width_);
+    property_.SetValidHeight(rect.height_);
+    property_.SetInputOffset(rect.posX_, rect.posY_);
+    // 多模触屏用于计算原始屏幕大小，配合上述参数计算缩放用
+    property_.SetScreenAreaWidth(rect.width_);
+    property_.SetScreenAreaHeight(rect.height_);
+    // 多模光标用于计算内屏有效区域
+    property_.SetMirrorWidth(rect.width_);
+    property_.SetMirrorHeight(rect.height_);
+}
+
 void ScreenSession::UpdatePropertyByFakeBounds(uint32_t width, uint32_t height)
 {
     auto screenFakeBounds = property_.GetFakeBounds();
diff --git a/window_scene/test/dms_unittest/screen_property_test.cpp b/window_scene/test/dms_unittest/screen_property_test.cpp
index ca424ce58f217091f4bb9814581349d630782256..312369d6804160aecb32e0aa683c35adf527ace3 100644
--- a/window_scene/test/dms_unittest/screen_property_test.cpp
+++ b/window_scene/test/dms_unittest/screen_property_test.cpp
@@ -970,6 +970,25 @@ HWTEST_F(ScreenPropertyTest, SetPhysicalTouchBounds, TestSize.Level1)
     EXPECT_EQ(property->physicalTouchBounds_.rect_.width_, 100);
     EXPECT_EQ(property->physicalTouchBounds_.rect_.height_, 200);
 }
+
+/**
+ * @tc.name: SetInputOffset
+ * @tc.desc: SetInputOffset
+ * @tc.type: FUNC
+ */
+HWTEST_F(ScreenPropertyTest, SetInputOffset, TestSize.Level1)
+{
+    std::shared_ptr<ScreenProperty> property = std::make_shared<ScreenProperty>();
+    property->SetInputOffset(0, 0);
+    EXPECT_EQ(property->GetInputOffsetX(), 0);
+    EXPECT_EQ(property->GetInputOffsetY(), 0);
+    property->SetInputOffset(-1, -2);
+    EXPECT_EQ(property->GetInputOffsetX(), -1);
+    EXPECT_EQ(property->GetInputOffsetY(), -2);
+    property->SetInputOffset(1, 2);
+    EXPECT_EQ(property->GetInputOffsetX(), 1);
+    EXPECT_EQ(property->GetInputOffsetY(), 2);
+}
 } // namespace
 } // namespace Rosen
 } // namespace OHOS
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 f88edbefb0fd6dc1bb07d6ebe0c3dc496f44078d..4e526d9c07989f411def8b319d3034a082fbd7c0 100644
--- a/window_scene/test/dms_unittest/screen_session_manager_test2.cpp
+++ b/window_scene/test/dms_unittest/screen_session_manager_test2.cpp
@@ -2122,6 +2122,142 @@ HWTEST_F(ScreenSessionManagerTest, HandleFoldDeviceScreenConnect, TestSize.Level
     EXPECT_TRUE(g_errLog.find("event: connect") != std::string::npos);
     g_errLog.clear();
 }
+
+/**
+ * @tc.name: HandleResolutionEffectChange
+ * @tc.desc: HandleResolutionEffectChange
+ * @tc.type: FUNC
+ */
+HWTEST_F(ScreenSessionManagerTest, HandleResolutionEffectChange, TestSize.Level1)
+{
+    ASSERT_NE(ssm_, nullptr);
+ 
+    sptr<ScreenSession> screenSession1 = new ScreenSession(51, ScreenProperty(), 0);
+    ASSERT_NE(nullptr, screenSession1);
+    screenSession1->SetIsCurrentInUse(true);
+    screenSession1->SetScreenType(ScreenType::REAL);
+    screenSession1->isInternal_ = true;
+
+    sptr<ScreenSession> screenSession2 = new ScreenSession(52, ScreenProperty(), 0);
+    ASSERT_NE(nullptr, screenSession2);
+    screenSession2->SetIsCurrentInUse(true);
+    screenSession2->SetScreenType(ScreenType::REAL);
+    screenSession2->isInternal_ = false;
+    auto ret = ssm_->HandleResolutionEffectChange();
+    EXPECT_FALSE(ret);
+
+    ssm_->screenSessionMap_[51] = screenSession1;
+    ssm_->screenSessionMap_[52] = screenSession2;
+    sptr<ScreenSession> externalSession = nullptr;
+    sptr<ScreenSession> internalSession = nullptr;
+    ssm_->GetInternalAndExternalSession(internalSession, externalSession);
+    EXPECT_EQ(internalSession, screenSession1);
+    EXPECT_EQ(externalSession, screenSession2);
+
+    screenSession2->SetScreenCombination(ScreenCombination::SCREEN_MIRROR);
+    ret = ssm_->HandleResolutionEffectChange();
+    EXPECT_TRUE(ret);
+    EXPECT_FALSE(ssm_->curResolutionEffectEnable_);
+
+    ssm_->screenSessionMap_.erase(51);
+    ssm_->screenSessionMap_.erase(52);
+}
+
+/**
+ * @tc.name: SetResolutionEffect
+ * @tc.desc: SetResolutionEffect
+ * @tc.type: FUNC
+ */
+HWTEST_F(ScreenSessionManagerTest, SetResolutionEffect, TestSize.Level1)
+{
+    ASSERT_NE(ssm_, nullptr);
+
+    sptr<ScreenSession> screenSession1 = new ScreenSession(51, ScreenProperty(), 0);
+    ASSERT_NE(nullptr, screenSession1);
+    screenSession1->SetIsCurrentInUse(true);
+    screenSession1->SetScreenType(ScreenType::REAL);
+    screenSession1->isInternal_ = true;
+
+    sptr<ScreenSession> screenSession2 = new ScreenSession(52, ScreenProperty(), 0);
+    ASSERT_NE(nullptr, screenSession2);
+    screenSession2->SetIsCurrentInUse(true);
+    screenSession2->SetScreenType(ScreenType::REAL);
+    screenSession2->isInternal_ = false;
+
+    ssm_->screenSessionMap_[51] = screenSession1;
+    ssm_->screenSessionMap_[52] = screenSession2;
+    sptr<ScreenSession> externalSession = nullptr;
+    sptr<ScreenSession> internalSession = nullptr;
+    ssm_->GetInternalAndExternalSession(internalSession, externalSession);
+    EXPECT_EQ(internalSession, screenSession1);
+    EXPECT_EQ(externalSession, screenSession2);
+
+    auto ret = ssm_->SetResolutionEffect(51, 3120, 2080);
+    EXPECT_FALSE(ret);
+
+    ret = ssm_->SetResolutionEffect(52, 3120, 2080);
+    EXPECT_FALSE(ret);
+
+    screenSession2->SetScreenCombination(ScreenCombination::SCREEN_MIRROR);
+    ret = ssm_->SetResolutionEffect(51, 3120, 2080);
+    EXPECT_TRUE(ret);
+    EXPECT_EQ(screenSession1->GetScreenProperty().GetBounds().rect_.width_, 3120);
+    EXPECT_EQ(screenSession1->GetScreenProperty().GetBounds().rect_.height_, 2080);
+    EXPECT_EQ(screenSession2->GetScreenProperty().GetMirrorWidth(), 3120);
+    EXPECT_EQ(screenSession2->GetScreenProperty().GetMirrorHeight(), 2080);
+
+    ssm_->screenSessionMap_.erase(51);
+    ssm_->screenSessionMap_.erase(52);
+}
+
+/**
+ * @tc.name: SetResolutionEffect
+ * @tc.desc: SetResolutionEffect
+ * @tc.type: FUNC
+ */
+HWTEST_F(ScreenSessionManagerTest, RecoveryResolutionEffect, TestSize.Level1)
+{
+    ASSERT_NE(ssm_, nullptr);
+
+    sptr<ScreenSession> screenSession1 = new ScreenSession(51, ScreenProperty(), 0);
+    ASSERT_NE(nullptr, screenSession1);
+    screenSession1->SetIsCurrentInUse(true);
+    screenSession1->SetScreenType(ScreenType::REAL);
+    screenSession1->isInternal_ = true;
+
+    sptr<ScreenSession> screenSession2 = new ScreenSession(52, ScreenProperty(), 0);
+    ASSERT_NE(nullptr, screenSession2);
+    screenSession2->SetIsCurrentInUse(true);
+    screenSession2->SetScreenType(ScreenType::REAL);
+    screenSession2->isInternal_ = false;
+
+    ssm_->screenSessionMap_[51] = screenSession1;
+    ssm_->screenSessionMap_[52] = screenSession2;
+    sptr<ScreenSession> externalSession = nullptr;
+    sptr<ScreenSession> internalSession = nullptr;
+    ssm_->GetInternalAndExternalSession(internalSession, externalSession);
+    ASSERT_EQ(internalSession, screenSession1);
+    ASSERT_EQ(externalSession, screenSession2);
+
+    auto ret = ssm_->RecoveryResolutionEffect();
+    EXPECT_FALSE(ret);
+
+    ssm_->curResolutionEffectEnable_ = true;
+    ret = ssm_->RecoveryResolutionEffect();
+    EXPECT_TRUE(ret);
+    EXPECT_FALSE(ssm_->curResolutionEffectEnable_);
+    EXPECT_EQ(screenSession1->GetScreenProperty().GetBounds().rect_.width_,
+        screenSession1->GetScreenProperty().GetScreenRealWidth());
+    EXPECT_EQ(screenSession1->GetScreenProperty().GetBounds().rect_.height_,
+        screenSession1->GetScreenProperty().GetScreenRealHeight());
+    EXPECT_EQ(screenSession2->GetScreenProperty().GetMirrorWidth(),
+            screenSession1->GetScreenProperty().GetScreenRealWidth());
+    EXPECT_EQ(screenSession2->GetScreenProperty().GetMirrorHeight(),
+            screenSession1->GetScreenProperty().GetScreenRealHeight());
+
+    ssm_->screenSessionMap_.erase(51);
+    ssm_->screenSessionMap_.erase(52);
+}
 }
 }
 }
\ No newline at end of file
diff --git a/window_scene/test/dms_unittest/screen_setting_helper_test.cpp b/window_scene/test/dms_unittest/screen_setting_helper_test.cpp
index d5033e6675f65c72124351bb2154647fdb300a50..4ab87ff373164cd20539457e566b85b70943289d 100644
--- a/window_scene/test/dms_unittest/screen_setting_helper_test.cpp
+++ b/window_scene/test/dms_unittest/screen_setting_helper_test.cpp
@@ -953,6 +953,76 @@ namespace {
         screenSettingHelper.GetSettingDuringCallState(value);
         ASSERT_TRUE(value);
     }
+     
+    /**
+     * @tc.name: RegisterSettingResolutionEffectObserver
+     * @tc.desc: RegisterSettingResolutionEffectObserver
+     * @tc.type: FUNC
+     */
+    HWTEST_F(ScreenSettingHelperTest, RegisterSettingResolutionEffectObserver, TestSize.Level1)
+    {
+        bool flag = false;
+        auto func = [&flag] (const std::string&) {
+            TLOGI(WmsLogTag::DMS, "UT test");
+            flag = true;
+        };
+        ScreenSettingHelper::RegisterSettingResolutionEffectObserver(func);
+        ASSERT_NE(ScreenSettingHelper::resolutionEffectObserver_, nullptr);
+            
+        g_errLog.clear();
+        LOG_SetCallback(MyLogCallback);
+        bool flag1 = false;
+        auto func1 = [&flag1] (const std::string&) {
+            TLOGI(WmsLogTag::DMS, "UT test");
+            flag1 = true;
+        };
+        ScreenSettingHelper::resolutionEffectObserver_ = new SettingObserver;
+        ScreenSettingHelper::RegisterSettingResolutionEffectObserver(func1);
+        EXPECT_TRUE(g_errLog.find("setting observer is registered") != std::string::npos);
+        LOG_SetCallback(nullptr);
+    }
+ 
+    /**
+     * @tc.name: UnRegisterSettingResolutionEffectObserver
+     * @tc.desc: UnRegisterSettingResolutionEffectObserver
+     * @tc.type: FUNC
+     */
+    HWTEST_F(ScreenSettingHelperTest, UnregisterSettingResolutionEffectObserver, TestSize.Level1)
+    {
+        ScreenSettingHelper::resolutionEffectObserver_ = new SettingObserver;
+        ScreenSettingHelper::UnregisterSettingResolutionEffectObserver();
+        ASSERT_EQ(ScreenSettingHelper::resolutionEffectObserver_, nullptr);
+
+        ScreenSettingHelper::resolutionEffectObserver_ = nullptr;
+        ScreenSettingHelper::UnregisterSettingResolutionEffectObserver();
+        ASSERT_EQ(ScreenSettingHelper::resolutionEffectObserver_, nullptr);
+    }
+
+    /**
+     * @tc.name: UnRegisterSettingResolutionEffectObserver
+     * @tc.desc: UnRegisterSettingResolutionEffectObserver
+     * @tc.type: FUNC
+     */
+    HWTEST_F(ScreenSettingHelperTest, UnregisterSettingResolutionEffectObserver02, TestSize.Level1)
+    {
+        ScreenSettingHelper::resolutionEffectObserver_ = nullptr;
+        ScreenSettingHelper::UnregisterSettingResolutionEffectObserver();
+        ASSERT_EQ(ScreenSettingHelper::resolutionEffectObserver_, nullptr);
+    }
+ 
+    /**
+     * @tc.name: GetResolutionEffectTest
+     * @tc.desc: Test GetResolutionEffectTest func
+     * @tc.type: FUNC
+     */
+    HWTEST_F(ScreenSettingHelperTest, GetResolutionEffectTestTest, Function | SmallTest | Level3)
+    {
+        ScreenSettingHelper screenSettingHelper = ScreenSettingHelper();
+        bool value = true;
+ 
+        screenSettingHelper.GetResolutionEffect(value);
+        ASSERT_TRUE(value);
+    }
 }
 } // namespace Rosen
 } // namespace OHOS
\ No newline at end of file