From 83e4e6738df820cfe0b47cb9eff93b837a45c54b Mon Sep 17 00:00:00 2001 From: j30052480 Date: Fri, 6 Jun 2025 17:01:46 +0800 Subject: [PATCH 1/2] feat: support during call Signed-off-by: j30052480 --- dm/include/display_manager_adapter.h | 1 + dm/src/display_manager.cpp | 11 ++++ dm/src/display_manager_adapter.cpp | 9 +++ .../include/display_manager_adapter_lite.h | 1 + dm_lite/include/display_manager_lite_proxy.h | 1 + dm_lite/src/display_manager_adapter_lite.cpp | 7 +++ dm_lite/src/display_manager_lite.cpp | 11 ++++ dm_lite/src/display_manager_lite_proxy.cpp | 26 ++++++++ interfaces/innerkits/dm/display_manager.h | 7 +++ .../innerkits/dm_lite/display_manager_lite.h | 7 +++ .../include/screen_scene_config.h | 1 + .../include/screen_session_dumper.h | 1 + .../include/screen_session_manager.h | 6 ++ .../include/screen_setting_helper.h | 6 ++ .../zidl/screen_session_manager_interface.h | 1 + .../screen_session_manager_lite_interface.h | 1 + .../zidl/screen_session_manager_proxy.h | 1 + .../fold_screen_controller.cpp | 5 +- .../src/screen_scene_config.cpp | 17 +++++- .../src/screen_session_dumper.cpp | 28 +++++++++ .../src/screen_session_manager.cpp | 37 +++++++++++- .../src/screen_setting_helper.cpp | 60 +++++++++++++++++++ .../src/setting_provider.cpp | 19 +++--- .../src/zidl/screen_session_manager_proxy.cpp | 24 ++++++++ window_scene/test/dms_unittest/BUILD.gn | 5 +- .../dms_unittest/screen_scene_config_test.cpp | 24 ++++++++ .../screen_session_dumper_test.cpp | 18 ++++++ .../screen_session_manager_proxy_test.cpp | 20 +++++++ .../screen_session_manager_test2.cpp | 29 +++++++++ .../screen_setting_helper_test.cpp | 42 +++++++++++++ 30 files changed, 408 insertions(+), 18 deletions(-) diff --git a/dm/include/display_manager_adapter.h b/dm/include/display_manager_adapter.h index 10e6a7c59d..f8bdb3b1ca 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 a7413eb70b..1b59c5a34e 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().SetFoldDisplayMode(mode); } +void DisplayManager::Impl::SetFoldDisplayModeAsync(const FoldDisplayMode mode) +{ + SingletonContainer::Get().SetFoldDisplayModeAsync(mode); +} + DMError DisplayManager::Impl::SetFoldDisplayModeFromJs(const FoldDisplayMode mode, std::string reason) { return SingletonContainer::Get().SetFoldDisplayModeFromJs(mode, reason); diff --git a/dm/src/display_manager_adapter.cpp b/dm/src/display_manager_adapter.cpp index 9790ab0fff..1b904eb0f0 100644 --- a/dm/src/display_manager_adapter.cpp +++ b/dm/src/display_manager_adapter.cpp @@ -1180,6 +1180,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 73d8eed5af..ef9090a637 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 GetDisplayInfo(DisplayId displayId); virtual sptr 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 dce102a3b3..9128645e49 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 GetDefaultDisplayInfo(); diff --git a/dm_lite/src/display_manager_adapter_lite.cpp b/dm_lite/src/display_manager_adapter_lite.cpp index f6789bad36..79841e9235 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 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 6e00a11b2c..4b4b5e3610 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 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().SetFoldDisplayMode(mode); } +void DisplayManagerLite::Impl::SetFoldDisplayModeAsync(const FoldDisplayMode mode) +{ + return SingletonContainer::Get().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 0d90e15cbd..5898d626f6 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 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(displayMode))) { + TLOGE(WmsLogTag::DMS, "Write displayMode failed"); + return; + } + if (remote->SendRequest(static_cast(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 757bf60f48..0e6cd4362c 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 13a1f2be68..552d48e03c 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 b65b66d5af..820fdfabfe 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 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 eec18e88fe..47e1a49aa6 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 &postures, std::vector &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 b1b3e6a180..c49daf686d 100644 --- a/window_scene/screen_session_manager/include/screen_session_manager.h +++ b/window_scene/screen_session_manager/include/screen_session_manager.h @@ -476,6 +476,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); protected: ScreenSessionManager(); @@ -824,6 +827,9 @@ private: std::mutex pcModeSwitchMutex_; std::atomic 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 d204132d6e..1dd6297dff 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 dpiObserver_; static sptr castObserver_; static sptr rotationObserver_; static sptr wireCastObserver_; static sptr extendScreenDpiObserver_; + static sptr 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 0aca00b696..86c2ce6e14 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 23aac3a704..65b83816b1 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 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 96fcc86c54..c727cec743 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 21257f6f23..82dd1b3195 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 5937c82fc6..efae4d85fe 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 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) || @@ -611,4 +614,12 @@ bool ScreenSceneConfig::IsSupportOffScreenRendering() } return false; } + +bool ScreenSceneConfig::IsSupportDuringCall() +{ + if (enableConfig_.count("supportDuringCall") != 0) { + return static_cast(enableConfig_["supportDuringCall"]); + } + return false; +} } // 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 ed1ccbdea6..b175aa8e93 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(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 054158447d..c0abd0f278 100644 --- a/window_scene/screen_session_manager/src/screen_session_manager.cpp +++ b/window_scene/screen_session_manager/src/screen_session_manager.cpp @@ -3570,7 +3570,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"); @@ -3812,6 +3812,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_(); } @@ -10785,4 +10788,36 @@ bool ScreenSessionManager::SynchronizePowerStatus(ScreenPowerState state) #endif return true; } + +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 9b3d7c6bdf..b76573951b 100644 --- a/window_scene/screen_session_manager/src/screen_setting_helper.cpp +++ b/window_scene/screen_session_manager/src/screen_setting_helper.cpp @@ -30,6 +30,7 @@ sptr ScreenSettingHelper::castObserver_; sptr ScreenSettingHelper::rotationObserver_; sptr ScreenSettingHelper::wireCastObserver_; sptr ScreenSettingHelper::extendScreenDpiObserver_; +sptr 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; @@ -609,5 +610,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 2a9dac74b7..328243e17a 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& 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 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 8019403cad..8472d6061c 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 @@ -2489,6 +2489,30 @@ void ScreenSessionManagerProxy::SetFoldDisplayMode(const FoldDisplayMode display } } +void ScreenSessionManagerProxy::SetFoldDisplayModeAsync(const FoldDisplayMode displayMode) +{ + sptr 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(displayMode))) { + TLOGE(WmsLogTag::DMS, "Write displayMode failed"); + return; + } + if (remote->SendRequest(static_cast(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 1bd72b25f1..17347a04a6 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 cec185cbef..63824d6bd3 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 c808f9b5f1..612f72d085 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 args = {u"-h"}; + sptr 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 1184758b40..059b43938c 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 de0d8eb317..5055fa4462 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" @@ -1128,6 +1129,34 @@ HWTEST_F(ScreenSessionManagerTest, NotifyScreenMaskAppear02, TestSize.Level1) g_errLog.find("screen mask appeared") != std::string::npos; EXPECT_TRUE(hasLog); } + +/** + * @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 32a4e1921a..1da5d0cfce 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 -- Gitee From dd567e4f3d5a3aa21aeeee676d3486726ee45f0e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E4=B9=BE=E9=98=B3=E7=86=A0?= Date: Mon, 28 Jul 2025 09:05:40 +0000 Subject: [PATCH 2/2] =?UTF-8?q?update=20window=5Fscene/test/dms=5Funittest?= =?UTF-8?q?/screen=5Fsession=5Fmanager=5Ftest2.cpp.=20Signed-off-by:=20?= =?UTF-8?q?=E4=B9=BE=E9=98=B3=E7=86=A0=20?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 乾阳熠 --- .../screen_session_manager_test2.cpp | 105 +++++++++++++++--- 1 file changed, 89 insertions(+), 16 deletions(-) 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 102b8e013d..3c69702749 100644 --- a/window_scene/test/dms_unittest/screen_session_manager_test2.cpp +++ b/window_scene/test/dms_unittest/screen_session_manager_test2.cpp @@ -1098,31 +1098,104 @@ HWTEST_F(ScreenSessionManagerTest, NotifyScreenMaskAppear02, TestSize.Level1) } /** - * @tc.name: RegisterSettingDuringCallStateObserver - * @tc.desc: RegisterSettingDuringCallStateObserver + * @tc.name: TryToCancelScreenOff01 + * @tc.desc: TryToCancelScreenOff test * @tc.type: FUNC */ -HWTEST_F(ScreenSessionManagerTest, RegisterSettingDuringCallStateObserver, Function | SmallTest | Level3) +HWTEST_F(ScreenSessionManagerTest, TryToCancelScreenOff01, TestSize.Level1) { - ASSERT_NE(ssm_, nullptr); - if (FoldScreenStateInternel::IsDualDisplayFoldDevice() && ScreenSceneConfig::IsSupportDuringCall()) { - ssm_->RegisterSettingDuringCallStateObserver(); - ASSERT_NE(ScreenSettingHelper::duringCallStateObserver_, nullptr); - } + g_errLog.clear(); + MockAccesstokenKit::MockIsSACalling(false); + MockAccesstokenKit::MockIsSystemApp(false); + ssm_->TryToCancelScreenOff(); + EXPECT_TRUE(g_errLog.find("permission denied!") != std::string::npos); } /** - * @tc.name: UpdateDuringCallState - * @tc.desc: UpdateDuringCallState + * @tc.name: WaitUpdateAvailableAreaForPc01 + * @tc.desc: WaitUpdateAvailableAreaForPc test * @tc.type: FUNC */ -HWTEST_F(ScreenSessionManagerTest, UpdateDuringCallState, Function | SmallTest | Level3) +HWTEST_F(ScreenSessionManagerTest, WaitUpdateAvailableAreaForPc01, TestSize.Level1) { - ASSERT_NE(ssm_, nullptr); - if (FoldScreenStateInternel::IsDualDisplayFoldDevice() && ScreenSceneConfig::IsSupportDuringCall()) { - ssm_->UpdateDuringCallState(); - ASSERT_EQ(ssm_->duringCallState_, 0); - } + g_errLog.clear(); + LOG_SetCallback(MyLogCallback); + bool temp = ScreenSessionManager::GetInstance().GetPcStatus(); + ScreenSessionManager::GetInstance().SetPcStatus(true); + ScreenSessionManager::GetInstance().WaitUpdateAvailableAreaForPc(); + EXPECT_TRUE(g_errLog.find("need wait update available area") == std::string::npos); + g_errLog.clear(); + ScreenSessionManager::GetInstance().SetPcStatus(temp); +} + +/** + * @tc.name: WaitUpdateAvailableAreaForPc02 + * @tc.desc: WaitUpdateAvailableAreaForPc test + * @tc.type: FUNC + */ +HWTEST_F(ScreenSessionManagerTest, WaitUpdateAvailableAreaForPc02, TestSize.Level1) +{ + g_errLog.clear(); + LOG_SetCallback(MyLogCallback); + bool temp = ScreenSessionManager::GetInstance().GetPcStatus(); + ScreenSessionManager::GetInstance().SetPcStatus(true); + ScreenSessionManager::GetInstance().needWaitAvailableArea_ = true; + ScreenSessionManager::GetInstance().WaitUpdateAvailableAreaForPc(); + EXPECT_TRUE(g_errLog.find("wait update available area timeout") != std::string::npos); + g_errLog.clear(); + ScreenSessionManager::GetInstance().SetPcStatus(temp); +} + +/** + * @tc.name: UpdateAvailableAreaWhenDisplayAdd01 + * @tc.desc: UpdateAvailableArea WhenDisplayAdd notify all + * @tc.type: FUNC + */ +HWTEST_F(ScreenSessionManagerTest, UpdateAvailableArea02, TestSize.Level1) +{ + g_errLog.clear(); + LOG_SetCallback(MyLogCallback); + bool temp = ssm_->GetPcStatus(); + ssm_->SetPcStatus(true); + ssm_->needWaitAvailableArea_ = true; + + ScreenId screenId = 1050; + DMRect area{0, 0, 600, 900}; + DMRect area2{0, 0, 600, 800}; + sptr screenSession = new (std::nothrow) ScreenSession(screenId, ScreenProperty(), 0); + ssm_->screenSessionMap_[screenId] = screenSession; + auto screenSession1 = ssm_->GetScreenSession(screenId); + EXPECT_EQ(screenSession1, screenSession); + EXPECT_TRUE(screenSession->UpdateAvailableArea(area)); + ssm_->UpdateAvailableArea(screenId, area2); + EXPECT_FALSE(ssm_->needWaitAvailableArea_); + g_errLog.clear(); + ssm_->SetPcStatus(temp); +} + +/** + * @tc.name: UpdateAvailableAreaWhenDisplayAdd02 + * @tc.desc: UpdateAvailableArea WhenDisplayAdd not notify all + * @tc.type: FUNC + */ +HWTEST_F(ScreenSessionManagerTest, UpdateAvailableArea02, TestSize.Level1) +{ + g_errLog.clear(); + LOG_SetCallback(MyLogCallback); + bool temp = ssm_->GetPcStatus(); + ssm_->SetPcStatus(true); + ssm_->needWaitAvailableArea_ = false; + + ScreenId screenId = 1050; + DMRect area{0, 0, 600, 800}; + sptr screenSession = new (std::nothrow) ScreenSession(screenId, ScreenProperty(), 0); + ssm_->screenSessionMap_[screenId] = screenSession; + ssm_->UpdateAvailableArea(screenId, area); + auto screenSession1 = ssm_->GetScreenSession(screenId); + EXPECT_EQ(screenSession1->GetAvailabelArea(), area); + EXPECT_FALSE(ssm_->needWaitAvailableArea_); + g_errLog.clear(); + ssm_->SetPcStatus(temp); } /* * @tc.name: RegisterSettingDuringCallStateObserver -- Gitee