1 /*
2 * Copyright (c) 2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "fold_screen_controller/sensor_fold_state_manager/single_display_sensor_fold_state_manager.h"
17 #include <parameters.h>
18
19 #include "fold_screen_controller/fold_screen_policy.h"
20 #include "fold_screen_controller/sensor_fold_state_manager/sensor_fold_state_manager.h"
21 #include "session/screen/include/screen_session.h"
22
23 #include "window_manager_hilog.h"
24
25 #ifdef POWER_MANAGER_ENABLE
26 #include <power_mgr_client.h>
27 #endif
28
29 namespace OHOS::Rosen {
30 namespace {
31 constexpr float ANGLE_MIN_VAL = 0.0F;
32 constexpr float ALTA_HALF_FOLDED_MAX_THRESHOLD = 140.0F;
33 constexpr float CLOSE_ALTA_HALF_FOLDED_MIN_THRESHOLD = 70.0F;
34 constexpr float OPEN_ALTA_HALF_FOLDED_MIN_THRESHOLD = 25.0F;
35 constexpr float ALTA_HALF_FOLDED_BUFFER = 10.0F;
36 constexpr float LARGER_BOUNDARY_FOR_ALTA_THRESHOLD = 90.0F;
37 constexpr int32_t LARGER_BOUNDARY_FLAG = 1;
38 constexpr int32_t SMALLER_BOUNDARY_FLAG = 0;
39 constexpr int32_t HALL_THRESHOLD = 1;
40 constexpr int32_t HALL_FOLDED_THRESHOLD = 0;
41 } // namespace
42
SingleDisplaySensorFoldStateManager()43 SingleDisplaySensorFoldStateManager::SingleDisplaySensorFoldStateManager() {}
~SingleDisplaySensorFoldStateManager()44 SingleDisplaySensorFoldStateManager::~SingleDisplaySensorFoldStateManager() {}
45
HandleAngleChange(float angle,int hall,sptr<FoldScreenPolicy> foldScreenPolicy)46 void SingleDisplaySensorFoldStateManager::HandleAngleChange(float angle, int hall,
47 sptr<FoldScreenPolicy> foldScreenPolicy)
48 {
49 FoldStatus nextState = GetNextFoldState(angle, hall);
50 HandleSensorChange(nextState, angle, foldScreenPolicy);
51 }
52
HandleHallChange(float angle,int hall,sptr<FoldScreenPolicy> foldScreenPolicy)53 void SingleDisplaySensorFoldStateManager::HandleHallChange(float angle, int hall,
54 sptr<FoldScreenPolicy> foldScreenPolicy)
55 {
56 FoldStatus nextState = GetNextFoldState(angle, hall);
57 HandleSensorChange(nextState, angle, foldScreenPolicy);
58 }
59
UpdateSwitchScreenBoundaryForLargeFoldDevice(float angle,int hall)60 void SingleDisplaySensorFoldStateManager::UpdateSwitchScreenBoundaryForLargeFoldDevice(float angle, int hall)
61 {
62 if (hall == HALL_FOLDED_THRESHOLD) {
63 allowUserSensorForLargeFoldDevice = SMALLER_BOUNDARY_FLAG;
64 } else if (angle >= LARGER_BOUNDARY_FOR_ALTA_THRESHOLD) {
65 allowUserSensorForLargeFoldDevice = LARGER_BOUNDARY_FLAG;
66 }
67 }
68
69
GetNextFoldState(float angle,int hall)70 FoldStatus SingleDisplaySensorFoldStateManager::GetNextFoldState(float angle, int hall)
71 {
72 UpdateSwitchScreenBoundaryForLargeFoldDevice(angle, hall);
73 FoldStatus currentState = GetCurrentState();
74 if (std::isless(angle, ANGLE_MIN_VAL)) {
75 return currentState;
76 }
77 FoldStatus state;
78
79 if (allowUserSensorForLargeFoldDevice == SMALLER_BOUNDARY_FLAG) {
80 if (std::islessequal(angle, OPEN_ALTA_HALF_FOLDED_MIN_THRESHOLD) && hall == HALL_FOLDED_THRESHOLD) {
81 state = FoldStatus::FOLDED;
82 } else if (std::isgreaterequal(angle, OPEN_ALTA_HALF_FOLDED_MIN_THRESHOLD + ALTA_HALF_FOLDED_BUFFER) &&
83 hall == HALL_FOLDED_THRESHOLD) {
84 state = FoldStatus::HALF_FOLD;
85 } else if (std::islessequal(angle, ALTA_HALF_FOLDED_MAX_THRESHOLD - ALTA_HALF_FOLDED_BUFFER) &&
86 hall == HALL_THRESHOLD) {
87 state = FoldStatus::HALF_FOLD;
88 } else if (std::isgreaterequal(angle, ALTA_HALF_FOLDED_MAX_THRESHOLD)) {
89 state = FoldStatus::EXPAND;
90 } else {
91 state = currentState;
92 if (state == FoldStatus::UNKNOWN) {
93 state = FoldStatus::HALF_FOLD;
94 }
95 }
96 return state;
97 }
98
99 if (hall == HALL_THRESHOLD && angle == OPEN_ALTA_HALF_FOLDED_MIN_THRESHOLD) {
100 state = currentState;
101 } else if (std::islessequal(angle, CLOSE_ALTA_HALF_FOLDED_MIN_THRESHOLD)) {
102 state = FoldStatus::FOLDED;
103 } else if (std::islessequal(angle, ALTA_HALF_FOLDED_MAX_THRESHOLD - ALTA_HALF_FOLDED_BUFFER) &&
104 std::isgreater(angle, CLOSE_ALTA_HALF_FOLDED_MIN_THRESHOLD + ALTA_HALF_FOLDED_BUFFER)) {
105 state = FoldStatus::HALF_FOLD;
106 } else if (std::isgreaterequal(angle, ALTA_HALF_FOLDED_MAX_THRESHOLD)) {
107 state = FoldStatus::EXPAND;
108 } else {
109 state = currentState;
110 if (state == FoldStatus::UNKNOWN) {
111 state = FoldStatus::HALF_FOLD;
112 }
113 }
114 return state;
115 }
116
RegisterApplicationStateObserver()117 void SingleDisplaySensorFoldStateManager::RegisterApplicationStateObserver() {}
118 } // namespace OHOS::Rosen