From bc498d49272d11e851dee0f4c9d848b8ef285b35 Mon Sep 17 00:00:00 2001 From: mengxiao Date: Thu, 28 Aug 2025 11:28:31 +0800 Subject: [PATCH] fix angle_min_value and fold threshold to config Signed-off-by: mengxiao --- .../fold_screen_controller_config.h | 40 +++++++++++++++++++ .../include/screen_scene_config.h | 3 +- .../fold_screen_sensor_manager.cpp | 2 +- .../secondary_fold_sensor_manager.cpp | 12 +++--- ...dual_display_sensor_fold_state_manager.cpp | 2 +- ...dary_display_sensor_fold_state_manager.cpp | 33 +++++++-------- ...ngle_display_sensor_fold_state_manager.cpp | 27 +++++-------- ...splay_sensor_pocket_fold_state_manager.cpp | 27 +++++-------- .../super_fold_sensor_manager.cpp | 2 +- .../src/screen_scene_config.cpp | 39 ++++++++++++++++-- .../dms_unittest/screen_scene_config_test.cpp | 28 +++++++++++++ ...display_sensor_fold_state_manager_test.cpp | 10 +++-- ..._sensor_pocket_fold_state_manager_test.cpp | 9 +++-- 13 files changed, 163 insertions(+), 71 deletions(-) create mode 100644 window_scene/screen_session_manager/include/fold_screen_controller/fold_screen_controller_config.h diff --git a/window_scene/screen_session_manager/include/fold_screen_controller/fold_screen_controller_config.h b/window_scene/screen_session_manager/include/fold_screen_controller/fold_screen_controller_config.h new file mode 100644 index 0000000000..a39ba34ad8 --- /dev/null +++ b/window_scene/screen_session_manager/include/fold_screen_controller/fold_screen_controller_config.h @@ -0,0 +1,40 @@ +/* + * Copyright (c) 2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef OHOS_ROSEN_FOLD_SCREEN_CONTROLLER_CONFIG_H +#define OHOS_ROSEN_FOLD_SCREEN_CONTROLLER_CONFIG_H + +#include "screen_scene_config.h" + +namespace OHOS::Rosen { +namespace { +const float ANGLE_MIN_VAL = static_cast(system::GetIntParameter("const.dms.min_fold_angle", 0)); + +const float HALF_FOLDED_MAX_THRESHOLD = + static_cast(ScreenSceneConfig::GetNumberConfigValue("halfFoldMaxThreshold", 140)); +const float CLOSE_HALF_FOLDED_MIN_THRESHOLD = + static_cast(ScreenSceneConfig::GetNumberConfigValue("closeHalfFoldedMinThreshold", 70)); +const float OPEN_HALF_FOLDED_MIN_THRESHOLD = + static_cast(ScreenSceneConfig::GetNumberConfigValue("openHalfFoldedMinThreshold", 25)); +const float HALF_FOLDED_BUFFER = + static_cast(ScreenSceneConfig::GetNumberConfigValue("halfFoldedBuffer", 10)); +const float LARGER_BOUNDARY_FOR_THRESHOLD = + static_cast(ScreenSceneConfig::GetNumberConfigValue("largerBoundaryForThreshold", 90)); + +const size_t POSTURE_SIZE = ScreenSceneConfig::GetNumberConfigValue("postureSize", 3); +const size_t HALL_SIZE = ScreenSceneConfig::GetNumberConfigValue("hallSize", 2); +} +} +#endif // OHOS_ROSEN_FOLD_SCREEN_CONTROLLER_CONFIG_H \ No newline at end of file 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 820fdfabfe..7904e9f53c 100644 --- a/window_scene/screen_session_manager/include/screen_scene_config.h +++ b/window_scene/screen_session_manager/include/screen_scene_config.h @@ -16,7 +16,7 @@ #ifndef OHOS_ROSEN_SCREEN_SCENE_CONFIG_H #define OHOS_ROSEN_SCREEN_SCENE_CONFIG_H - +#include #include #include "cutout_info.h" @@ -52,6 +52,7 @@ public: static bool IsSupportOffScreenRendering(); static uint32_t GetOffScreenPPIThreshold(); static bool IsSupportDuringCall(); + static uint32_t GetNumberConfigValue(std::string name, uint32_t default_value); private: static std::map xmlNodeMap_; diff --git a/window_scene/screen_session_manager/src/fold_screen_controller/fold_screen_sensor_manager.cpp b/window_scene/screen_session_manager/src/fold_screen_controller/fold_screen_sensor_manager.cpp index 7031a5a62c..69d279de12 100644 --- a/window_scene/screen_session_manager/src/fold_screen_controller/fold_screen_sensor_manager.cpp +++ b/window_scene/screen_session_manager/src/fold_screen_controller/fold_screen_sensor_manager.cpp @@ -19,6 +19,7 @@ #include #include "fold_screen_controller/fold_screen_sensor_manager.h" +#include "fold_screen_controller/fold_screen_controller_config.h" #include "fold_screen_state_internel.h" #include "window_manager_hilog.h" #include "screen_session_manager.h" @@ -40,7 +41,6 @@ static void SensorHallDataCallback(SensorEvent *event) namespace OHOS { namespace Rosen { namespace { -constexpr float ANGLE_MIN_VAL = 0.0F; constexpr float ANGLE_MAX_VAL = 180.0F; constexpr int32_t SENSOR_SUCCESS = 0; constexpr int32_t POSTURE_INTERVAL = 10000000; diff --git a/window_scene/screen_session_manager/src/fold_screen_controller/secondary_fold_sensor_manager.cpp b/window_scene/screen_session_manager/src/fold_screen_controller/secondary_fold_sensor_manager.cpp index 333b63d770..80b588fd35 100644 --- a/window_scene/screen_session_manager/src/fold_screen_controller/secondary_fold_sensor_manager.cpp +++ b/window_scene/screen_session_manager/src/fold_screen_controller/secondary_fold_sensor_manager.cpp @@ -19,6 +19,7 @@ #include #include "fold_screen_controller/secondary_fold_sensor_manager.h" +#include "fold_screen_controller/fold_screen_controller_config.h" #include "fold_screen_state_internel.h" #include "window_manager_hilog.h" #include "screen_session_manager.h" @@ -30,7 +31,6 @@ namespace OHOS { namespace Rosen { namespace { -constexpr float ANGLE_MIN_VAL = 0.0F; constexpr float ANGLE_MAX_VAL = 180.0F; constexpr int32_t SENSOR_SUCCESS = 0; // 10ms = 1000 * 1000 * 10 ns @@ -41,8 +41,6 @@ constexpr uint16_t HALL_A_B_COLUMN_ORDER = 4; constexpr float ACCURACY_ERROR_FOR_ALTA = 0.0001F; constexpr float MINI_NOTIFY_FOLD_ANGLE = 0.5F; std::vector oldFoldAngle = {0.0F, 0.0F}; -constexpr size_t SECONDARY_POSTURE_SIZE = 3; -constexpr size_t SECONDARY_HALL_SIZE = 2; constexpr uint16_t FIRST_DATA = 0; constexpr uint16_t SECOND_DATA = 1; constexpr uint16_t THIRD_DATA = 2; @@ -155,7 +153,7 @@ void SecondaryFoldSensorManager::HandlePostureData(const SensorEvent * const eve void SecondaryFoldSensorManager::NotifyFoldAngleChanged(const std::vector &angles) { - if (angles.size() < SECONDARY_HALL_SIZE) { + if (angles.size() < HALL_SIZE) { return; } bool bcFlag = fabs(angles[0] - oldFoldAngle[0]) < MINI_NOTIFY_FOLD_ANGLE; @@ -198,12 +196,12 @@ void SecondaryFoldSensorManager::HandleHallDataExt(const SensorEvent * const eve bool SecondaryFoldSensorManager::IsDataBeyondBoundary() { - if (globalAngle_.size() < SECONDARY_POSTURE_SIZE || globalHall_.size() < SECONDARY_HALL_SIZE) { + if (globalAngle_.size() < POSTURE_SIZE || globalHall_.size() < HALL_SIZE) { TLOGE(WmsLogTag::DMS, "oversize, global angles: %{public}zu, halls size: %{public}zu.", globalAngle_.size(), globalHall_.size()); return true; } - for (size_t i = 0; i < SECONDARY_POSTURE_SIZE - 1; i++) { + for (size_t i = 0; i < POSTURE_SIZE - 1; i++) { float angle = globalAngle_[i]; if (std::isless(angle, ANGLE_MIN_VAL) || std::isgreater(angle, ANGLE_MAX_VAL + ACCURACY_ERROR_FOR_ALTA)) { @@ -211,7 +209,7 @@ bool SecondaryFoldSensorManager::IsDataBeyondBoundary() return true; } } - for (size_t i = 0; i < SECONDARY_HALL_SIZE; i++) { + for (size_t i = 0; i < HALL_SIZE; i++) { uint16_t hall = globalHall_[i]; if (hall != 0 && hall != 1) { TLOGE(WmsLogTag::DMS, "i = %{public}zu, hall = %{public}u", i, hall); diff --git a/window_scene/screen_session_manager/src/fold_screen_controller/sensor_fold_state_manager/dual_display_sensor_fold_state_manager.cpp b/window_scene/screen_session_manager/src/fold_screen_controller/sensor_fold_state_manager/dual_display_sensor_fold_state_manager.cpp index 6b0871cecc..aa6f85516f 100644 --- a/window_scene/screen_session_manager/src/fold_screen_controller/sensor_fold_state_manager/dual_display_sensor_fold_state_manager.cpp +++ b/window_scene/screen_session_manager/src/fold_screen_controller/sensor_fold_state_manager/dual_display_sensor_fold_state_manager.cpp @@ -30,6 +30,7 @@ #include "ability_state_data.h" #include "process_data.h" #include "fold_screen_controller/fold_screen_policy.h" +#include "fold_screen_controller/fold_screen_controller_config.h" #include "screen_setting_helper.h" #include "fold_screen_controller/fold_screen_sensor_manager.h" @@ -62,7 +63,6 @@ const float INWARD_HALF_FOLDED_MIN_THRESHOLD = static_cast(system::GetInt ("const.fold.half_folded_min_threshold", 85)); constexpr int32_t HALL_THRESHOLD = 1; constexpr int32_t HALL_FOLDED_THRESHOLD = 0; -constexpr float ANGLE_MIN_VAL = 0.0F; constexpr float INWARD_FOLDED_LOWER_THRESHOLD = 10.0F; constexpr float INWARD_FOLDED_UPPER_THRESHOLD = 20.0F; constexpr float HALL_ZERO_INVALID_POSTURE = 170.0F; diff --git a/window_scene/screen_session_manager/src/fold_screen_controller/sensor_fold_state_manager/secondary_display_sensor_fold_state_manager.cpp b/window_scene/screen_session_manager/src/fold_screen_controller/sensor_fold_state_manager/secondary_display_sensor_fold_state_manager.cpp index 2a3d90029b..d425dd6d9f 100644 --- a/window_scene/screen_session_manager/src/fold_screen_controller/sensor_fold_state_manager/secondary_display_sensor_fold_state_manager.cpp +++ b/window_scene/screen_session_manager/src/fold_screen_controller/sensor_fold_state_manager/secondary_display_sensor_fold_state_manager.cpp @@ -19,6 +19,7 @@ #include #include "screen_session_manager.h" #include "fold_screen_controller/fold_screen_policy.h" +#include "fold_screen_controller/fold_screen_controller_config.h" #include "fold_screen_controller/sensor_fold_state_manager/sensor_fold_state_manager.h" #include "fold_screen_controller/secondary_fold_sensor_manager.h" #include "session/screen/include/screen_session.h" @@ -34,12 +35,6 @@ namespace OHOS::Rosen { namespace { constexpr uint8_t HALLS_AXIS_SIZE = 2; constexpr uint8_t ANGLES_AXIS_SIZE = 3; -constexpr float ANGLE_MIN_VAL = 0.0F; -constexpr float GRL_HALF_FOLDED_MAX_THRESHOLD = 140.0F; -constexpr float CLOSE_GRL_HALF_FOLDED_MIN_THRESHOLD = 70.0F; -constexpr float OPEN_GRL_HALF_FOLDED_MIN_THRESHOLD = 45.0F; -constexpr float GRL_HALF_FOLDED_BUFFER = 10.0F; -constexpr float LARGER_BOUNDARY_FOR_GRL_THRESHOLD = 90.0F; constexpr int32_t LARGER_BOUNDARY_FLAG = 1; constexpr int32_t SMALLER_BOUNDARY_FLAG = 0; constexpr int32_t HALL_THRESHOLD = 1; @@ -141,7 +136,7 @@ FoldStatus SecondaryDisplaySensorFoldStateManager::UpdateSwitchScreenBoundaryFor { if (hall == HALL_FOLDED_THRESHOLD) { allowUserSensorForLargeFoldDeviceAB = SMALLER_BOUNDARY_FLAG; - } else if (angle >= LARGER_BOUNDARY_FOR_GRL_THRESHOLD) { + } else if (angle >= LARGER_BOUNDARY_FOR_THRESHOLD) { allowUserSensorForLargeFoldDeviceAB = LARGER_BOUNDARY_FLAG; } return GetNextFoldStateHalf(angle, hall, state, allowUserSensorForLargeFoldDeviceAB); @@ -152,7 +147,7 @@ FoldStatus SecondaryDisplaySensorFoldStateManager::UpdateSwitchScreenBoundaryFor { if (hall == HALL_FOLDED_THRESHOLD) { allowUserSensorForLargeFoldDeviceBC = SMALLER_BOUNDARY_FLAG; - } else if (angle >= LARGER_BOUNDARY_FOR_GRL_THRESHOLD) { + } else if (angle >= LARGER_BOUNDARY_FOR_THRESHOLD) { allowUserSensorForLargeFoldDeviceBC = LARGER_BOUNDARY_FLAG; } return GetNextFoldStateHalf(angle, hall, state, allowUserSensorForLargeFoldDeviceBC); @@ -167,15 +162,15 @@ FoldStatus SecondaryDisplaySensorFoldStateManager::GetNextFoldStateHalf(float an FoldStatus state = FoldStatus::UNKNOWN; if (allowUserSensorForLargeFoldDevice == SMALLER_BOUNDARY_FLAG) { - if (std::islessequal(angle, OPEN_GRL_HALF_FOLDED_MIN_THRESHOLD) && hall == HALL_FOLDED_THRESHOLD) { + if (std::islessequal(angle, OPEN_HALF_FOLDED_MIN_THRESHOLD) && hall == HALL_FOLDED_THRESHOLD) { state = FoldStatus::FOLDED; - } else if (std::isgreaterequal(angle, OPEN_GRL_HALF_FOLDED_MIN_THRESHOLD + GRL_HALF_FOLDED_BUFFER) && + } else if (std::isgreaterequal(angle, OPEN_HALF_FOLDED_MIN_THRESHOLD + HALF_FOLDED_BUFFER) && hall == HALL_FOLDED_THRESHOLD) { state = FoldStatus::HALF_FOLD; - } else if (std::islessequal(angle, GRL_HALF_FOLDED_MAX_THRESHOLD - GRL_HALF_FOLDED_BUFFER) && + } else if (std::islessequal(angle, HALF_FOLDED_MAX_THRESHOLD - HALF_FOLDED_BUFFER) && hall == HALL_THRESHOLD) { state = FoldStatus::HALF_FOLD; - } else if (std::isgreaterequal(angle, GRL_HALF_FOLDED_MAX_THRESHOLD)) { + } else if (std::isgreaterequal(angle, HALF_FOLDED_MAX_THRESHOLD)) { state = FoldStatus::EXPAND; } else { state = CurrentState; @@ -186,14 +181,14 @@ FoldStatus SecondaryDisplaySensorFoldStateManager::GetNextFoldStateHalf(float an return state; } - if (hall == HALL_THRESHOLD && angle == OPEN_GRL_HALF_FOLDED_MIN_THRESHOLD) { + if (hall == HALL_THRESHOLD && angle == OPEN_HALF_FOLDED_MIN_THRESHOLD) { state = CurrentState; - } else if (std::islessequal(angle, CLOSE_GRL_HALF_FOLDED_MIN_THRESHOLD)) { + } else if (std::islessequal(angle, CLOSE_HALF_FOLDED_MIN_THRESHOLD)) { state = FoldStatus::FOLDED; - } else if (std::islessequal(angle, GRL_HALF_FOLDED_MAX_THRESHOLD - GRL_HALF_FOLDED_BUFFER) && - std::isgreater(angle, CLOSE_GRL_HALF_FOLDED_MIN_THRESHOLD + GRL_HALF_FOLDED_BUFFER)) { + } else if (std::islessequal(angle, HALF_FOLDED_MAX_THRESHOLD - HALF_FOLDED_BUFFER) && + std::isgreater(angle, CLOSE_HALF_FOLDED_MIN_THRESHOLD + HALF_FOLDED_BUFFER)) { state = FoldStatus::HALF_FOLD; - } else if (std::isgreaterequal(angle, GRL_HALF_FOLDED_MAX_THRESHOLD)) { + } else if (std::isgreaterequal(angle, HALF_FOLDED_MAX_THRESHOLD)) { state = FoldStatus::EXPAND; } else { state = CurrentState; @@ -302,9 +297,9 @@ FoldStatus SecondaryDisplaySensorFoldStateManager::CalculateNewABFoldStatus(floa { if ((previousHall == HALL_THRESHOLD && hall == HALL_FOLDED_THRESHOLD) || (previousHall == hall && std::islessequal(angle - previousAngle, ANGLE_DIFF_OF_SECONDARY_AB) && - std::islessequal(angle, CLOSE_GRL_HALF_FOLDED_MIN_THRESHOLD))) { + std::islessequal(angle, CLOSE_HALF_FOLDED_MIN_THRESHOLD))) { return FoldStatus::FOLDED; - } else if (std::isgreaterequal(angle, GRL_HALF_FOLDED_MAX_THRESHOLD - GRL_HALF_FOLDED_BUFFER)) { + } else if (std::isgreaterequal(angle, HALF_FOLDED_MAX_THRESHOLD - HALF_FOLDED_BUFFER)) { return FoldStatus::EXPAND; } else { return FoldStatus::HALF_FOLD; diff --git a/window_scene/screen_session_manager/src/fold_screen_controller/sensor_fold_state_manager/single_display_sensor_fold_state_manager.cpp b/window_scene/screen_session_manager/src/fold_screen_controller/sensor_fold_state_manager/single_display_sensor_fold_state_manager.cpp index 9be949cab8..6f11fba86c 100644 --- a/window_scene/screen_session_manager/src/fold_screen_controller/sensor_fold_state_manager/single_display_sensor_fold_state_manager.cpp +++ b/window_scene/screen_session_manager/src/fold_screen_controller/sensor_fold_state_manager/single_display_sensor_fold_state_manager.cpp @@ -17,6 +17,7 @@ #include #include "fold_screen_controller/fold_screen_policy.h" +#include "fold_screen_controller/fold_screen_controller_config.h" #include "fold_screen_controller/sensor_fold_state_manager/sensor_fold_state_manager.h" #include "session/screen/include/screen_session.h" @@ -28,12 +29,6 @@ namespace OHOS::Rosen { namespace { -constexpr float ANGLE_MIN_VAL = 0.0F; -constexpr float ALTA_HALF_FOLDED_MAX_THRESHOLD = 140.0F; -constexpr float CLOSE_ALTA_HALF_FOLDED_MIN_THRESHOLD = 70.0F; -constexpr float OPEN_ALTA_HALF_FOLDED_MIN_THRESHOLD = 25.0F; -constexpr float ALTA_HALF_FOLDED_BUFFER = 10.0F; -constexpr float LARGER_BOUNDARY_FOR_ALTA_THRESHOLD = 90.0F; constexpr int32_t LARGER_BOUNDARY_FLAG = 1; constexpr int32_t SMALLER_BOUNDARY_FLAG = 0; constexpr int32_t HALL_THRESHOLD = 1; @@ -61,7 +56,7 @@ void SingleDisplaySensorFoldStateManager::UpdateSwitchScreenBoundaryForLargeFold { if (hall == HALL_FOLDED_THRESHOLD) { allowUserSensorForLargeFoldDevice = SMALLER_BOUNDARY_FLAG; - } else if (angle >= LARGER_BOUNDARY_FOR_ALTA_THRESHOLD) { + } else if (angle >= LARGER_BOUNDARY_FOR_THRESHOLD) { allowUserSensorForLargeFoldDevice = LARGER_BOUNDARY_FLAG; } } @@ -77,15 +72,15 @@ FoldStatus SingleDisplaySensorFoldStateManager::GetNextFoldState(float angle, in FoldStatus state; if (allowUserSensorForLargeFoldDevice == SMALLER_BOUNDARY_FLAG) { - if (std::islessequal(angle, OPEN_ALTA_HALF_FOLDED_MIN_THRESHOLD) && hall == HALL_FOLDED_THRESHOLD) { + if (std::islessequal(angle, OPEN_HALF_FOLDED_MIN_THRESHOLD) && hall == HALL_FOLDED_THRESHOLD) { state = FoldStatus::FOLDED; - } else if (std::isgreaterequal(angle, OPEN_ALTA_HALF_FOLDED_MIN_THRESHOLD + ALTA_HALF_FOLDED_BUFFER) && + } else if (std::isgreaterequal(angle, OPEN_HALF_FOLDED_MIN_THRESHOLD + HALF_FOLDED_BUFFER) && hall == HALL_FOLDED_THRESHOLD) { state = FoldStatus::HALF_FOLD; - } else if (std::islessequal(angle, ALTA_HALF_FOLDED_MAX_THRESHOLD - ALTA_HALF_FOLDED_BUFFER) && + } else if (std::islessequal(angle, HALF_FOLDED_MAX_THRESHOLD - HALF_FOLDED_BUFFER) && hall == HALL_THRESHOLD) { state = FoldStatus::HALF_FOLD; - } else if (std::isgreaterequal(angle, ALTA_HALF_FOLDED_MAX_THRESHOLD)) { + } else if (std::isgreaterequal(angle, HALF_FOLDED_MAX_THRESHOLD)) { state = FoldStatus::EXPAND; } else { state = currentState; @@ -96,14 +91,14 @@ FoldStatus SingleDisplaySensorFoldStateManager::GetNextFoldState(float angle, in return state; } - if (hall == HALL_THRESHOLD && angle == OPEN_ALTA_HALF_FOLDED_MIN_THRESHOLD) { + if (hall == HALL_THRESHOLD && angle == OPEN_HALF_FOLDED_MIN_THRESHOLD) { state = currentState; - } else if (std::islessequal(angle, CLOSE_ALTA_HALF_FOLDED_MIN_THRESHOLD)) { + } else if (std::islessequal(angle, CLOSE_HALF_FOLDED_MIN_THRESHOLD)) { state = FoldStatus::FOLDED; - } else if (std::islessequal(angle, ALTA_HALF_FOLDED_MAX_THRESHOLD - ALTA_HALF_FOLDED_BUFFER) && - std::isgreater(angle, CLOSE_ALTA_HALF_FOLDED_MIN_THRESHOLD + ALTA_HALF_FOLDED_BUFFER)) { + } else if (std::islessequal(angle, HALF_FOLDED_MAX_THRESHOLD - HALF_FOLDED_BUFFER) && + std::isgreater(angle, CLOSE_HALF_FOLDED_MIN_THRESHOLD + HALF_FOLDED_BUFFER)) { state = FoldStatus::HALF_FOLD; - } else if (std::isgreaterequal(angle, ALTA_HALF_FOLDED_MAX_THRESHOLD)) { + } else if (std::isgreaterequal(angle, HALF_FOLDED_MAX_THRESHOLD)) { state = FoldStatus::EXPAND; } else { state = currentState; diff --git a/window_scene/screen_session_manager/src/fold_screen_controller/sensor_fold_state_manager/single_display_sensor_pocket_fold_state_manager.cpp b/window_scene/screen_session_manager/src/fold_screen_controller/sensor_fold_state_manager/single_display_sensor_pocket_fold_state_manager.cpp index c1d5b4c1d3..13624b04a3 100644 --- a/window_scene/screen_session_manager/src/fold_screen_controller/sensor_fold_state_manager/single_display_sensor_pocket_fold_state_manager.cpp +++ b/window_scene/screen_session_manager/src/fold_screen_controller/sensor_fold_state_manager/single_display_sensor_pocket_fold_state_manager.cpp @@ -17,6 +17,7 @@ #include #include "fold_screen_controller/fold_screen_policy.h" +#include "fold_screen_controller/fold_screen_controller_config.h" #include "fold_screen_controller/sensor_fold_state_manager/single_display_sensor_pocket_fold_state_manager.h" #include "fold_screen_controller/sensor_fold_state_manager/sensor_fold_state_manager.h" #include "session/screen/include/screen_session.h" @@ -38,12 +39,6 @@ using OHOS::AppExecFwk::AppStateData; using OHOS::AppExecFwk::ApplicationState; namespace { const std::string CAMERA_NAME = "camera"; -constexpr float ANGLE_MIN_VAL = 0.0F; -constexpr float ALTA_HALF_FOLDED_MAX_THRESHOLD = 140.0F; -constexpr float CLOSE_ALTA_HALF_FOLDED_MIN_THRESHOLD = 70.0F; -constexpr float OPEN_ALTA_HALF_FOLDED_MIN_THRESHOLD = 25.0F; -constexpr float ALTA_HALF_FOLDED_BUFFER = 10.0F; -constexpr float LARGER_BOUNDARY_FOR_ALTA_THRESHOLD = 90.0F; constexpr int32_t LARGER_BOUNDARY_FLAG = 1; constexpr int32_t SMALLER_BOUNDARY_FLAG = 0; constexpr int32_t HALL_THRESHOLD = 1; @@ -90,7 +85,7 @@ void SingleDisplaySensorPocketFoldStateManager::UpdateSwitchScreenBoundaryForLar { if (hall == HALL_FOLDED_THRESHOLD) { allowUserSensorForLargeFoldDevice = SMALLER_BOUNDARY_FLAG; - } else if (angle >= LARGER_BOUNDARY_FOR_ALTA_THRESHOLD) { + } else if (angle >= LARGER_BOUNDARY_FOR_THRESHOLD) { allowUserSensorForLargeFoldDevice = LARGER_BOUNDARY_FLAG; } } @@ -105,15 +100,15 @@ FoldStatus SingleDisplaySensorPocketFoldStateManager::GetNextFoldState(float ang FoldStatus state; if (allowUserSensorForLargeFoldDevice == SMALLER_BOUNDARY_FLAG) { - if (std::islessequal(angle, OPEN_ALTA_HALF_FOLDED_MIN_THRESHOLD) && hall == HALL_FOLDED_THRESHOLD) { + if (std::islessequal(angle, OPEN_HALF_FOLDED_MIN_THRESHOLD) && hall == HALL_FOLDED_THRESHOLD) { state = FoldStatus::FOLDED; - } else if (std::isgreaterequal(angle, OPEN_ALTA_HALF_FOLDED_MIN_THRESHOLD + ALTA_HALF_FOLDED_BUFFER) && + } else if (std::isgreaterequal(angle, OPEN_HALF_FOLDED_MIN_THRESHOLD + HALF_FOLDED_BUFFER) && hall == HALL_FOLDED_THRESHOLD) { state = FoldStatus::HALF_FOLD; - } else if (std::islessequal(angle, ALTA_HALF_FOLDED_MAX_THRESHOLD - ALTA_HALF_FOLDED_BUFFER) && + } else if (std::islessequal(angle, HALF_FOLDED_MAX_THRESHOLD - HALF_FOLDED_BUFFER) && hall == HALL_THRESHOLD) { state = FoldStatus::HALF_FOLD; - } else if (std::isgreaterequal(angle, ALTA_HALF_FOLDED_MAX_THRESHOLD)) { + } else if (std::isgreaterequal(angle, HALF_FOLDED_MAX_THRESHOLD)) { state = FoldStatus::EXPAND; } else { state = currentState; @@ -124,14 +119,14 @@ FoldStatus SingleDisplaySensorPocketFoldStateManager::GetNextFoldState(float ang return state; } - if (hall == HALL_THRESHOLD && angle == OPEN_ALTA_HALF_FOLDED_MIN_THRESHOLD) { + if (hall == HALL_THRESHOLD && angle == OPEN_HALF_FOLDED_MIN_THRESHOLD) { state = currentState; - } else if (std::islessequal(angle, CLOSE_ALTA_HALF_FOLDED_MIN_THRESHOLD)) { + } else if (std::islessequal(angle, CLOSE_HALF_FOLDED_MIN_THRESHOLD)) { state = FoldStatus::FOLDED; - } else if (std::islessequal(angle, ALTA_HALF_FOLDED_MAX_THRESHOLD - ALTA_HALF_FOLDED_BUFFER) && - std::isgreater(angle, CLOSE_ALTA_HALF_FOLDED_MIN_THRESHOLD + ALTA_HALF_FOLDED_BUFFER)) { + } else if (std::islessequal(angle, HALF_FOLDED_MAX_THRESHOLD - HALF_FOLDED_BUFFER) && + std::isgreater(angle, CLOSE_HALF_FOLDED_MIN_THRESHOLD + HALF_FOLDED_BUFFER)) { state = FoldStatus::HALF_FOLD; - } else if (std::isgreaterequal(angle, ALTA_HALF_FOLDED_MAX_THRESHOLD)) { + } else if (std::isgreaterequal(angle, HALF_FOLDED_MAX_THRESHOLD)) { state = FoldStatus::EXPAND; } else { state = currentState; diff --git a/window_scene/screen_session_manager/src/fold_screen_controller/super_fold_sensor_manager.cpp b/window_scene/screen_session_manager/src/fold_screen_controller/super_fold_sensor_manager.cpp index 5687d0960d..bdb313f8cd 100644 --- a/window_scene/screen_session_manager/src/fold_screen_controller/super_fold_sensor_manager.cpp +++ b/window_scene/screen_session_manager/src/fold_screen_controller/super_fold_sensor_manager.cpp @@ -22,6 +22,7 @@ #include "fold_screen_controller/super_fold_sensor_manager.h" #include "fold_screen_controller/super_fold_state_manager.h" +#include "fold_screen_controller/fold_screen_controller_config.h" #include "window_manager_hilog.h" #include "screen_session_manager.h" @@ -29,7 +30,6 @@ namespace OHOS { namespace Rosen { namespace { -constexpr float ANGLE_MIN_VAL = 30.0F; constexpr float ANGLE_MAX_VAL = 180.0F; constexpr float ANGLE_FLAT_THRESHOLD = 160.0F; constexpr float ANGLE_SENSOR_THRESHOLD = 160.0F; 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 55b5bed497..c7a96b7e01 100644 --- a/window_scene/screen_session_manager/src/screen_scene_config.cpp +++ b/window_scene/screen_session_manager/src/screen_scene_config.cpp @@ -66,7 +66,14 @@ enum XmlNodeElement { IS_SUPPORT_OFFSCREEN_RENDERING, OFF_SCREEN_PPI_THRESHOLD, PC_MODE_DPI, - SUPPORT_DURING_CALL + SUPPORT_DURING_CALL, + HALF_FOLDED_MAX_THRESHOLD, + CLOSE_HALF_FOLDED_MIN_THRESHOLD, + OPEN_HALF_FOLDED_MIN_THRESHOLD, + HALF_FOLDED_BUFFER, + LARGER_BOUNDARY_FOR_THRESHOLD, + POSTURE_SIZE, + HALL_SIZE }; } @@ -112,7 +119,14 @@ std::map ScreenSceneConfig::xmlNodeMap_ = { {IS_SUPPORT_OFFSCREEN_RENDERING, "isSupportOffScreenRendering"}, {OFF_SCREEN_PPI_THRESHOLD, "offScreenPPIThreshold"}, {PC_MODE_DPI, "pcModeDpi"}, - {SUPPORT_DURING_CALL, "supportDuringCall"} + {SUPPORT_DURING_CALL, "supportDuringCall"}, + {HALF_FOLDED_MAX_THRESHOLD, "halfFoldMaxThreshold"}, + {CLOSE_HALF_FOLDED_MIN_THRESHOLD, "closeHalfFoldedMinThreshold"}, + {OPEN_HALF_FOLDED_MIN_THRESHOLD, "openHalfFoldedMinThreshold"}, + {HALF_FOLDED_BUFFER, "halfFoldedBuffer"}, + {LARGER_BOUNDARY_FOR_THRESHOLD, "largerBoundaryForThreshold"}, + {POSTURE_SIZE, "postureSize"}, + {HALL_SIZE, "hallSize"} }; @@ -205,7 +219,14 @@ void ScreenSceneConfig::ParseNodeConfig(const xmlNodePtr& currNode) (xmlNodeMap_[BUILD_IN_DEFAULT_ORIENTATION] == nodeName) || (xmlNodeMap_[DEFAULT_DEVICE_ROTATION_OFFSET] == nodeName) || (xmlNodeMap_[OFF_SCREEN_PPI_THRESHOLD] == nodeName) || - (xmlNodeMap_[PC_MODE_DPI] == nodeName); + (xmlNodeMap_[PC_MODE_DPI] == nodeName) || + (xmlNodeMap_[HALF_FOLDED_MAX_THRESHOLD] == nodeName) || + (xmlNodeMap_[CLOSE_HALF_FOLDED_MIN_THRESHOLD] == nodeName) || + (xmlNodeMap_[OPEN_HALF_FOLDED_MIN_THRESHOLD] == nodeName) || + (xmlNodeMap_[HALF_FOLDED_BUFFER] == nodeName) || + (xmlNodeMap_[LARGER_BOUNDARY_FOR_THRESHOLD] == nodeName) || + (xmlNodeMap_[POSTURE_SIZE] == nodeName) || + (xmlNodeMap_[HALL_SIZE] == nodeName); bool stringConfigCheck = (xmlNodeMap_[DEFAULT_DISPLAY_CUTOUT_PATH] == nodeName) || (xmlNodeMap_[SUB_DISPLAY_CUTOUT_PATH] == nodeName) || (xmlNodeMap_[ROTATION_POLICY] == nodeName) || @@ -626,6 +647,7 @@ bool ScreenSceneConfig::IsSupportOffScreenRendering() } bool ScreenSceneConfig::IsSupportDuringCall() + { if (enableConfig_.count("supportDuringCall") != 0) { return static_cast(enableConfig_["supportDuringCall"]); @@ -633,4 +655,15 @@ bool ScreenSceneConfig::IsSupportDuringCall() return false; } // LCOV_EXCL_STOP + +uint32_t ScreenSceneConfig::GetNumberConfigValue(std::string name, uint32_t default_value) +{ + if (intNumbersConfig_.count(name) != 0) { + uint32_t value = static_cast(intNumbersConfig_[name][0]); + TLOGD(WmsLogTag::DMS, "%{public}s = %{public}u", name.c_str(), value); + return value; + } + TLOGD(WmsLogTag::DMS, "default %{public}s = %{public}u", name.c_str(), default_value); + return default_value; +} } // namespace OHOS::Rosen 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 63824d6bd3..5b11307920 100644 --- a/window_scene/test/dms_unittest/screen_scene_config_test.cpp +++ b/window_scene/test/dms_unittest/screen_scene_config_test.cpp @@ -13,6 +13,7 @@ * limitations under the License. */ +#include #include #include @@ -1271,6 +1272,33 @@ HWTEST_F(ScreenSceneConfigTest, IsSupportDuringCall02, TestSize.Level1) bool res = ScreenSceneConfig::IsSupportDuringCall(); EXPECT_FALSE(res); } + +/** + * @tc.name: GetNumberConfigValue + * @tc.desc: GetNumberConfigValue + * @tc.type: FUNC + */ +HWTEST_F(ScreenSceneConfigTest, GetNumberConfigValue, TestSize.Level1) +{ + std::vector test_config; + test_config.push_back(10); + ScreenSceneConfig::intNumbersConfig_["halfFoldedBuffer"] = test_config; + uint32_t res = ScreenSceneConfig::GetNumberConfigValue("halfFoldedBuffer", 1); + EXPECT_EQ(res, 10); +} + +/** + * @tc.name: GetNumberConfigValue_default + * @tc.desc: GetNumberConfigValue_default + * @tc.type: FUNC + */ +HWTEST_F(ScreenSceneConfigTest, GetNumberConfigValue_default, TestSize.Level1) +{ + ScreenSceneConfig::intNumbersConfig_.erase("halfFoldedBuffer"); + uint32_t res = ScreenSceneConfig::GetNumberConfigValue("halfFoldedBuffer", 1); + EXPECT_EQ(res, 1); +} + } } // namespace Rosen } // namespace OHOS diff --git a/window_scene/test/dms_unittest/single_display_sensor_fold_state_manager_test.cpp b/window_scene/test/dms_unittest/single_display_sensor_fold_state_manager_test.cpp index bc362fa3fc..138ad368dd 100644 --- a/window_scene/test/dms_unittest/single_display_sensor_fold_state_manager_test.cpp +++ b/window_scene/test/dms_unittest/single_display_sensor_fold_state_manager_test.cpp @@ -17,6 +17,7 @@ #include "screen_session_manager/include/fold_screen_controller/sensor_fold_state_manager/single_display_sensor_fold_state_manager.h" #include "scene_board_judgement.h" +#include "fold_screen_state_internel.h" using namespace testing; using namespace testing::ext; @@ -171,10 +172,13 @@ HWTEST_F(SingleDisplaySensorFoldStateManagerTest, GetNextFoldState02, TestSize.L } SingleDisplaySensorFoldStateManager manager; manager.allowUserSensorForLargeFoldDevice = 1; - float angel = 25.0F; int hall = 1; - auto result1 = manager.GetNextFoldState(angel, hall); - EXPECT_EQ(static_cast(result1), 0); + float angel; + if (FoldScreenStateInternel::IsSingleDisplayFoldDevice()) { + angel = 25.0F; + auto result1 = manager.GetNextFoldState(angel, hall); + EXPECT_EQ(static_cast(result1), 0); + } angel = 70.0F - 0.1; auto result2 = manager.GetNextFoldState(angel, hall); diff --git a/window_scene/test/dms_unittest/single_display_sensor_pocket_fold_state_manager_test.cpp b/window_scene/test/dms_unittest/single_display_sensor_pocket_fold_state_manager_test.cpp index 3a8d1f85bc..1a45c5e891 100644 --- a/window_scene/test/dms_unittest/single_display_sensor_pocket_fold_state_manager_test.cpp +++ b/window_scene/test/dms_unittest/single_display_sensor_pocket_fold_state_manager_test.cpp @@ -164,10 +164,13 @@ HWTEST_F(SingleDisplaySensorPocketFoldStateManagerTest, GetNextFoldState02, Test { SingleDisplaySensorPocketFoldStateManager manager; manager.allowUserSensorForLargeFoldDevice = 1; - float angel = 25.0F; + float angel; int hall = 1; - auto result1 = manager.GetNextFoldState(angel, hall); - EXPECT_EQ(static_cast(result1), 0); + if (FoldScreenStateInternel::IsSingleDisplayPocketFoldDevice()) { + angel = 25.0F; + auto result1 = manager.GetNextFoldState(angel, hall); + EXPECT_EQ(static_cast(result1), 0); + } angel = 70.0F - 0.1; auto result2 = manager.GetNextFoldState(angel, hall); -- Gitee