1 /*
2 * Copyright (c) 2021-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 "power_mgr_service_native_test.h"
17
18 #ifdef THERMAL_GTEST
19 #define private public
20 #define protected public
21 #endif
22
23 #include <csignal>
24 #include <iostream>
25
26 #ifdef HAS_MULTIMODALINPUT_INPUT_PART
27 #include "key_event.h"
28 #include "pointer_event.h"
29 #endif
30 #include "power_common.h"
31 #include "power_mgr_service.h"
32 #include "setting_helper.h"
33 using namespace testing::ext;
34 using namespace OHOS::PowerMgr;
35 using namespace OHOS;
36 using namespace std;
37
38 namespace {
39 constexpr int32_t TIMEOUTMS = 7;
40 constexpr int64_t CALLTIMEMS = 1;
41 constexpr int64_t SUSCALLTIMEMS = 3;
42 constexpr pid_t PID = 1;
43 constexpr pid_t UID = 1;
44 constexpr int32_t UNCANCELID = -1;
45 constexpr int32_t INVALID_CODE = -1;
46 constexpr int32_t TRY_TIMES = 2;
47 sptr<PowerMgrService> g_pmsTest;
48 } // namespace
49
SetUp()50 void PowerMgrServiceNativeTest::SetUp()
51 {
52 g_pmsTest = DelayedSpSingleton<PowerMgrService>::GetInstance();
53 EXPECT_TRUE(g_pmsTest != nullptr) << "PowerMgrService02 fail to get PowerMgrService";
54 g_pmsTest->OnStart();
55
56 auto stateMachine = std::make_shared<PowerStateMachine>(g_pmsTest);
57 EXPECT_TRUE(stateMachine->Init());
58 UserActivityType userActivityType = UserActivityType::USER_ACTIVITY_TYPE_ACCESSIBILITY;
59 stateMachine->RefreshActivityInner(PID, CALLTIMEMS, userActivityType, true);
60 auto runningLockMgr = std::make_shared<RunningLockMgr>(g_pmsTest);
61 EXPECT_TRUE(runningLockMgr->Init());
62 sptr<IRemoteObject> remoteObj = new RunningLockTokenStub();
63 RunningLockParam runningLockParam {0,
64 "runninglockNativeTest1", "", RunningLockType::RUNNINGLOCK_SCREEN, TIMEOUTMS, PID, UID};
65 EXPECT_TRUE(runningLockMgr->CreateRunningLock(remoteObj, runningLockParam) != nullptr);
66 runningLockMgr->Lock(remoteObj);
67 runningLockMgr->UnLock(remoteObj);
68 EXPECT_FALSE(runningLockMgr->ReleaseLock(remoteObj));
69 }
70
TearDown()71 void PowerMgrServiceNativeTest::TearDown()
72 {
73 g_pmsTest->OnStop();
74 }
75
OnPowerStateChanged(PowerState state)76 void PowerStateTestCallback::OnPowerStateChanged(PowerState state)
77 {
78 POWER_HILOGI(
79 LABEL_TEST, "PowerStateTestCallback::OnPowerStateChanged state = %{public}u.", static_cast<uint32_t>(state));
80 }
81
82 namespace {
83 /**
84 * @tc.name: PowerMgrServiceNative001
85 * @tc.desc: test init in powerMgrService
86 * @tc.type: FUNC
87 */
88 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNative001, TestSize.Level1)
89 {
90 GTEST_LOG_(INFO) << "PowerMgrServiceNative001 start.";
91 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNative001 function start!");
92 g_pmsTest->HallSensorSubscriberInit();
93 g_pmsTest->HallSensorSubscriberCancel();
94 #ifdef HAS_MULTIMODALINPUT_INPUT_PART
95 int32_t keyCode = OHOS::MMI::KeyEvent::KEYCODE_F1;
96 g_pmsTest->HandleKeyEvent(keyCode);
97 int32_t type = OHOS::MMI::PointerEvent::SOURCE_TYPE_MOUSE;
98 g_pmsTest->HandlePointEvent(type);
99
100 EXPECT_EQ(g_pmsTest->OverrideScreenOffTime(TIMEOUTMS), PowerErrors::ERR_OK);
101 EXPECT_EQ(g_pmsTest->RestoreScreenOffTime(), PowerErrors::ERR_OK);
102
103 g_pmsTest->doubleClickId_ = UNCANCELID;
104 g_pmsTest->monitorId_ = UNCANCELID;
105 #endif
106 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNative001 function end!");
107 GTEST_LOG_(INFO) << "PowerMgrServiceNative001 end.";
108 }
109
110 /**
111 * @tc.name: PowerMgrServiceNative002
112 * @tc.desc: test handleKeyEvent in powerMgrService
113 * @tc.type: FUNC
114 */
115 #ifdef HAS_MULTIMODALINPUT_INPUT_PART
116 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNative002, TestSize.Level1)
117 {
118 GTEST_LOG_(INFO) << "PowerMgrServiceNative002 start.";
119 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNative002 function start!");
120 int32_t keyCode = OHOS::MMI::KeyEvent::KEYCODE_F1;
121 g_pmsTest->HandleKeyEvent(keyCode);
122 keyCode = OHOS::MMI::KeyEvent::KEYCODE_F2;
123 g_pmsTest->HandleKeyEvent(keyCode);
124 keyCode = OHOS::MMI::KeyEvent::KEYCODE_VIRTUAL_MULTITASK;
125 g_pmsTest->HandleKeyEvent(keyCode);
126 keyCode = OHOS::MMI::KeyEvent::KEYCODE_WEAR_1;
127 g_pmsTest->HandleKeyEvent(keyCode);
128 int32_t type = OHOS::MMI::PointerEvent::SOURCE_TYPE_MOUSE;
129 g_pmsTest->HandlePointEvent(type);
130 type = OHOS::MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN;
131 g_pmsTest->HandlePointEvent(type);
132
133 EXPECT_TRUE(g_pmsTest->ShutDownDevice(SHUTDOWN_FAST_REASON) == PowerErrors::ERR_OK);
134 SuspendDeviceType reasonSDT = SuspendDeviceType::SUSPEND_DEVICE_REASON_DEVICE_ADMIN;
135 EXPECT_TRUE(g_pmsTest->SuspendDevice(SUSCALLTIMEMS, reasonSDT, false) == PowerErrors::ERR_OK);
136 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNative002 function end!");
137 GTEST_LOG_(INFO) << "PowerMgrServiceNative002 end.";
138 }
139 #endif
140
141 /**
142 * @tc.name: PowerMgrServiceNative003
143 * @tc.desc: test pickup register
144 * @tc.type: FUNC
145 */
146 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNative003, TestSize.Level1)
147 {
148 GTEST_LOG_(INFO) << "PowerMgrServiceNative003 start.";
149 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNative003 function start!");
150 #ifdef POWER_PICKUP_ENABLE
151 g_pmsTest->RegisterSettingWakeupPickupGestureObserver();
152 g_pmsTest->RegisterSettingWakeupPickupGestureObserver();
153 EXPECT_TRUE(SettingHelper::pickUpObserver_ != nullptr);
154 SettingHelper::UnregisterSettingWakeupPickupObserver();
155 SettingHelper::UnregisterSettingWakeupPickupObserver();
156 EXPECT_TRUE(SettingHelper::pickUpObserver_ == nullptr);
157 #endif
158 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNative003 function end!");
159 GTEST_LOG_(INFO) << "PowerMgrServiceNative003 end.";
160 }
161
162 /**
163 * @tc.name: PowerMgrServiceNative004
164 * @tc.desc: test autobrightness register
165 * @tc.type: FUNC
166 */
167 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNative004, TestSize.Level1)
168 {
169 GTEST_LOG_(INFO) << "PowerMgrServiceNative004 start.";
170 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNative004 function start!");
171 shared_ptr<PowerModeModule> powerModeModuleTest = make_shared<PowerModeModule>();
172 EXPECT_TRUE(powerModeModuleTest != nullptr);
173 auto flag = SettingHelper::IsAutoAdjustBrightnessSettingValid();
174 powerModeModuleTest->RegisterAutoAdjustBrightnessObserver();
175 SettingHelper::SetSettingAutoAdjustBrightness(SettingHelper::SwitchStatus::INVALID);
176 auto ret = SettingHelper::GetSettingAutoAdjustBrightness(INVALID_CODE);
177 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNative004 function end!");
178 GTEST_LOG_(INFO) << "PowerMgrServiceNative004 end.";
179 }
180
181 /**
182 * @tc.name: PowerMgrServiceNative005
183 * @tc.desc: test brightness register
184 * @tc.type: FUNC
185 */
186 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNative005, TestSize.Level1)
187 {
188 GTEST_LOG_(INFO) << "PowerMgrServiceNative005 start.";
189 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNative005 function start!");
190 shared_ptr<PowerModeModule> powerModeModuleTest = make_shared<PowerModeModule>();
191 EXPECT_TRUE(powerModeModuleTest != nullptr);
192 powerModeModuleTest->RegisterAutoAdjustBrightnessObserver();
193 auto flag = SettingHelper::IsBrightnessSettingValid();
194 SettingHelper::SetSettingBrightness(INVALID_CODE);
195 auto ret = SettingHelper::GetSettingAutoAdjustBrightness(INVALID_CODE);
196 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNative005 function end!");
197 GTEST_LOG_(INFO) << "PowerMgrServiceNative005 end.";
198 }
199
200 /**
201 * @tc.name: PowerMgrServiceNative006
202 * @tc.desc: test vibrateState register
203 * @tc.type: FUNC
204 */
205 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNative006, TestSize.Level1)
206 {
207 GTEST_LOG_(INFO) << "PowerMgrServiceNative006 start.";
208 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNative006 function start!");
209 shared_ptr<PowerModeModule> powerModeModuleTest = make_shared<PowerModeModule>();
210 EXPECT_TRUE(powerModeModuleTest != nullptr);
211 powerModeModuleTest->RegisterVibrateStateObserver();
212 auto flag = SettingHelper::IsVibrationSettingValid();
213 SettingHelper::SetSettingVibration(SettingHelper::SwitchStatus::INVALID);
214 auto ret = SettingHelper::GetSettingVibration(INVALID_CODE);
215 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNative006 function end!");
216 GTEST_LOG_(INFO) << "PowerMgrServiceNative006 end.";
217 }
218
219
220 /**
221 * @tc.name: PowerMgrServiceNative007
222 * @tc.desc: test autoWindowRotation register
223 * @tc.type: FUNC
224 */
225 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNative007, TestSize.Level1)
226 {
227 GTEST_LOG_(INFO) << "PowerMgrServiceNative007 start.";
228 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNative007 function start!");
229 shared_ptr<PowerModeModule> powerModeModuleTest = make_shared<PowerModeModule>();
230 EXPECT_TRUE(powerModeModuleTest != nullptr);
231 powerModeModuleTest->RegisterAutoWindowRotationObserver();
232 auto flag = SettingHelper::IsWindowRotationSettingValid();
233 SettingHelper::SetSettingWindowRotation(SettingHelper::SwitchStatus::INVALID);
234 auto ret = SettingHelper::GetSettingWindowRotation(INVALID_CODE);
235 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNative007 function end!");
236 GTEST_LOG_(INFO) << "PowerMgrServiceNative007 end.";
237 }
238
239 /**
240 * @tc.name: PowerMgrServiceNative008
241 * @tc.desc: test intellVoiceSetting register
242 * @tc.type: FUNC
243 */
244 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNative008, TestSize.Level1)
245 {
246 GTEST_LOG_(INFO) << "PowerMgrServiceNative008 start.";
247 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNative008 function start!");
248 shared_ptr<PowerModeModule> powerModeModuleTest = make_shared<PowerModeModule>();
249 EXPECT_TRUE(powerModeModuleTest != nullptr);
250 powerModeModuleTest->RegisterIntellVoiceObserver();
251 auto flag = SettingHelper::IsIntellVoiceSettingValid();
252 SettingHelper::SetSettingIntellVoice(SettingHelper::SwitchStatus::INVALID);
253 auto ret = SettingHelper::GetSettingIntellVoice(INVALID_CODE);
254 powerModeModuleTest->UnregisterSaveModeObserver();
255 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNative008 function end!");
256 GTEST_LOG_(INFO) << "PowerMgrServiceNative008 end.";
257 }
258
259 /**
260 * @tc.name: PowerMgrServiceNative009
261 * @tc.desc: test settingPowerMode register
262 * @tc.type: FUNC
263 */
264 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNative009, TestSize.Level1)
265 {
266 GTEST_LOG_(INFO) << "PowerMgrServiceNative009 start.";
267 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNative009 function start!");
268 g_pmsTest->RegisterSettingPowerModeObservers();
269 g_pmsTest->RegisterSettingPowerModeObservers();
270 EXPECT_TRUE(SettingHelper::powerModeObserver_ != nullptr);
271 SettingHelper::SaveCurrentMode(INVALID_CODE);
272 SettingHelper::UnRegisterSettingPowerModeObserver();
273 EXPECT_TRUE(SettingHelper::powerModeObserver_ == nullptr);
274 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNative009 function end!");
275 GTEST_LOG_(INFO) << "PowerMgrServiceNative009 end.";
276 }
277
278 /**
279 * @tc.name: PowerMgrServiceNative010
280 * @tc.desc: test settingWakeUpLid register
281 * @tc.type: FUNC
282 */
283 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNative010, TestSize.Level1)
284 {
285 GTEST_LOG_(INFO) << "PowerMgrServiceNative010 start.";
286 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNative010 function start!");
287 g_pmsTest->RegisterSettingWakeUpLidObserver();
288 SettingHelper::SetSettingWakeupLid(true);
289 bool ret = SettingHelper::GetSettingWakeupLid();
290 SettingHelper::UnRegisterSettingWakeupLidObserver();
291 EXPECT_TRUE(SettingHelper::lidObserver_ == nullptr);
292 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNative010 function end!");
293 GTEST_LOG_(INFO) << "PowerMgrServiceNative010 end.";
294 }
295
296 /**
297 * @tc.name: PowerMgrServiceNative011
298 * @tc.desc: test RegisterSettingWakeupDoubleClickObservers
299 * @tc.type: FUNC
300 */
301 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNative011, TestSize.Level1)
302 {
303 GTEST_LOG_(INFO) << "PowerMgrServiceNative011 start.";
304 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNative011 function start!");
305 #ifdef POWER_DOUBLECLICK_ENABLE
306 g_pmsTest->RegisterSettingWakeupDoubleClickObservers();
307 g_pmsTest->RegisterSettingWakeupDoubleClickObservers();
308 SettingHelper::IsWakeupDoubleSettingValid();
309 SettingHelper::UnregisterSettingWakeupDoubleObserver();
310 SettingHelper::UnregisterSettingWakeupDoubleObserver();
311 EXPECT_TRUE(SettingHelper::doubleClickObserver_ == nullptr);
312 #endif
313 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNative011 function end!");
314 GTEST_LOG_(INFO) << "PowerMgrServiceNative011 end.";
315 }
316
317 /**
318 * @tc.name: PowerMgrServiceNative012
319 * @tc.desc: test RegisterMovementCallback
320 * @tc.type: FUNC
321 */
322 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNative012, TestSize.Level1)
323 {
324 GTEST_LOG_(INFO) << "PowerMgrServiceNative012 start.";
325 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNative012 function start!");
326 #ifdef MSDP_MOVEMENT_ENABLE
327 auto stateMachine = std::make_shared<PowerStateMachine>(g_pmsTest);
328 g_pmsTest->RegisterMovementCallback();
329 g_pmsTest->UnRegisterMovementCallback();
330 g_pmsTest->ResetMovementState();
331 bool ret = stateMachine->IsMovementStateOn();
332 EXPECT_TRUE(ret == false);
333 #endif
334 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNative012 function end!");
335 GTEST_LOG_(INFO) << "PowerMgrServiceNative012 end.";
336 }
337
338 /**
339 * @tc.name: PowerMgrServiceNative013
340 * @tc.desc: test RegisterExternalScreenListener
341 * @tc.type: FUNC
342 */
343 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNative013, TestSize.Level1)
344 {
345 GTEST_LOG_(INFO) << "PowerMgrServiceNative013 start.";
346 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNative013 function start!");
347 #ifdef POWER_MANAGER_ENABLE_EXTERNAL_SCREEN_MANAGEMENT
348 g_pmsTest->RegisterExternalScreenListener();
349 EXPECT_TRUE(g_pmsTest->externalScreenListener_ != nullptr);
350 g_pmsTest->UnRegisterExternalScreenListener();
351 EXPECT_TRUE(g_pmsTest->externalScreenListener_ == nullptr);
352 #endif
353 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNative013 function end!");
354 GTEST_LOG_(INFO) << "PowerMgrServiceNative013 end.";
355 }
356
357 /**
358 * @tc.name: PowerMgrServiceNative014
359 * @tc.desc: test ExternalScreenListener OnConnect
360 * @tc.type: FUNC
361 */
362 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNative014, TestSize.Level1)
363 {
364 GTEST_LOG_(INFO) << "PowerMgrServiceNative014 start.";
365 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNative014 function start!");
366 #ifdef POWER_MANAGER_ENABLE_EXTERNAL_SCREEN_MANAGEMENT
367 g_pmsTest->SuspendControllerInit();
368 g_pmsTest->WakeupControllerInit();
369 // Register screen listener
370 g_pmsTest->RegisterExternalScreenListener();
371 EXPECT_TRUE(g_pmsTest->externalScreenListener_ != nullptr);
372
373 auto powerStateMachine = g_pmsTest->GetPowerStateMachine();
374 constexpr uint64_t SCREEN_A_ID = 10001;
375 // Mock open switch to wakeup deivce
376 // case 1: isSwitchOpen:true, isScreenOn:true
377 powerStateMachine->SetSwitchState(true);
378 g_pmsTest->WakeupDevice(
379 static_cast<int64_t>(time(nullptr)), WakeupDeviceType::WAKEUP_DEVICE_SWITCH, "PowerMgrServiceNative014");
380 EXPECT_TRUE(powerStateMachine->IsScreenOn());
381 g_pmsTest->externalScreenListener_->OnConnect(SCREEN_A_ID);
382 EXPECT_TRUE(powerStateMachine->IsScreenOn());
383 powerStateMachine->SetExternalScreenNumber(0);
384
385 // case 2: isSwitchOpen:true, isScreenOn:false
386 g_pmsTest->SuspendDevice(GetTickCount(), SuspendDevice::SUSPEND_DEVICE_REASON_POWER_KEY, false);
387 EXPECT_FALSE(powerStateMachine->IsScreenOn());
388 g_pmsTest->externalScreenListener_->OnConnect(SCREEN_A_ID);
389 EXPECT_TRUE(powerStateMachine->IsScreenOn());
390 powerStateMachine->SetExternalScreenNumber(0);
391
392 // case 3: isSwitchOpen:false, isScreenOn:false
393 powerStateMachine->SetSwitchState(false);
394 g_pmsTest->SuspendDevice(GetTickCount(), SuspendDevice::SUSPEND_DEVICE_REASON_SWITCH, false);
395 EXPECT_FALSE(powerStateMachine->IsScreenOn());
396 g_pmsTest->externalScreenListener_->OnConnect(SCREEN_A_ID);
397 EXPECT_FALSE(powerStateMachine->IsScreenOn());
398 powerStateMachine->SetExternalScreenNumber(0);
399
400 // Unregister screen listener
401 g_pmsTest->UnRegisterExternalScreenListener();
402 EXPECT_TRUE(g_pmsTest->externalScreenListener_ == nullptr);
403 #endif
404 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNative014 function end!");
405 GTEST_LOG_(INFO) << "PowerMgrServiceNative014 end.";
406 }
407
408 /**
409 * @tc.name: PowerMgrServiceNative015
410 * @tc.desc: test ExternalScreenListener OnDisconnect
411 * @tc.type: FUNC
412 */
413 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNative015, TestSize.Level1)
414 {
415 GTEST_LOG_(INFO) << "PowerMgrServiceNative015 start.";
416 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNative015 function start!");
417 #ifdef POWER_MANAGER_ENABLE_EXTERNAL_SCREEN_MANAGEMENT
418 g_pmsTest->SuspendControllerInit();
419 g_pmsTest->WakeupControllerInit();
420 // Register screen listener
421 g_pmsTest->RegisterExternalScreenListener();
422 EXPECT_TRUE(g_pmsTest->externalScreenListener_ != nullptr);
423
424 auto powerStateMachine = g_pmsTest->GetPowerStateMachine();
425 constexpr uint64_t SCREEN_A_ID = 10001;
426 // Mock open switch to wakeup deivce
427 // case 1: isSwitchOpen:true, isScreenOn:true
428 powerStateMachine->SetSwitchState(true);
429 g_pmsTest->WakeupDevice(
430 static_cast<int64_t>(time(nullptr)), WakeupDeviceType::WAKEUP_DEVICE_SWITCH, "PowerMgrServiceNative015");
431 powerStateMachine->SetExternalScreenNumber(1);
432 EXPECT_TRUE(powerStateMachine->IsScreenOn());
433 g_pmsTest->externalScreenListener_->OnDisconnect(SCREEN_A_ID);
434 EXPECT_TRUE(powerStateMachine->IsScreenOn());
435
436 // case 2: isSwitchOpen:true, isScreenOn:false
437 g_pmsTest->SuspendDevice(GetTickCount(), SuspendDevice::SUSPEND_DEVICE_REASON_POWER_KEY, false);
438 EXPECT_FALSE(powerStateMachine->IsScreenOn());
439 powerStateMachine->SetExternalScreenNumber(1);
440 g_pmsTest->externalScreenListener_->OnDisconnect(SCREEN_A_ID);
441 EXPECT_FALSE(powerStateMachine->IsScreenOn());
442
443 // case 3: isSwitchOpen:false, isScreenOn:true, and there's only 1 external screen
444 // Mock open switch to wakeup deivce
445 powerStateMachine->SetSwitchState(true);
446 g_service->WakeupDevice(
447 static_cast<int64_t>(time(nullptr)), WakeupDeviceType::WAKEUP_DEVICE_SWITCH, "PowerMgrServiceNative015");
448 EXPECT_TRUE(powerStateMachine->IsScreenOn());
449 powerStateMachine->SetExternalScreenNumber(1);
450 // Mock close switch to suspend device when switch's action is configured as ACTION_NONE
451 powerStateMachine->SetSwitchState(false);
452 auto suspendController = g_service->GetSuspendController();
453 suspendController->ControlListener(SuspendDeviceType::SUSPEND_DEVICE_REASON_SWITCH, SuspendAction::ACTION_NONE, 0);
454 EXPECT_TRUE(powerStateMachine->IsScreenOn());
455 g_pmsTest->externalScreenListener_->OnDisconnect(SCREEN_A_ID);
456 EXPECT_FALSE(powerStateMachine->IsScreenOn());
457
458 // Unregister screen listener
459 g_pmsTest->UnRegisterExternalScreenListener();
460 EXPECT_TRUE(g_pmsTest->externalScreenListener_ == nullptr);
461 #endif
462 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNative015 function end!");
463 GTEST_LOG_(INFO) << "PowerMgrServiceNative015 end.";
464 }
465
466 /**
467 * @tc.name: PowerMgrServiceNative016
468 * @tc.desc: test RegisterSettingDuringCallObservers
469 * @tc.type: FUNC
470 */
471 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNative016, TestSize.Level1)
472 {
473 GTEST_LOG_(INFO) << "PowerMgrServiceNative016 start.";
474 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNative016 function start!");
475 g_pmsTest->isDuringCallStateEnable_ = true;
476 EXPECT_TRUE(g_pmsTest->IsDuringCallStateEnable());
477 g_pmsTest->RegisterSettingDuringCallObservers();
478 EXPECT_TRUE(SettingHelper::duringCallObserver_ != nullptr);
479 g_pmsTest->RegisterSettingDuringCallObservers();
480 EXPECT_TRUE(SettingHelper::duringCallObserver_ != nullptr);
481 SettingHelper::UnRegisterSettingDuringCallObserver();
482 EXPECT_TRUE(SettingHelper::duringCallObserver_ == nullptr);
483 SettingHelper::UnRegisterSettingDuringCallObserver();
484 EXPECT_TRUE(SettingHelper::duringCallObserver_ == nullptr);
485 g_pmsTest->DuringCallSettingUpdateFunc(SettingHelper::SETTING_DURING_CALL_STATE_KEY);
486 auto stateMachine = g_pmsTest->GetPowerStateMachine();
487 EXPECT_TRUE(stateMachine != nullptr && !stateMachine->isDuringCall_);
488 g_pmsTest->powerStateMachine_ = nullptr;
489 EXPECT_TRUE(g_pmsTest->GetPowerStateMachine() == nullptr);
490 g_pmsTest->DuringCallSettingUpdateFunc(SettingHelper::SETTING_DURING_CALL_STATE_KEY);
491 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNative016 function end!");
492 GTEST_LOG_(INFO) << "PowerMgrServiceNative016 end.";
493 }
494
495 /**
496 * @tc.name: PowerMgrServiceNative017
497 * @tc.desc: test RegisterSettingDuringCallObservers
498 * @tc.type: FUNC
499 */
500 HWTEST_F(PowerMgrServiceNativeTest, PowerMgrServiceNative017, TestSize.Level1)
501 {
502 GTEST_LOG_(INFO) << "PowerMgrServiceNative017 start.";
503 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNative017 function start!");
504 g_pmsTest->isDuringCallStateEnable_ = false;
505 EXPECT_FALSE(g_pmsTest->IsDuringCallStateEnable());
506 g_pmsTest->RegisterSettingDuringCallObservers();
507 EXPECT_TRUE(SettingHelper::duringCallObserver_ == nullptr);
508 SettingHelper::UnRegisterSettingDuringCallObserver();
509 EXPECT_TRUE(SettingHelper::duringCallObserver_ == nullptr);
510 POWER_HILOGI(LABEL_TEST, "PowerMgrServiceNative017 function end!");
511 GTEST_LOG_(INFO) << "PowerMgrServiceNative017 end.";
512 }
513 } // namespace
514