diff --git a/dm/include/display_manager_adapter.h b/dm/include/display_manager_adapter.h
index 71312401bfb77295303cdfabf987b3c434a48b5e..b857f49a99107b8506a46054140f30db9f840aae 100644
--- a/dm/include/display_manager_adapter.h
+++ b/dm/include/display_manager_adapter.h
@@ -94,6 +94,7 @@ public:
     virtual FoldStatus GetFoldStatus();
     virtual FoldDisplayMode GetFoldDisplayMode();
     virtual void SetFoldDisplayMode(const FoldDisplayMode);
+    virtual void SetFoldDisplayModeAsync(const FoldDisplayMode);
     virtual DMError SetFoldDisplayModeFromJs(const FoldDisplayMode, std::string reason = "");
     virtual void SetDisplayScale(ScreenId screenId, float scaleX, float scaleY, float pivotX, float pivotY);
     virtual void SetFoldStatusLocked(bool locked);
diff --git a/dm/src/display_manager.cpp b/dm/src/display_manager.cpp
index 3dba1825739ea67c0f4f2a3f83ff4f49b158eed4..bd65da5f9d19cc1725e5f533d7746f7b348cf3c6 100644
--- a/dm/src/display_manager.cpp
+++ b/dm/src/display_manager.cpp
@@ -90,6 +90,7 @@ public:
     FoldDisplayMode GetFoldDisplayMode();
     FoldDisplayMode GetFoldDisplayModeForExternal();
     void SetFoldDisplayMode(const FoldDisplayMode);
+    void SetFoldDisplayModeAsync(const FoldDisplayMode);
     DMError SetFoldDisplayModeFromJs(const FoldDisplayMode, std::string reason = "");
     void SetDisplayScale(ScreenId screenId, float scaleX, float scaleY, float pivotX, float pivotY);
     void SetFoldStatusLocked(bool locked);
@@ -1151,6 +1152,11 @@ void DisplayManager::SetFoldDisplayMode(const FoldDisplayMode mode)
     pImpl_->SetFoldDisplayMode(mode);
 }
 
+void DisplayManager::SetFoldDisplayModeAsync(const FoldDisplayMode mode)
+{
+    pImpl_->SetFoldDisplayModeAsync(mode);
+}
+
 DMError DisplayManager::SetFoldDisplayModeFromJs(const FoldDisplayMode mode, std::string reason)
 {
     return pImpl_->SetFoldDisplayModeFromJs(mode, reason);
@@ -1172,6 +1178,11 @@ void DisplayManager::Impl::SetFoldDisplayMode(const FoldDisplayMode mode)
     SingletonContainer::Get<DisplayManagerAdapter>().SetFoldDisplayMode(mode);
 }
 
+void DisplayManager::Impl::SetFoldDisplayModeAsync(const FoldDisplayMode mode)
+{
+    SingletonContainer::Get<DisplayManagerAdapter>().SetFoldDisplayModeAsync(mode);
+}
+
 DMError DisplayManager::Impl::SetFoldDisplayModeFromJs(const FoldDisplayMode mode, std::string reason)
 {
     return SingletonContainer::Get<DisplayManagerAdapter>().SetFoldDisplayModeFromJs(mode, reason);
diff --git a/dm/src/display_manager_adapter.cpp b/dm/src/display_manager_adapter.cpp
index 9571197b3d7fb64b37d28cfe1bf74b0c171a84ad..2bcd9bd367b94899d4ca3a773bb24eec4fc1ee89 100644
--- a/dm/src/display_manager_adapter.cpp
+++ b/dm/src/display_manager_adapter.cpp
@@ -1178,6 +1178,15 @@ void DisplayManagerAdapter::SetFoldDisplayMode(const FoldDisplayMode mode)
     }
 }
 
+void DisplayManagerAdapter::SetFoldDisplayModeAsync(const FoldDisplayMode mode)
+{
+    INIT_PROXY_CHECK_RETURN();
+
+    if (screenSessionManagerServiceProxy_) {
+        screenSessionManagerServiceProxy_->SetFoldDisplayModeAsync(mode);
+    }
+}
+
 DMError DisplayManagerAdapter::SetFoldDisplayModeFromJs(const FoldDisplayMode mode, std::string reason)
 {
     INIT_PROXY_CHECK_RETURN(DMError::DM_ERROR_INIT_DMS_PROXY_LOCKED);
diff --git a/dm_lite/include/display_manager_adapter_lite.h b/dm_lite/include/display_manager_adapter_lite.h
index 73d8eed5af427089eece1f8ec84a7c73fe7db84f..ef9090a6376f13df5baea06ff7e755a21053df50 100644
--- a/dm_lite/include/display_manager_adapter_lite.h
+++ b/dm_lite/include/display_manager_adapter_lite.h
@@ -59,6 +59,7 @@ public:
     virtual FoldStatus GetFoldStatus();
     virtual FoldDisplayMode GetFoldDisplayMode();
     virtual void SetFoldDisplayMode(const FoldDisplayMode);
+    virtual void SetFoldDisplayModeAsync(const FoldDisplayMode);
     virtual sptr<DisplayInfo> GetDisplayInfo(DisplayId displayId);
     virtual sptr<CutoutInfo> GetCutoutInfo(DisplayId displayId);
     virtual VirtualScreenFlag GetVirtualScreenFlag(ScreenId screenId);
diff --git a/dm_lite/include/display_manager_lite_proxy.h b/dm_lite/include/display_manager_lite_proxy.h
index dce102a3b329a1419392b5bb16cf9b5ac3daf038..9128645e49d010731daefed6d4070ccc7be6b5b3 100644
--- a/dm_lite/include/display_manager_lite_proxy.h
+++ b/dm_lite/include/display_manager_lite_proxy.h
@@ -47,6 +47,7 @@ public:
 
     FoldDisplayMode GetFoldDisplayMode();
     void SetFoldDisplayMode(const FoldDisplayMode displayMode);
+    void SetFoldDisplayModeAsync(const FoldDisplayMode displayMode);
     bool IsFoldable();
     FoldStatus GetFoldStatus();
     sptr<DisplayInfo> GetDefaultDisplayInfo();
diff --git a/dm_lite/src/display_manager_adapter_lite.cpp b/dm_lite/src/display_manager_adapter_lite.cpp
index f6789bad36434e7c31131205c872804db3e9c236..79841e9235b7df58a1c66ede0b4bb0ea8875a47e 100644
--- a/dm_lite/src/display_manager_adapter_lite.cpp
+++ b/dm_lite/src/display_manager_adapter_lite.cpp
@@ -146,6 +146,13 @@ void DisplayManagerAdapterLite::SetFoldDisplayMode(const FoldDisplayMode mode)
     return displayManagerServiceProxy_->SetFoldDisplayMode(mode);
 }
 
