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 <gtest/gtest.h>
17
18 #include "fold_screen_controller/fold_screen_sensor_manager.h"
19 #include "fold_screen_controller/fold_screen_controller.h"
20 #include "parameters.h"
21 #include "screen_session_manager/include/fold_screen_controller/sensor_fold_state_manager/dual_display_sensor_fold_state_manager.h"
22 #include "screen_session_manager/include/screen_session_manager.h"
23 #include "fold_screen_state_internel.h"
24
25 using namespace testing;
26 using namespace testing::ext;
27
28 namespace OHOS {
29 namespace Rosen {
30 namespace {
31 constexpr uint32_t SLEEP_TIME_US = 100000;
32 const float INWARD_FOLDED_THRESHOLD = static_cast<float>(system::GetIntParameter<int32_t>
33 ("const.fold.folded_threshold", 85));
34 const float INWARD_EXPAND_THRESHOLD = static_cast<float>(system::GetIntParameter<int32_t>
35 ("const.fold.expand_threshold", 145));
36 const float INWARD_HALF_FOLDED_MAX_THRESHOLD = static_cast<float>(system::GetIntParameter<int32_t>
37 ("const.half_folded_max_threshold", 135));
38 const float INWARD_HALF_FOLDED_MIN_THRESHOLD = static_cast<float>(system::GetIntParameter<int32_t>
39 ("const.fold.half_folded_min_threshold", 85));
40 constexpr int32_t HALL_THRESHOLD = 1;
41 constexpr int32_t HALL_FOLDED_THRESHOLD = 0;
42 constexpr float INWARD_FOLDED_LOWER_THRESHOLD = 10.0F;
43 constexpr float INWARD_FOLDED_UPPER_THRESHOLD = 20.0F;
44 constexpr float ANGLE_BUFFER = 0.001F;
45 }
46
47 class DualDisplaySensorFoldStateManagerTest : public testing::Test {
48 public:
49 static void SetUpTestCase();
50 static void TearDownTestCase();
51 void SetUp() override;
52 void TearDown() override;
53 };
54
SetUpTestCase()55 void DualDisplaySensorFoldStateManagerTest::SetUpTestCase()
56 {
57 }
58
TearDownTestCase()59 void DualDisplaySensorFoldStateManagerTest::TearDownTestCase()
60 {
61 }
62
SetUp()63 void DualDisplaySensorFoldStateManagerTest::SetUp()
64 {
65 }
66
TearDown()67 void DualDisplaySensorFoldStateManagerTest::TearDown()
68 {
69 usleep(SLEEP_TIME_US);
70 }
71
72 namespace {
73
74 /**
75 * @tc.name: DualDisplaySensorFoldStateManager
76 * @tc.desc: DualDisplaySensorFoldStateManager
77 * @tc.type: FUNC
78 */
79 HWTEST_F(DualDisplaySensorFoldStateManagerTest, DualDisplaySensorFoldStateManager, TestSize.Level1)
80 {
81 if (!FoldScreenStateInternel::IsDualDisplayFoldDevice()) {
82 GTEST_SKIP();
83 }
84 std::shared_ptr<TaskScheduler> screenPowerTaskScheduler = nullptr;
85 DualDisplaySensorFoldStateManager mgr = DualDisplaySensorFoldStateManager(screenPowerTaskScheduler);
86 ASSERT_EQ(mgr.packageNames_.size(), 1);
87 }
88
89 /**
90 * @tc.name: HandleAngleChange
91 * @tc.desc: HandleAngleChange
92 * @tc.type: FUNC
93 */
94 HWTEST_F(DualDisplaySensorFoldStateManagerTest, HandleAngleChange, TestSize.Level1)
95 {
96 std::shared_ptr<TaskScheduler> screenPowerTaskScheduler = nullptr;
97 DualDisplaySensorFoldStateManager mgr = DualDisplaySensorFoldStateManager(screenPowerTaskScheduler);
98 float angle = 0.0f;
99 int hall = 0;
100 sptr<FoldScreenPolicy> foldScreenPolicy = new FoldScreenPolicy();
101 mgr.HandleAngleChange(angle, hall, foldScreenPolicy);
102 ASSERT_TRUE(std::islessequal(angle, INWARD_FOLDED_THRESHOLD + ANGLE_BUFFER));
103 ASSERT_FALSE(hall == HALL_THRESHOLD);
104
105 hall = 1;
106 mgr.HandleAngleChange(angle, hall, foldScreenPolicy);
107 ASSERT_TRUE(std::islessequal(angle, INWARD_FOLDED_THRESHOLD + ANGLE_BUFFER));
108 ASSERT_TRUE(hall == HALL_THRESHOLD);
109
110 angle = 100.0f;
111 mgr.HandleAngleChange(angle, hall, foldScreenPolicy);
112 ASSERT_FALSE(std::islessequal(angle, INWARD_FOLDED_THRESHOLD + ANGLE_BUFFER));
113 ASSERT_TRUE(hall == HALL_THRESHOLD);
114
115 hall = 0;
116 mgr.HandleAngleChange(angle, hall, foldScreenPolicy);
117 ASSERT_FALSE(std::islessequal(angle, INWARD_FOLDED_THRESHOLD + ANGLE_BUFFER));
118 ASSERT_FALSE(hall == HALL_THRESHOLD);
119 }
120
121 /**
122 * @tc.name: HandleHallChangeInner
123 * @tc.desc: HandleHallChangeInner
124 * @tc.type: FUNC
125 */
126 HWTEST_F(DualDisplaySensorFoldStateManagerTest, HandleHallChangeInner, TestSize.Level1)
127 {
128 std::recursive_mutex mutex;
129 std::shared_ptr<TaskScheduler> screenPowerTaskScheduler = nullptr;
130 DualDisplaySensorFoldStateManager mgr = DualDisplaySensorFoldStateManager(screenPowerTaskScheduler);
131 float angle = 0.0f;
132 int hall = 1;
133 sptr<FoldScreenPolicy> foldScreenPolicy = new FoldScreenPolicy();
134 mgr.applicationStateObserver_ = nullptr;
135 mgr.HandleHallChangeInner(angle, hall, foldScreenPolicy);
136 ASSERT_FALSE(mgr.applicationStateObserver_ != nullptr);
137 ASSERT_TRUE(hall == HALL_THRESHOLD);
138
139 mgr.applicationStateObserver_ = new ApplicationStateObserver();
140 mgr.HandleHallChangeInner(angle, hall, foldScreenPolicy);
141 ASSERT_TRUE(mgr.applicationStateObserver_ != nullptr);
142 ASSERT_TRUE(hall == HALL_THRESHOLD);
143
144 mgr.applicationStateObserver_ = nullptr;
145 hall = 0;
146 mgr.HandleHallChangeInner(angle, hall, foldScreenPolicy);
147 ASSERT_FALSE(mgr.applicationStateObserver_ != nullptr);
148 ASSERT_FALSE(hall == HALL_THRESHOLD);
149 }
150
151 /**
152 * @tc.name: HandleHallChangeWhenHallIs1NormalHallChange
153 * @tc.desc: DualDisplaySensorFoldStateManager.HandleHallChange
154 * @tc.type: FUNC
155 */
156 HWTEST_F(DualDisplaySensorFoldStateManagerTest,
157 HandleHallChangeWhenHallIs1NormalHallChange,
158 TestSize.Level1)
159 {
160 // test hall = 1
161 std::recursive_mutex mutex;
162 std::shared_ptr<TaskScheduler> screenPowerTaskScheduler =
163 std::make_shared<TaskScheduler>("HandleHallChange");
164 DualDisplaySensorFoldStateManager mgr = DualDisplaySensorFoldStateManager(screenPowerTaskScheduler);
165 int hall = 1;
166 float angle = 150.0f;
167 sptr<FoldScreenPolicy> foldScreenPolicy = new FoldScreenPolicy();
168 ASSERT_NO_FATAL_FAILURE({mgr.HandleHallChange(angle, hall, foldScreenPolicy);});
169 }
170
171 /**
172 * @tc.name: HandleHallChangeWhenAngleLess170
173 * @tc.desc: DualDisplaySensorFoldStateManager.HandleHallChange
174 * @tc.type: FUNC
175 */
176 HWTEST_F(DualDisplaySensorFoldStateManagerTest,
177 HandleHallChangeWhenAngleLess170,
178 TestSize.Level1)
179 {
180 // test angle < 170
181 std::recursive_mutex mutex;
182 std::shared_ptr<TaskScheduler> screenPowerTaskScheduler =
183 std::make_shared<TaskScheduler>("HandleHallChange");
184 DualDisplaySensorFoldStateManager mgr = DualDisplaySensorFoldStateManager(screenPowerTaskScheduler);
185 int hall = 1;
186 float angle = 150.0f;
187 sptr<FoldScreenPolicy> foldScreenPolicy = new FoldScreenPolicy();
188 ASSERT_NO_FATAL_FAILURE({mgr.HandleHallChange(angle, hall, foldScreenPolicy);});
189 }
190
191 /**
192 * @tc.name: HandleHallChangeWhenHallIs0AndAngleMore170HallChanged
193 * @tc.desc: DualDisplaySensorFoldStateManager.HandleHallChange
194 * @tc.type: FUNC
195 */
196 HWTEST_F(DualDisplaySensorFoldStateManagerTest,
197 HandleHallChangeWhenHallIs0AndAngleMore170HallChanged,
198 TestSize.Level1)
199 {
200 // test hall = 0 angle > 170 and hall change to 1
201 std::recursive_mutex mutex;
202 std::shared_ptr<TaskScheduler> screenPowerTaskScheduler =
203 std::make_shared<TaskScheduler>("HandleHallChange");
204 DualDisplaySensorFoldStateManager mgr = DualDisplaySensorFoldStateManager(screenPowerTaskScheduler);
205 float angle = 178.0f;
206 int hall = 0;
207 FoldScreenSensorManager::GetInstance().SetGlobalHall(1);
208 sptr<FoldScreenPolicy> foldScreenPolicy = new FoldScreenPolicy();
209 ASSERT_NO_FATAL_FAILURE({mgr.HandleHallChange(angle, hall, foldScreenPolicy);});
210 usleep(500000);
211 }
212
213 /**
214 * @tc.name: HandleHallChangeWhenHallIs0AndAngleMore170HallNotChanged
215 * @tc.desc: DualDisplaySensorFoldStateManager.HandleHallChange
216 * @tc.type: FUNC
217 */
218 HWTEST_F(DualDisplaySensorFoldStateManagerTest,
219 HandleHallChangeWhenHallIs0AndAngleMore170HallNotChanged,
220 TestSize.Level1)
221 {
222 // test hall = 0 angle > 170 and angle not change
223 std::recursive_mutex mutex;
224 std::shared_ptr<TaskScheduler> screenPowerTaskScheduler =
225 std::make_shared<TaskScheduler>("HandleHallChange");
226 DualDisplaySensorFoldStateManager mgr = DualDisplaySensorFoldStateManager(screenPowerTaskScheduler);
227 float angle = 178.0f;
228 int hall = 0;
229 FoldScreenSensorManager::GetInstance().SetGlobalHall(0);
230 FoldScreenSensorManager::GetInstance().SetGlobalAngle(angle);
231 sptr<FoldScreenPolicy> foldScreenPolicy = new FoldScreenPolicy();
232 ASSERT_NO_FATAL_FAILURE({mgr.HandleHallChange(angle, hall, foldScreenPolicy);});
233 usleep(500000);
234 }
235
236 /**
237 * @tc.name: HandleHallChangeWhenHallIs0AndAngleMore170AngleChangedToLess170
238 * @tc.desc: DualDisplaySensorFoldStateManager.HandleHallChange
239 * @tc.type: FUNC
240 */
241 HWTEST_F(DualDisplaySensorFoldStateManagerTest,
242 HandleHallChangeWhenHallIs0AndAngleMore170AngleChangedToLess170,
243 TestSize.Level1)
244 {
245 // test hall = 0 angle < 170 and angle change less 170
246 std::recursive_mutex mutex;
247 std::shared_ptr<TaskScheduler> screenPowerTaskScheduler =
248 std::make_shared<TaskScheduler>("HandleHallChange");
249 DualDisplaySensorFoldStateManager mgr = DualDisplaySensorFoldStateManager(screenPowerTaskScheduler);
250 float angle = 178.0f;
251 int hall = 0;
252 FoldScreenSensorManager::GetInstance().SetGlobalHall(0);
253 FoldScreenSensorManager::GetInstance().SetGlobalAngle(150.0f);
254 sptr<FoldScreenPolicy> foldScreenPolicy = new FoldScreenPolicy();
255 ASSERT_NO_FATAL_FAILURE({mgr.HandleHallChange(angle, hall, foldScreenPolicy);});
256 usleep(500000);
257 }
258
259 /**
260 * @tc.name: HandleHallChangeWhenHallIs0AndAngleMore170AngleChangedToMore170
261 * @tc.desc: DualDisplaySensorFoldStateManager.HandleHallChange
262 * @tc.type: FUNC
263 */
264 HWTEST_F(DualDisplaySensorFoldStateManagerTest,
265 HandleHallChangeWhenHallIs0AndAngleMore170AngleChangedToMore170,
266 TestSize.Level1)
267 {
268 // test hall = 0 angle > 170 and angle change more than 170
269 std::recursive_mutex mutex;
270 std::shared_ptr<TaskScheduler> screenPowerTaskScheduler =
271 std::make_shared<TaskScheduler>("HandleHallChange");
272 DualDisplaySensorFoldStateManager mgr = DualDisplaySensorFoldStateManager(screenPowerTaskScheduler);
273 float angle = 178.0f;
274 int hall = 0;
275 FoldScreenSensorManager::GetInstance().SetGlobalHall(0);
276 FoldScreenSensorManager::GetInstance().SetGlobalAngle(175.0f);
277 sptr<FoldScreenPolicy> foldScreenPolicy = new FoldScreenPolicy();
278 ASSERT_NO_FATAL_FAILURE({mgr.HandleHallChange(angle, hall, foldScreenPolicy);});
279 usleep(500000);
280 }
281
282 /**
283 * @tc.name: HandleHallChangeWhenHallIs0AndAngleMore170ChangedToLess170InWaitting
284 * @tc.desc: DualDisplaySensorFoldStateManager.HandleHallChange
285 * @tc.type: FUNC
286 */
287 HWTEST_F(DualDisplaySensorFoldStateManagerTest,
288 HandleHallChangeWhenHallIs0AndAngleMore170ChangedToLess170InWaitting,
289 TestSize.Level1)
290 {
291 // test hall = 0 angle > 170 and angle change more than 170, report angle when in task
292 std::recursive_mutex mutex;
293 std::shared_ptr<TaskScheduler> screenPowerTaskScheduler =
294 std::make_shared<TaskScheduler>("HandleHallChange");
295 DualDisplaySensorFoldStateManager mgr = DualDisplaySensorFoldStateManager(screenPowerTaskScheduler);
296 float angle = 178.0f;
297 int hall = 0;
298 sptr<FoldScreenPolicy> foldScreenPolicy = new FoldScreenPolicy();
299 mgr.HandleHallChange(angle, hall, foldScreenPolicy);
300 ASSERT_NO_FATAL_FAILURE({mgr.HandleHallChange(150.0f, hall, foldScreenPolicy);});
301 }
302
303 /**
304 * @tc.name: CheckUpdateAngleShouldBeFalseWhenHallIsFold1AndAngleGreaterThan170
305 * @tc.desc: DualDisplaySensorFoldStateManager.CheckUpdateAngle
306 * @tc.type: FUNC
307 */
308 HWTEST_F(DualDisplaySensorFoldStateManagerTest,
309 CheckUpdateAngleShouldBeFalseWhenHallIsFold1AndAngleGreaterThan170,
310 TestSize.Level1)
311 {
312 // test hall = 0 angle > 170 and angle change more than 170, report angle when in task
313 std::recursive_mutex mutex;
314 std::shared_ptr<TaskScheduler> screenPowerTaskScheduler =
315 std::make_shared<TaskScheduler>("HandleHallChange");
316 DualDisplaySensorFoldStateManager mgr = DualDisplaySensorFoldStateManager(screenPowerTaskScheduler);
317 float angle = 188.0f;
318 int hall = HALL_FOLDED_THRESHOLD;
319 ASSERT_NO_FATAL_FAILURE({mgr.CheckUpdateAngle(angle, hall);});
320 ASSERT_FALSE(mgr.CheckUpdateAngle(angle, hall));
321 }
322
323 /**
324 * @tc.name: HandleAngleChangeInTaskDoNothingWhenAngleLessThan0AndHallIs1
325 * @tc.desc: DualDisplaySensorFoldStateManager.HandleAngleChangeInTask
326 * @tc.type: FUNC
327 */
328 HWTEST_F(DualDisplaySensorFoldStateManagerTest,
329 HandleAngleChangeInTaskDoNothingWhenAngleLessThan0AndHallIs1,
330 TestSize.Level1)
331 {
332 // test hall = 0 angle > 170 and angle change more than 170, report angle when in task
333 std::recursive_mutex mutex;
334 std::shared_ptr<TaskScheduler> screenPowerTaskScheduler =
335 std::make_shared<TaskScheduler>("HandleHallChange");
336 sptr<FoldScreenPolicy> foldScreenPolicy = new FoldScreenPolicy();
337 DualDisplaySensorFoldStateManager mgr = DualDisplaySensorFoldStateManager(screenPowerTaskScheduler);
338 float angle = 10.0f;
339 int hall = HALL_THRESHOLD;
340 ASSERT_NO_FATAL_FAILURE({mgr.HandleAngleChangeInTask(angle, hall, foldScreenPolicy);});
341 }
342
343 /**
344 * @tc.name: GetNextFoldState
345 * @tc.desc: GetNextFoldState
346 * @tc.type: FUNC
347 */
348 HWTEST_F(DualDisplaySensorFoldStateManagerTest, GetNextFoldState, TestSize.Level1)
349 {
350 std::shared_ptr<TaskScheduler> screenPowerTaskScheduler = nullptr;
351 DualDisplaySensorFoldStateManager mgr = DualDisplaySensorFoldStateManager(screenPowerTaskScheduler);
352 float angle = 200.0f;
353 int hall = 1;
354 FoldStatus ret = mgr.GetNextFoldState(angle, hall);
355 ASSERT_TRUE(std::isgreaterequal(angle, INWARD_EXPAND_THRESHOLD + ANGLE_BUFFER));
356 ASSERT_EQ(ret, FoldStatus::EXPAND);
357
358 angle = 0.0f;
359 ret = mgr.GetNextFoldState(angle, hall);
360 ASSERT_TRUE(std::islessequal
361 (angle, INWARD_FOLDED_LOWER_THRESHOLD + ANGLE_BUFFER));
362 ASSERT_EQ(ret, FoldStatus::FOLDED);
363
364 mgr.isHallSwitchApp_ = true;
365 angle = 30.0f;
366 ret = mgr.GetNextFoldState(angle, hall);
367 ASSERT_TRUE(std::isgreaterequal(angle, INWARD_FOLDED_UPPER_THRESHOLD + ANGLE_BUFFER));
368 ASSERT_TRUE(std::islessequal(angle, INWARD_HALF_FOLDED_MAX_THRESHOLD + ANGLE_BUFFER));
369 ASSERT_EQ(ret, FoldStatus::HALF_FOLD);
370
371 mgr.isHallSwitchApp_ = false;
372 angle = 120.0f;
373 ret = mgr.GetNextFoldState(angle, hall);
374 ASSERT_TRUE(std::isgreaterequal(angle, INWARD_HALF_FOLDED_MIN_THRESHOLD + ANGLE_BUFFER));
375 ASSERT_TRUE(std::islessequal(angle, INWARD_HALF_FOLDED_MAX_THRESHOLD + ANGLE_BUFFER));
376 ASSERT_EQ(ret, FoldStatus::HALF_FOLD);
377 }
378
379 /**
380 * @tc.name: RegisterApplicationStateObserver
381 * @tc.desc: RegisterApplicationStateObserver
382 * @tc.type: FUNC
383 */
384 HWTEST_F(DualDisplaySensorFoldStateManagerTest, RegisterApplicationStateObserver, TestSize.Level1)
385 {
386 std::shared_ptr<TaskScheduler> screenPowerTaskScheduler = nullptr;
387 DualDisplaySensorFoldStateManager mgr = DualDisplaySensorFoldStateManager(screenPowerTaskScheduler);
388 mgr.RegisterApplicationStateObserver();
389 ASSERT_NE(mgr.applicationStateObserver_, nullptr);
390 }
391 }
392 } // namespace Rosen
393 } // namespace OHOS