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 0000000000000000000000000000000000000000..a39ba34ad86f09946159591046d1d4a6e6bede1a --- /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 4bcb964dffb2c4ecc413e311a1a9ca17e3e6ef4e..84b5446810b23f11432a388f6a017611cbe47c5a 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" @@ -68,6 +68,7 @@ public: static bool IsSupportOffScreenRendering(); static uint32_t GetOffScreenPPIThreshold(); static bool IsSupportDuringCall(); + static uint32_t GetNumberConfigValue(std::string name, uint32_t default_value); static bool IsConcurrentUser(); private: 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 7031a5a62c8febc09e5547e82f5c9e912ffa94df..69d279de127a12fbad6ea8be8a744c231e1f4595 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 333b63d770ddebae65c6d982ae1cbc26f329424a..80b588fd3574bc4fd5b62eebc83b9abf63894b4d 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 6b0871cecc2db5a2b1c1c4315e90d11a7109b8f9..aa6f85516f50d716c526ed9cd9393fba821da40d 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 2a3d90029b4f4b2da29e350ea4f3079c051eb77c..d425dd6d9f456fdc6d97a399b1b6516912f1bd7e 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 9be949cab8632f275a9896e723d5c22bc18249b3..6f11fba86ca47d4606355f9ead9e68f6c173d758 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 c1d5b4c1d3a74dd8ec161bcf81a1606dc6670d11..13624b04a3adee075211e4416c4002a20d1226e0 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 5687d0960d40521345e2dac1546d99d2a6fc5500..bdb313f8cd79f74fafc933bba4f96a52bd3b3ad4 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 4798b3a1b40ff8be9441370177a225f1fe520365..b62f9d8abc9bb42a3380ec0eae86a9a9baaed673 100644 --- a/window_scene/screen_session_manager/src/screen_scene_config.cpp +++ b/window_scene/screen_session_manager/src/screen_scene_config.cpp @@ -68,7 +68,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 }; } @@ -117,7 +124,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"} }; std::vector ScreenSceneConfig::Split(std::string str, std::string pattern) @@ -217,7 +231,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) || @@ -731,6 +752,7 @@ bool ScreenSceneConfig::IsSupportOffScreenRendering() } bool ScreenSceneConfig::IsSupportDuringCall() + { if (enableConfig_.count("supportDuringCall") != 0) { return static_cast(enableConfig_["supportDuringCall"]); @@ -743,4 +765,15 @@ bool ScreenSceneConfig::IsConcurrentUser() return isConcurrentUser_; } // 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 a2087d8ff3b94a6985c6602c6caab5cb23705d2c..269d5adb35ee929bca9408ecf7df9927afecd1d5 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 @@ -1274,6 +1275,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/secondary_display_sensor_fold_state_manager_test.cpp b/window_scene/test/dms_unittest/secondary_display_sensor_fold_state_manager_test.cpp index 89478d58ab2bfbbedf0de927175bfc37dfc647f6..b9618977c3df40d518b421e5e81b730670fa8253 100644 --- a/window_scene/test/dms_unittest/secondary_display_sensor_fold_state_manager_test.cpp +++ b/window_scene/test/dms_unittest/secondary_display_sensor_fold_state_manager_test.cpp @@ -417,6 +417,9 @@ HWTEST_F(SecondaryDisplaySensorFoldStateManagerTest, GetNextFoldStateHalf02, Tes */ HWTEST_F(SecondaryDisplaySensorFoldStateManagerTest, GetNextFoldStateHalf03, TestSize.Level1) { + if (!FoldScreenStateInternel::IsSecondaryDisplayFoldDevice()) { + return; + } SecondaryDisplaySensorFoldStateManager manager; int32_t allowUserSensorForLargeFoldDevice = 0; FoldStatus state = FoldStatus::UNKNOWN; 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 bc362fa3fc8cb8ab00b07d9dfa4009a02fd71f39..138ad368dd1d2568220f642c615e2f58fc04c2ac 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 3a8d1f85bcc1576ded64fdf580373073e4d1346a..1a45c5e89169dbd0130ce774dab8f631cdbfcf4b 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);