+void DisplayManagerAdapterLite::SetFoldDisplayModeAsync(const FoldDisplayMode mode)
+{
+    INIT_PROXY_CHECK_RETURN();
+
+    return displayManagerServiceProxy_->SetFoldDisplayModeAsync(mode);
+}
+
 sptr<DisplayInfo> DisplayManagerAdapterLite::GetDisplayInfo(DisplayId displayId)
 {
     if (displayId == DISPLAY_ID_INVALID) {
diff --git a/dm_lite/src/display_manager_lite.cpp b/dm_lite/src/display_manager_lite.cpp
index 6e00a11b2c5a0417da6aa67f72492dc1ab02427b..4b4b5e361045edc460ae403cd7aa626ab89ff4ef 100644
--- a/dm_lite/src/display_manager_lite.cpp
+++ b/dm_lite/src/display_manager_lite.cpp
@@ -37,6 +37,7 @@ public:
     FoldDisplayMode GetFoldDisplayMode();
     FoldDisplayMode GetFoldDisplayModeForExternal();
     void SetFoldDisplayMode(const FoldDisplayMode);
+    void SetFoldDisplayModeAsync(const FoldDisplayMode);
     bool IsFoldable();
 
     DMError RegisterDisplayListener(sptr<IDisplayListener> listener);
@@ -557,11 +558,21 @@ void DisplayManagerLite::SetFoldDisplayMode(const FoldDisplayMode mode)
     return pImpl_->SetFoldDisplayMode(mode);
 }
 
+void DisplayManagerLite::SetFoldDisplayModeAsync(const FoldDisplayMode mode)
+{
+    return pImpl_->SetFoldDisplayModeAsync(mode);
+}
+
 void DisplayManagerLite::Impl::SetFoldDisplayMode(const FoldDisplayMode mode)
 {
     return SingletonContainer::Get<DisplayManagerAdapterLite>().SetFoldDisplayMode(mode);
 }
 
+void DisplayManagerLite::Impl::SetFoldDisplayModeAsync(const FoldDisplayMode mode)
+{
+    return SingletonContainer::Get<DisplayManagerAdapterLite>().SetFoldDisplayModeAsync(mode);
+}
+
 void DisplayManagerLite::Impl::OnRemoteDied()
 {
     TLOGI(WmsLogTag::DMS, "dms is died");
diff --git a/dm_lite/src/display_manager_lite_proxy.cpp b/dm_lite/src/display_manager_lite_proxy.cpp
index 0d90e15cbd131183fa2a3b8f3c29dc85eff10186..5898d626f6c26eb6411439ecd9ae26b9d07a6576 100644
--- a/dm_lite/src/display_manager_lite_proxy.cpp
+++ b/dm_lite/src/display_manager_lite_proxy.cpp
@@ -173,6 +173,32 @@ void DisplayManagerLiteProxy::SetFoldDisplayMode(const FoldDisplayMode displayMo
 #endif
 }
 
+void DisplayManagerLiteProxy::SetFoldDisplayModeAsync(const FoldDisplayMode displayMode)
+{
+#ifdef SCENE_BOARD_ENABLED
+    sptr<IRemoteObject> remote = Remote();
+    if (remote == nullptr) {
+        TLOGW(WmsLogTag::DMS, "remote is null");
+        return;
+    }
+    MessageParcel data;
+    MessageParcel reply;
+    MessageOption option(MessageOption::TF_ASYNC);
+    if (!data.WriteInterfaceToken(GetDescriptor())) {
+        TLOGE(WmsLogTag::DMS, "WriteInterfaceToken Failed");
+        return;
+    }
+    if (!data.WriteUint32(static_cast<uint32_t>(displayMode))) {
+        TLOGE(WmsLogTag::DMS, "Write displayMode failed");
+        return;
+    }
+    if (remote->SendRequest(static_cast<uint32_t>(DisplayManagerMessage::TRANS_ID_SCENE_BOARD_SET_FOLD_DISPLAY_MODE),
+                            data, reply, option) != ERR_NONE) {
+        TLOGE(WmsLogTag::DMS, "Send TRANS_ID_SCENE_BOARD_SET_FOLD_DISPLAY_MODE request failed");
+    }
+#endif
+}
+
 bool DisplayManagerLiteProxy::IsFoldable()
 {
 #ifdef SCENE_BOARD_ENABLED
diff --git a/interfaces/innerkits/dm/display_manager.h b/interfaces/innerkits/dm/display_manager.h
index 02cfb6fca1b394d6b7f974e406f07d8c6a6c876c..23e1a728b15556e61c60c3225a95bffb6fbf229f 100644
--- a/interfaces/innerkits/dm/display_manager.h
+++ b/interfaces/innerkits/dm/display_manager.h
@@ -695,6 +695,13 @@ public:
      */
     void SetFoldDisplayMode(const FoldDisplayMode mode);
 
+    /**
+     * @brief Change the display mode of the foldable device asynchronously.
+     *
+     * @param mode target display mode to change.
+     */
+    void SetFoldDisplayModeAsync(const FoldDisplayMode mode);
+
     /**
      * @brief Change the display mode of the foldable device from js.
      *
diff --git a/interfaces/innerkits/dm_lite/display_manager_lite.h b/interfaces/innerkits/dm_lite/display_manager_lite.h
index 13a1f2be6841e32a8644225e7e32ab12e9d43275..552d48e03c092e9f8a7dd1892e1b67576379e323 100644
--- a/interfaces/innerkits/dm_lite/display_manager_lite.h
+++ b/interfaces/innerkits/dm_lite/display_manager_lite.h
@@ -183,6 +183,13 @@ public:
      */
     void SetFoldDisplayMode(const FoldDisplayMode mode);
 
+    /**
+     * @brief Change the display mode of the foldable device asynchronously.
+     *
+     * @param mode target display mode to change.
+     */
+    void SetFoldDisplayModeAsync(const FoldDisplayMode mode);
+
     /**
      * @brief Get the display object by id.
      *
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 b65b66d5af224a1846338f386f7c2258e1c3d331..820fdfabfed64e415868d6a6fd755b61a4ecb66d 100644
--- a/window_scene/screen_session_manager/include/screen_scene_config.h
+++ b/window_scene/screen_session_manager/include/screen_scene_config.h
@@ -51,6 +51,7 @@ public:
     static bool IsSupportCapture();
     static bool IsSupportOffScreenRendering();
     static uint32_t GetOffScreenPPIThreshold();
+    static bool IsSupportDuringCall();
 
 private:
     static std::map<int32_t, std::string> xmlNodeMap_;
diff --git a/window_scene/screen_session_manager/include/screen_session_dumper.h b/window_scene/screen_session_manager/include/screen_session_dumper.h
index eec18e88fe118b33291c70ae99cb33984b282066..47e1a49aa60ec09361fd717555ee3613c2e8d363 100644
--- a/window_scene/screen_session_manager/include/screen_session_dumper.h
+++ b/window_scene/screen_session_manager/include/screen_session_dumper.h
@@ -84,6 +84,7 @@ private:
         std::vector<float> &postures, std::vector<uint16_t> &halls);
     void TriggerSecondarySensor(const std::string &valueStr);
     void TriggerSecondaryFoldStatus(const std::string &valueStr);
+    void SetDuringCallState(std::string input);
     bool IsDeveloperModeCommand();
 private:
     int fd_;
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 2f7cfeba583e7cd5d39f5996761a50d045f3a12e..8cb96c1ae65e10efd1e13d17cb9cb6553e6aeaad 100644
--- a/window_scene/screen_session_manager/include/screen_session_manager.h
+++ b/window_scene/screen_session_manager/include/screen_session_manager.h
@@ -479,6 +479,9 @@ public:
     DMError SetVirtualScreenAutoRotation(ScreenId screenId, bool enable) override;
     bool SetScreenOffset(ScreenId screenId, float offsetX, float offsetY);
     bool SynchronizePowerStatus(ScreenPowerState state) override;
+    void RegisterSettingDuringCallStateObserver();
+    void UpdateDuringCallState();
+    void SetDuringCallState(bool value);
     std::shared_ptr<TaskScheduler> GetPowerTaskScheduler() const;
 
 protected:
@@ -839,6 +842,9 @@ private:
     std::mutex pcModeSwitchMutex_;
     std::atomic<DisplayGroupId> displayGroupNum_ { 1 };
 
+    // Fold Screen duringcall
+    bool duringCallState_ = false;
+
 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 d204132d6efaace1611f61f3f7c1808fdb4b79a0..1dd6297dffc6f3a801ebf27df1bd293afdf0cb92 100644
--- a/window_scene/screen_session_manager/include/screen_setting_helper.h
+++ b/window_scene/screen_session_manager/include/screen_setting_helper.h
@@ -60,6 +60,10 @@ public:
     static void UnregisterSettingWireCastObserver();
     static void RegisterSettingExtendScreenDpiObserver(SettingObserver::UpdateFunc func);
     static void UnRegisterSettingExtendScreenDpiObserver();
+    static void RegisterSettingDuringCallStateObserver(SettingObserver::UpdateFunc func);
+    static void UnregisterSettingDuringCallStateObserver();
+    static bool GetSettingDuringCallState(bool& enable, const std::string& key = SETTING_DURING_CALL_KEY);
+    static bool SetSettingDuringCallState(const std::string& key, const bool& value);
     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);
@@ -71,12 +75,14 @@ private:
     static const constexpr char* SETTING_ROTATION_SCREEN_ID_KEY {"screen_rotation_screen_id_value"};
     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 uint32_t BASE_TEN = 10;
     static sptr<SettingObserver> dpiObserver_;
     static sptr<SettingObserver> castObserver_;
     static sptr<SettingObserver> rotationObserver_;
     static sptr<SettingObserver> wireCastObserver_;
     static sptr<SettingObserver> extendScreenDpiObserver_;
+    static sptr<SettingObserver> duringCallStateObserver_;
 };
 } // namespace Rosen
 } // namespace OHOS
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 5ee9e8fc25309dcdcd2f205eddd68711c8b347dc..3e11583b76c3b2862909fbebf91dd9373a27d44a 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
@@ -231,6 +231,7 @@ public:
     virtual DMError SetPrimaryDisplaySystemDpi(float dpi) { return DMError::DM_OK; }
     // Fold Screen
     virtual void SetFoldDisplayMode(const FoldDisplayMode displayMode) {}
+    virtual void SetFoldDisplayModeAsync(const FoldDisplayMode displayMode) {}
     virtual DMError SetFoldDisplayModeFromJs(const FoldDisplayMode displayMode,
         std::string reason = "") { return DMError::DM_OK; }
 
diff --git a/window_scene/screen_session_manager/include/zidl/screen_session_manager_lite_interface.h b/window_scene/screen_session_manager/include/zidl/screen_session_manager_lite_interface.h
index 23aac3a70499112f4cdb621aae538979334adae3..65b83816b12edccf61cffa99937546f15a372d64 100644
--- a/window_scene/screen_session_manager/include/zidl/screen_session_manager_lite_interface.h
+++ b/window_scene/screen_session_manager/include/zidl/screen_session_manager_lite_interface.h
@@ -72,6 +72,7 @@ public:
 
     virtual FoldDisplayMode GetFoldDisplayMode() { return FoldDisplayMode::UNKNOWN; }
     virtual void SetFoldDisplayMode(const FoldDisplayMode) {}
+    virtual void SetFoldDisplayModeAsync(const FoldDisplayMode) {}
     virtual bool IsFoldable() { return false; };
     virtual FoldStatus GetFoldStatus() { return FoldStatus::UNKNOWN; };
     virtual sptr<DisplayInfo> GetDefaultDisplayInfo() { return nullptr; }
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 00e179d5d27a746c2d463e0ee5b6eced92a78dfe..a77fddbf5218ce2fc96946b512e9d47c0e6b5b55 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
@@ -149,6 +149,7 @@ public:
     virtual void DumpSpecialScreenInfo(ScreenId id, std::string& dumpInfo) override;
     //Fold Screen
     void SetFoldDisplayMode(const FoldDisplayMode displayMode) override;
+    void SetFoldDisplayModeAsync(const FoldDisplayMode displayMode) override;
     DMError SetFoldDisplayModeFromJs(const FoldDisplayMode displayMode, std::string reason = "") override;
 
     void SetDisplayScale(ScreenId screenId, float scaleX, float scaleY,
diff --git a/window_scene/screen_session_manager/src/fold_screen_controller/fold_screen_controller.cpp b/window_scene/screen_session_manager/src/fold_screen_controller/fold_screen_controller.cpp
index 21257f6f231497b7172950ec7a471c1bf13fafe8..82dd1b3195e6418f56c559f3d7414fc8083aeb55 100644
--- a/window_scene/screen_session_manager/src/fold_screen_controller/fold_screen_controller.cpp
+++ b/window_scene/screen_session_manager/src/fold_screen_controller/fold_screen_controller.cpp
@@ -123,8 +123,9 @@ void FoldScreenController::RecoverDisplayMode()
     }
     if (!FoldScreenStateInternel::IsSingleDisplayFoldDevice() &&
         !FoldScreenStateInternel::IsSingleDisplayPocketFoldDevice() &&
-        !FoldScreenStateInternel::IsSecondaryDisplayFoldDevice()) {
-        TLOGI(WmsLogTag::DMS, "not single display fold (pocket) device, skip");
+        !FoldScreenStateInternel::IsSecondaryDisplayFoldDevice() &&
+        !FoldScreenStateInternel::IsDualDisplayFoldDevice()) {
+        TLOGI(WmsLogTag::DMS, "current fold device do not need recover, skip");
         return;
     }
     TLOGI(WmsLogTag::DMS, "%{public}d -> %{public}d", currentDisplayMode, displayMode);
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 674cb4bc228e0d213d2d8064f0a94470e0a55044..6b2820fa314e9a74d0ba607ca2fc9a5260b0727a 100644
--- a/window_scene/screen_session_manager/src/screen_scene_config.cpp
+++ b/window_scene/screen_session_manager/src/screen_scene_config.cpp
@@ -64,7 +64,8 @@ enum XmlNodeElement {
     SCROLLABLE_PARAM,
     IS_SUPPORT_CAPTURE,
     IS_SUPPORT_OFFSCREEN_RENDERING,
-    OFF_SCREEN_PPI_THRESHOLD
+    OFF_SCREEN_PPI_THRESHOLD,
+    SUPPORT_DURING_CALL
 };
 }
 
@@ -108,7 +109,8 @@ std::map<int32_t, std::string> ScreenSceneConfig::xmlNodeMap_ = {
     {SCROLLABLE_PARAM, "scrollableParam"},
     {IS_SUPPORT_CAPTURE, "isSupportCapture"},
     {IS_SUPPORT_OFFSCREEN_RENDERING, "isSupportOffScreenRendering"},
-    {OFF_SCREEN_PPI_THRESHOLD, "offScreenPPIThreshold"}
+    {OFF_SCREEN_PPI_THRESHOLD, "offScreenPPIThreshold"},
+    {SUPPORT_DURING_CALL, "supportDuringCall"}
 };
 
 
@@ -192,7 +194,8 @@ void ScreenSceneConfig::ParseNodeConfig(const xmlNodePtr& currNode)
         (xmlNodeMap_[IS_RIGHT_POWER_BUTTON] == nodeName) ||
         (xmlNodeMap_[IS_SUPPORT_CAPTURE] == nodeName) ||
         (xmlNodeMap_[SUPPORT_ROTATE_WITH_SCREEN] == nodeName)||
-        (xmlNodeMap_[IS_SUPPORT_OFFSCREEN_RENDERING] == nodeName);
+        (xmlNodeMap_[IS_SUPPORT_OFFSCREEN_RENDERING] == nodeName) ||
+        (xmlNodeMap_[SUPPORT_DURING_CALL] == nodeName);
     bool numberConfigCheck = (xmlNodeMap_[DPI] == nodeName) ||
         (xmlNodeMap_[SUB_DPI] == nodeName) ||
         (xmlNodeMap_[CURVED_SCREEN_BOUNDARY] == nodeName) ||
@@ -618,5 +621,13 @@ bool ScreenSceneConfig::IsSupportOffScreenRendering()
     }
     return false;
 }
+
+bool ScreenSceneConfig::IsSupportDuringCall()
+{
+    if (enableConfig_.count("supportDuringCall") != 0) {
+        return static_cast<bool>(enableConfig_["supportDuringCall"]);
+    }
+    return false;
+}
 // 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 ed1ccbdea6bc3b722654041e8603f817ba351577..b175aa8e93c78b1ade3ba24897c525d1d5c31cf5 100644
--- a/window_scene/screen_session_manager/src/screen_session_dumper.cpp
+++ b/window_scene/screen_session_manager/src/screen_session_dumper.cpp
@@ -70,6 +70,7 @@ const std::string ARG_CHANGE_OUTER_CMD = "outer";
 const std::string ANGLE_STR = "angle";
 const std::string HALL_STR = "hall";
 const std::string ARG_SET_LANDSCAPE_LOCK = "-landscapelock";
+const std::string ARG_SET_DURINGCALL_STATE = "-duringcallstate";
 #ifdef FOLD_ABILITY_ENABLE
 constexpr int SUPER_FOLD_STATUS_MAX = 2;
 const char SECONDARY_DUMPER_VALUE_BOUNDARY[] = "mfg";
@@ -247,6 +248,8 @@ void ScreenSessionDumper::ExecuteInjectCmd2()
         SetSecondaryStatusChange(params_[0]);
     } else if (params_[0].find(ARG_SET_LANDSCAPE_LOCK) != std::string::npos) {
         SetLandscapeLock(params_[0]);
+    } else if (params_[0].find(ARG_SET_DURINGCALL_STATE) != std::string::npos) {
+        SetDuringCallState(params_[0]);
     }
 }
 
@@ -1059,6 +1062,31 @@ void ScreenSessionDumper::SetLandscapeLock(std::string input)
 #endif
 }
 
+void ScreenSessionDumper::SetDuringCallState(std::string input)
+{
+#ifdef FOLD_ABILITY_ENABLE
+    size_t commaPos = input.find_last_of(',');
+    if ((commaPos != std::string::npos) && (input.substr(0, commaPos) == ARG_SET_DURINGCALL_STATE)) {
+        std::string valueStr = input.substr(commaPos + 1);
+        if (valueStr.size() != 1) {
+            dumpInfo_.append("[error]: the value is too long");
+            return;
+        }
+        if (!std::isdigit(valueStr[0])) {
+            dumpInfo_.append("[error]: value is not a number");
+            return;
+        }
+        if ((valueStr[0] != '0') && (valueStr[0] != '1')) {
+            TLOGE(WmsLogTag::DMS, "param is invalid: %{public}s", valueStr.c_str());
+            return;
+        }
+        bool value = static_cast<bool>(std::stoi(valueStr));
+        ScreenSessionManager::GetInstance().SetDuringCallState(value);
+        TLOGI(WmsLogTag::DMS, "SetDuringCallState: %{public}d", value);
+    }
+#endif
+}
+
 #ifdef FOLD_ABILITY_ENABLE
 bool ScreenSessionDumper::IsAllCharDigit(const std::string &firstPostureStr)
 {
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 1f1fbb4081bbdf19d2b84f50a1304b058ae3fa21..19b34c3abc635c622ae2a05eef0472c937c641e1 100644
--- a/window_scene/screen_session_manager/src/screen_session_manager.cpp
+++ b/window_scene/screen_session_manager/src/screen_session_manager.cpp
@@ -3658,7 +3658,7 @@ void ScreenSessionManager::TryToRecoverFoldDisplayMode(ScreenPowerStatus status)
 
 bool ScreenSessionManager::SetScreenPower(ScreenPowerStatus status, PowerStateChangeReason reason)
 {
-    TLOGI(WmsLogTag::DMS, "[UL_POWER] enter status:%{public}u", status);
+    TLOGI(WmsLogTag::DMS, "[UL_POWER] enter status:%{public}u, reason:%{public}u", status, reason);
     auto screenIds = GetAllScreenIds();
     if (screenIds.empty()) {
         TLOGI(WmsLogTag::DMS, "[UL_POWER] screenIds empty");
@@ -3900,6 +3900,9 @@ void ScreenSessionManager::BootFinishedCallback(const char *key, const char *val
         that.UpdateDisplayState(that.GetAllScreenIds(), DisplayState::ON);
         that.RegisterSettingDpiObserver();
         that.RegisterSettingExtendScreenDpiObserver();
+        if (FoldScreenStateInternel::IsDualDisplayFoldDevice()) {
+            that.RegisterSettingDuringCallStateObserver();
+        }
         if (that.foldScreenPowerInit_ != nullptr) {
             that.foldScreenPowerInit_();
         }
@@ -10899,4 +10902,36 @@ std::shared_ptr<TaskScheduler> ScreenSessionManager::GetPowerTaskScheduler() con
 {
     return screenPowerTaskScheduler_;
 }
+
+void ScreenSessionManager::RegisterSettingDuringCallStateObserver()
+{
+    TLOGI(WmsLogTag::DMS, "Register Setting During Call State Observer");
+    SettingObserver::UpdateFunc updateFunc = [&](const std::string& key) { UpdateDuringCallState(); };
+    ScreenSettingHelper::RegisterSettingDuringCallStateObserver(updateFunc);
+}
+
+void ScreenSessionManager::UpdateDuringCallState()
+{
+    TLOGI(WmsLogTag::DMS, "update during call state, current state: %{public}d", duringCallState_);
+    bool ret = ScreenSettingHelper::GetSettingDuringCallState(duringCallState_);
+    if (!ret) {
+        TLOGE(WmsLogTag::DMS, "get setting during call state failed");
+        return;
+    }
+    TLOGI(WmsLogTag::DMS, "get setting during call state: %{public}d", duringCallState_);
+#ifdef FOLD_ABILITY_ENABLE
+    if (ScreenSceneConfig::IsSupportDuringCall() && !duringCallState_ && foldScreenController_ != nullptr &&
+        foldScreenController_->GetDisplayMode() == FoldDisplayMode::SUB) {
+        TLOGI(WmsLogTag::DMS, "duringcallstate exit, recover displaymode");
+        foldScreenController_->RecoverDisplayMode();
+    }
+#endif
+}
+
+void ScreenSessionManager::SetDuringCallState(bool value)
+{
+    TLOGI(WmsLogTag::DMS, "set during call state to %{public}d, start", value);
+    bool ret = ScreenSettingHelper::SetSettingDuringCallState("during_call_state", value);
+    TLOGI(WmsLogTag::DMS, "set during call state to %{public}d, ret:%{public}d", value, ret);
+}
 } // namespace OHOS::Rosen
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 c6a69c0741f84601ba46660c4848077920460c96..6d61727a829f1d6246e144bcd6bcd5ee38a652e3 100644
--- a/window_scene/screen_session_manager/src/screen_setting_helper.cpp
+++ b/window_scene/screen_session_manager/src/screen_setting_helper.cpp
@@ -32,6 +32,7 @@ sptr<SettingObserver> ScreenSettingHelper::castObserver_;
 sptr<SettingObserver> ScreenSettingHelper::rotationObserver_;
 sptr<SettingObserver> ScreenSettingHelper::wireCastObserver_;
 sptr<SettingObserver> ScreenSettingHelper::extendScreenDpiObserver_;
+sptr<SettingObserver> ScreenSettingHelper::duringCallStateObserver_;
 constexpr int32_t PARAM_NUM_TEN = 10;
 constexpr uint32_t EXPECT_SCREEN_MODE_SIZE = 2;
 constexpr uint32_t EXPECT_RELATIVE_POSITION_SIZE = 3;
@@ -617,5 +618,64 @@ bool ScreenSettingHelper::ConvertStrToInt32(const std::string& str, int32_t& num
     }
     return true;
 }
+
+void ScreenSettingHelper::RegisterSettingDuringCallStateObserver(SettingObserver::UpdateFunc func)
+{
+    if (duringCallStateObserver_ != nullptr) {
+        TLOGW(WmsLogTag::DMS, "during call state observer is registered");
+        return;
+    }
+    SettingProvider& settingProvider = SettingProvider::GetInstance(DISPLAY_MANAGER_SERVICE_SA_ID);
+    duringCallStateObserver_ = settingProvider.CreateObserver(SETTING_DURING_CALL_KEY, func);
+    if (duringCallStateObserver_ == nullptr) {
+        TLOGE(WmsLogTag::DMS, "create observer failed");
+        return;
+    }
+    ErrCode ret = settingProvider.RegisterObserver(duringCallStateObserver_);
+    if (ret != ERR_OK) {
+        TLOGW(WmsLogTag::DMS, "failed, ret=%{public}d", ret);
+        duringCallStateObserver_ = nullptr;
+    }
+}
+
+void ScreenSettingHelper::UnregisterSettingDuringCallStateObserver()
+{
+    if (duringCallStateObserver_ == nullptr) {
+        TLOGW(WmsLogTag::DMS, "duringCallStateObserver_ is nullptr");
+        return;
+    }
+    SettingProvider& settingProvider = SettingProvider::GetInstance(DISPLAY_MANAGER_SERVICE_SA_ID);
+    ErrCode ret = settingProvider.UnregisterObserver(duringCallStateObserver_);
+    if (ret != ERR_OK) {
+        TLOGW(WmsLogTag::DMS, "failed, ret=%{public}d", ret);
+    }
+    duringCallStateObserver_ = nullptr;
+}
+
+bool ScreenSettingHelper::GetSettingDuringCallState(bool& enable, const std::string& key)
+{
+    SettingProvider& settingProvider = SettingProvider::GetInstance(DISPLAY_MANAGER_SERVICE_SA_ID);
+    bool value = 0;
+    ErrCode ret = settingProvider.GetBoolValue(key, value);
+    if (ret != ERR_OK) {
+        TLOGE(WmsLogTag::DMS, "failed, ret=%{public}d", ret);
+        return false;
+    }
+    TLOGI(WmsLogTag::DMS, "get during call state is %{public}d", value);
+    enable = value;
+    return true;
+}
+
+bool ScreenSettingHelper::SetSettingDuringCallState(const std::string& key, const bool& value)
+{
+    SettingProvider& settingProvider = SettingProvider::GetInstance(DISPLAY_MANAGER_SERVICE_SA_ID);
+    ErrCode ret = settingProvider.PutBoolValue(key, value);
+    if (ret != ERR_OK) {
+        TLOGE(WmsLogTag::DMS, "failed, ret=%{public}d", ret);
+        return false;
+    }
+    TLOGI(WmsLogTag::DMS, "put during call state is %{public}d", value);
+    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 2a9dac74b7921a6bf75c5a4b6a7eda927cb221ed..328243e17ad5bc74bab1e14748f362edb254115c 100644
--- a/window_scene/screen_session_manager/src/setting_provider.cpp
+++ b/window_scene/screen_session_manager/src/setting_provider.cpp
@@ -35,12 +35,11 @@ namespace {
 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 SETTING_WALL_URI =
-    "datashare:///com.ohos.settingsdata/entry/settingsdata/USER_SETTINGSDATA_SECURE_100?Proxy=true";
 const std::string WALL_KEY = "wallpaperAodDisplay";
+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_";
-const std::string SETTING_WALL_MULTI_USER_TABLE = "USER_SETTINGSDATA_SECURE_";
+const std::string SETTING_SECURE_MULTI_USER_TABLE = "USER_SETTINGSDATA_SECURE_";
 const std::string SETTING_MULTI_USER_PROXY = "?Proxy=true";
 constexpr const char *SETTINGS_DATA_EXT_URI = "datashare:///com.ohos.settingsdata.DataAbility";
 constexpr int32_t PARAM_NUM_TEN = 10;
@@ -143,7 +142,8 @@ ErrCode SettingProvider::RegisterObserver(const sptr<SettingObserver>& observer)
         return ERR_NO_INIT;
     }
     std::string callingIdentity = IPCSkeleton::ResetCallingIdentity();
-    auto uri = AssembleUri(observer->GetKey());
+    Uri uri = (observer->GetKey() == DURING_CALL_KEY) ?
+        AssembleUriMultiUser(observer->GetKey()) : AssembleUri(observer->GetKey());
     auto helper = CreateDataShareHelper();
     if (helper == nullptr) {
         IPCSkeleton::SetCallingIdentity(callingIdentity);
@@ -204,7 +204,7 @@ 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) ? AssembleUriMultiUser(key) : AssembleUri(key);
+    Uri uri = (key == WALL_KEY || key == DURING_CALL_KEY) ? AssembleUriMultiUser(key) : AssembleUri(key);
     auto resultSet = helper->Query(uri, predicates, columns);
     ReleaseDataShareHelper(helper);
     if (resultSet == nullptr) {
@@ -290,7 +290,7 @@ ErrCode SettingProvider::PutStringValue(const std::string& key, const std::strin
     bucket.Put(SETTING_COLUMN_VALUE, valueObj);
     DataShare::DataSharePredicates predicates;
     predicates.EqualTo(SETTING_COLUMN_KEYWORD, key);
-    Uri uri(AssembleUri(key));
+    Uri uri = (key == DURING_CALL_KEY) ? AssembleUriMultiUser(key) : AssembleUri(key);
     if (helper->Update(uri, predicates, bucket) <= 0) {
         TLOGD(WmsLogTag::DMS, "no data exist, insert one row");
         helper->Insert(uri, bucket);
@@ -358,16 +358,13 @@ Uri SettingProvider::AssembleUriMultiUser(const std::string& key)
         std::string userIdString = std::to_string(userId);
         uriString = SETTING_MULTI_USER_URI + SETTING_MULTI_USER_TABLE + userIdString +
             SETTING_MULTI_USER_PROXY + "&key=" + key;
-        if (key == WALL_KEY) {
-            uriString = SETTING_MULTI_USER_URI + SETTING_WALL_MULTI_USER_TABLE +
+        if (key == WALL_KEY || key == DURING_CALL_KEY) {
+            uriString = SETTING_MULTI_USER_URI + SETTING_SECURE_MULTI_USER_TABLE +
                 userIdString + SETTING_MULTI_USER_PROXY + "&key=" + key;
         }
     } else {
         TLOGE(WmsLogTag::DMS, "invalid userId: %{public}d, use default uri", userId);
         uriString = SETTING_URI_PROXY + "&key=" + key;
-        if (key == WALL_KEY) {
-            uriString = SETTING_WALL_URI + "&key=" + key;
-        }
     }
     Uri uri(uriString);
     return uri;
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 dfe0b90cead47d6c4c25f82f87031c0f028f2658..ae97cd99bdab5149f71c34e4c56be8e059ed9bac 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
@@ -2486,6 +2486,30 @@ void ScreenSessionManagerProxy::SetFoldDisplayMode(const FoldDisplayMode display
     }
 }
 
+void ScreenSessionManagerProxy::SetFoldDisplayModeAsync(const FoldDisplayMode displayMode)
+{
+    sptr<IRemoteObject> remote = Remote();
+    if (remote == nullptr) {
+        TLOGW(WmsLogTag::DMS, "remote is null");
+        return;
+    }
+    MessageParcel data;
+    MessageParcel reply;
+    MessageOption option(MessageOption::TF_ASYNC);
+    if (!data.WriteInterfaceToken(GetDescriptor())) {
+        TLOGE(WmsLogTag::DMS, "WriteInterfaceToken Failed");
+        return;
+    }
+    if (!data.WriteUint32(static_cast<uint32_t>(displayMode))) {
+        TLOGE(WmsLogTag::DMS, "Write displayMode failed");
+        return;
+    }
+    if (remote->SendRequest(static_cast<uint32_t>(DisplayManagerMessage::TRANS_ID_SCENE_BOARD_SET_FOLD_DISPLAY_MODE),
+                            data, reply, option) != ERR_NONE) {
+        TLOGE(WmsLogTag::DMS, "Send TRANS_ID_SCENE_BOARD_SET_FOLD_DISPLAY_MODE request failed");
+    }
+}
+
 //SetFoldDisplayModeFromJs add DMError to return DMErrorCode for js
 DMError ScreenSessionManagerProxy::SetFoldDisplayModeFromJs(const FoldDisplayMode displayMode, std::string reason)
 {
diff --git a/window_scene/test/dms_unittest/BUILD.gn b/window_scene/test/dms_unittest/BUILD.gn
index 1bd72b25f185564e5e0725c03467b4fe31680882..17347a04a642d1bef0abd50ae385cb3d3bc368fc 100644
--- a/window_scene/test/dms_unittest/BUILD.gn
+++ b/window_scene/test/dms_unittest/BUILD.gn
@@ -588,7 +588,10 @@ ohos_unittest("ws_screen_session_manager_test2") {
   deps = [ ":ws_unittest_common" ]
 
   external_deps = test_external_deps
-  external_deps += [ "init:libbegetutil" ]
+  external_deps += [
+    "ability_runtime:dataobs_manager",
+    "init:libbegetutil"
+  ]
 }
 
 ohos_unittest("ws_screen_rotation_property_test") {
diff --git a/window_scene/test/dms_unittest/screen_scene_config_test.cpp b/window_scene/test/dms_unittest/screen_scene_config_test.cpp
index cec185cbef1b0206654377d45c715780e13f8d35..63824d6bd3fc03c8bfe28085aefe081d6cd1252d 100644
--- a/window_scene/test/dms_unittest/screen_scene_config_test.cpp
+++ b/window_scene/test/dms_unittest/screen_scene_config_test.cpp
@@ -1247,6 +1247,30 @@ HWTEST_F(ScreenSceneConfigTest, IsSupportOffScreenRendering02, TestSize.Level1)
     bool res = ScreenSceneConfig::IsSupportOffScreenRendering();
     EXPECT_EQ(false, res);
 }
+
+/**
+ * @tc.name: IsSupportDuringCall01
+ * @tc.desc: IsSupportDuringCall01
+ * @tc.type: FUNC
+ */
+HWTEST_F(ScreenSceneConfigTest, IsSupportDuringCall01, TestSize.Level1)
+{
+    ScreenSceneConfig::enableConfig_["supportDuringCall"] = true;
+    bool res = ScreenSceneConfig::IsSupportDuringCall();
+    EXPECT_TRUE(res);
+}
+
+/**
+ * @tc.name: IsSupportDuringCall02
+ * @tc.desc: IsSupportDuringCall02
+ * @tc.type: FUNC
+ */
+HWTEST_F(ScreenSceneConfigTest, IsSupportDuringCall02, TestSize.Level1)
+{
+    ScreenSceneConfig::enableConfig_.erase("supportDuringCall");
+    bool res = ScreenSceneConfig::IsSupportDuringCall();
+    EXPECT_FALSE(res);
+}
 }
 } // namespace Rosen
 } // namespace OHOS
diff --git a/window_scene/test/dms_unittest/screen_session_dumper_test.cpp b/window_scene/test/dms_unittest/screen_session_dumper_test.cpp
index c808f9b5f13fb1763ce08c35b5db6f3fa9c47f0f..612f72d085e65fa1b0a2e09c12854eab0fa5f5bd 100644
--- a/window_scene/test/dms_unittest/screen_session_dumper_test.cpp
+++ b/window_scene/test/dms_unittest/screen_session_dumper_test.cpp
@@ -1342,6 +1342,24 @@ HWTEST_F(ScreenSessionDumperTest, SetEnterOrExitTentMode, TestSize.Level1)
     ASSERT_EQ(tentMode, false);
 }
 
+/**
+ * @tc.name: SetDuringCallState
+ * @tc.desc: test function : SetDuringCallState
+ * @tc.type: FUNC
+ */
+HWTEST_F(ScreenSessionDumperTest, SetDuringCallState, TestSize.Level1)
+{
+    int fd = 1;
+    std::vector<std::u16string> args = {u"-h"};
+    sptr<ScreenSessionDumper> dumper = new ScreenSessionDumper(fd, args);
+    
+    dumper->SetDuringCallState("-duringcallstate, 1");
+    ASSERT_TRUE(ScreenSessionManager::GetInstance().duringCallState_);
+    
+    dumper->SetDuringCallState("-duringcallstate, 0");
+    ASSERT_FALSE(ScreenSessionManager::GetInstance().duringCallState_);
+}
+
 #endif // FOLD_ABILITY_ENABLE
 }
 }
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 1184758b40913dad47821c4f32bfce1c4561c25f..059b43938c98682deb18730a3713524efcfab1af 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
@@ -1487,6 +1487,26 @@ HWTEST_F(ScreenSessionManagerProxyTest, SetFoldDisplayMode, TestSize.Level1)
     screenSessionManagerProxy->SetFoldDisplayMode(displayMode);
     if (screenSessionManagerProxy->IsFoldable() && !FoldScreenStateInternel::IsSuperFoldDisplayDevice()) {
         EXPECT_NE(ScreenSessionManager::GetInstance().foldScreenController_, nullptr);
+    } else if (FoldScreenStateInternel::IsDualDisplayFoldDevice()) {
+        EXPECT_NE(ScreenSessionManager::GetInstance().foldScreenController_, nullptr);
+    } else {
+        EXPECT_EQ(ScreenSessionManager::GetInstance().foldScreenController_, nullptr);
+    }
+}
+
+/**
+ * @tc.name: SetFoldDisplayModeAsync
+ * @tc.desc: SetFoldDisplayModeAsync
+ * @tc.type: FUNC
+ */
+HWTEST_F(ScreenSessionManagerProxyTest, SetFoldDisplayModeAsync, TestSize.Level1)
+{
+    FoldDisplayMode displayMode = FoldDisplayMode::UNKNOWN;
+    screenSessionManagerProxy->SetFoldDisplayModeAsync(displayMode);
+    if (screenSessionManagerProxy->IsFoldable() && !FoldScreenStateInternel::IsSuperFoldDisplayDevice()) {
+        EXPECT_NE(ScreenSessionManager::GetInstance().foldScreenController_, nullptr);
+    } else if (FoldScreenStateInternel::IsDualDisplayFoldDevice()) {
+        EXPECT_NE(ScreenSessionManager::GetInstance().foldScreenController_, nullptr);
     } else {
         EXPECT_EQ(ScreenSessionManager::GetInstance().foldScreenController_, nullptr);
     }
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 fff931a291774943b00a5f6404a6e2b772f81087..3c69702749bac560c225ae46ec94441a4450dbc5 100644
--- a/window_scene/test/dms_unittest/screen_session_manager_test2.cpp
+++ b/window_scene/test/dms_unittest/screen_session_manager_test2.cpp
@@ -20,6 +20,7 @@
 #include "display_manager_agent_default.h"
 #include "screen_session_manager/include/screen_session_manager.h"
 #include "screen_scene_config.h"
+#include "screen_setting_helper.h"
 #include "fold_screen_state_internel.h"
 #include "mock/mock_accesstoken_kit.h"
 #include "window_manager_hilog.h"
@@ -1196,6 +1197,33 @@ HWTEST_F(ScreenSessionManagerTest, UpdateAvailableArea02, TestSize.Level1)
     g_errLog.clear();
     ssm_->SetPcStatus(temp);
 }
+/*
+ * @tc.name: RegisterSettingDuringCallStateObserver
+ * @tc.desc: RegisterSettingDuringCallStateObserver
+ * @tc.type: FUNC
+ */
+HWTEST_F(ScreenSessionManagerTest, RegisterSettingDuringCallStateObserver, Function | SmallTest | Level3)
+{
+    ASSERT_NE(ssm_, nullptr);
+    if (FoldScreenStateInternel::IsDualDisplayFoldDevice() && ScreenSceneConfig::IsSupportDuringCall()) {
+        ssm_->RegisterSettingDuringCallStateObserver();
+        ASSERT_NE(ScreenSettingHelper::duringCallStateObserver_, nullptr);
+    }
+}
+
+/**
+ * @tc.name: UpdateDuringCallState
+ * @tc.desc: UpdateDuringCallState
+ * @tc.type: FUNC
+ */
+HWTEST_F(ScreenSessionManagerTest, UpdateDuringCallState, Function | SmallTest | Level3)
+{
+    ASSERT_NE(ssm_, nullptr);
+    if (FoldScreenStateInternel::IsDualDisplayFoldDevice() && ScreenSceneConfig::IsSupportDuringCall()) {
+        ssm_->UpdateDuringCallState();
+        ASSERT_EQ(ssm_->duringCallState_, 0);
+    }
+}
 }
 }
 }
\ 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 32a4e1921a0e873ff6786421aa002c377a5f1e72..1da5d0cfce53a1e863d142490757e37ef059982e 100644
--- a/window_scene/test/dms_unittest/screen_setting_helper_test.cpp
+++ b/window_scene/test/dms_unittest/screen_setting_helper_test.cpp
@@ -883,6 +883,48 @@ namespace {
         EXPECT_TRUE(screenSettingHelper.ConvertStrToInt32(str, num1));
         EXPECT_EQ(123, num1);
     }
+
+    /**
+     * @tc.name: RegisterSettingDuringCallStateObserver
+     * @tc.desc: RegisterSettingDuringCallStateObserver
+     * @tc.type: FUNC
+     */
+    HWTEST_F(ScreenSettingHelperTest, RegisterSettingDuringCallStateObserver, TestSize.Level1)
+    {
+        bool flag = false;
+        auto func = [&flag] (const std::string&) {
+            TLOGI(WmsLogTag::DMS, "UT test");
+            flag = true;
+        };
+        ScreenSettingHelper::RegisterSettingDuringCallStateObserver(func);
+        ASSERT_NE(ScreenSettingHelper::duringCallStateObserver_, nullptr);
+    }
+
+    /**
+     * @tc.name: UnregisterSettingDuringCallStateObserver
+     * @tc.desc: UnregisterSettingDuringCallStateObserver
+     * @tc.type: FUNC
+     */
+    HWTEST_F(ScreenSettingHelperTest, UnregisterSettingDuringCallStateObserver, TestSize.Level1)
+    {
+        ScreenSettingHelper::UnregisterSettingDuringCallStateObserver();
+        ASSERT_EQ(ScreenSettingHelper::duringCallStateObserver_, nullptr);
+    }
+
+    /**
+     * @tc.name: GetSettingDuringCallStateTest
+     * @tc.desc: Test GetSettingDuringCallState func
+     * @tc.type: FUNC
+     */
+    HWTEST_F(ScreenSettingHelperTest, GetSettingDuringCallStateTest, Function | SmallTest | Level3)
+    {
+        ScreenSettingHelper screenSettingHelper = ScreenSettingHelper();
+        bool value = true;
+
+        screenSettingHelper.SetSettingDuringCallState("during_call_state", false);
+        screenSettingHelper.GetSettingDuringCallState(value);
+        ASSERT_FALSE(value);
+    }
 }
 } // namespace Rosen
 } // namespace OHOS
\ No newline at end of file