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 "native_power_state_machine_test.h"
17
18 #include <ipc_skeleton.h>
19
20 #include "actions/irunning_lock_action.h"
21
22 using namespace testing::ext;
23 using namespace OHOS::PowerMgr;
24 using namespace OHOS;
25 using namespace std;
26
SetUpTestCase()27 void NativePowerStateMachineTest::SetUpTestCase() {}
28
OnPowerStateChanged(PowerState state)29 void PowerStateTest1Callback::OnPowerStateChanged(PowerState state)
30 {
31 POWER_HILOGI(
32 LABEL_TEST, "PowerStateTest1Callback::OnPowerStateChanged state = %{public}u.", static_cast<uint32_t>(state));
33 }
34
OnAsyncPowerStateChanged(PowerState state)35 void PowerStateTest1Callback::OnAsyncPowerStateChanged(PowerState state)
36 {
37 POWER_HILOGI(LABEL_TEST, "PowerStateTest1Callback::OnAsyncPowerStateChanged state = %{public}u.",
38 static_cast<uint32_t>(state));
39 }
40
OnPowerStateChanged(PowerState state)41 void PowerStateTest2Callback::OnPowerStateChanged(PowerState state)
42 {
43 POWER_HILOGI(
44 LABEL_TEST, "PowerStateTest2Callback::OnPowerStateChanged state = %{public}u.", static_cast<uint32_t>(state));
45 }
46
OnAsyncPowerStateChanged(PowerState state)47 void PowerStateTest2Callback::OnAsyncPowerStateChanged(PowerState state)
48 {
49 POWER_HILOGI(LABEL_TEST, "PowerStateTest2Callback::OnAsyncPowerStateChanged state = %{public}u.",
50 static_cast<uint32_t>(state));
51 }
52
53 namespace {
TransitResultToStateChangeReason(StateChangeReason trigger)54 TransitResult TransitResultToStateChangeReason(StateChangeReason trigger)
55 {
56 return TransitResult::ALREADY_IN_STATE;
57 }
58
59 /**
60 * @tc.name: NativePowerStateMachine001
61 * @tc.desc: test init in powerStateMachine
62 * @tc.type: FUNC
63 */
64 HWTEST_F(NativePowerStateMachineTest, NativePowerStateMachine001, TestSize.Level0)
65 {
66 GTEST_LOG_(INFO) << "NativePowerStateMachine001: Suspend Device start.";
67 POWER_HILOGI(LABEL_TEST, "NativePowerStateMachine001::fun is start!");
68 auto pmsTest = DelayedSpSingleton<PowerMgrService>::GetInstance();
69 pmsTest->OnStart();
70 auto stateMachine = std::make_shared<PowerStateMachine>(pmsTest);
71 EXPECT_TRUE(stateMachine->Init());
72 EXPECT_TRUE(stateMachine->Init());
73 stateMachine->InitState();
74 EXPECT_FALSE(stateMachine->CheckRefreshTime());
75 EXPECT_TRUE(stateMachine->CheckRefreshTime());
76 EXPECT_FALSE(stateMachine->RestoreScreenOffTimeInner());
77 EXPECT_TRUE(stateMachine->OverrideScreenOffTimeInner(TIMEOUT));
78 EXPECT_TRUE(stateMachine->OverrideScreenOffTimeInner(TIMEOUT));
79 stateMachine->SetDisplayOffTime(TIME, true);
80 stateMachine->ResetInactiveTimer();
81 std::string result;
82 stateMachine->DumpInfo(result);
83 EXPECT_TRUE(stateMachine->RestoreScreenOffTimeInner());
84 stateMachine->onWakeup();
85 stateMachine->SetSleepTime(TIME);
86 stateMachine->ResetSleepTimer();
87
88 bool ret = stateMachine->SetState(PowerState::UNKNOWN, StateChangeReason::STATE_CHANGE_REASON_BATTERY, true);
89 EXPECT_FALSE(ret);
90 stateMachine->SetDisplaySuspend(true);
91 stateMachine->SetDisplaySuspend(false);
92
93 POWER_HILOGI(LABEL_TEST, "NativePowerStateMachine001::fun is end!");
94 GTEST_LOG_(INFO) << "NativePowerStateMachine001: Suspend Device end.";
95 }
96
97 /**
98 * @tc.name: NativePowerStateMachine002
99 * @tc.desc: test callback in powerStateMachine
100 * @tc.type: FUNC
101 */
102 HWTEST_F(NativePowerStateMachineTest, NativePowerStateMachine002, TestSize.Level0)
103 {
104 GTEST_LOG_(INFO) << "NativePowerStateMachine002: Suspend Device start.";
105 POWER_HILOGI(LABEL_TEST, "NativePowerStateMachine002::fun is start!");
106 auto pmsTest = DelayedSpSingleton<PowerMgrService>::GetInstance();
107 auto stateMachine = std::make_shared<PowerStateMachine>(pmsTest);
108 EXPECT_TRUE(stateMachine->Init());
109 stateMachine->ReceiveScreenEvent(true);
110 stateMachine->ReceiveScreenEvent(false);
111 sptr<IPowerStateCallback> callBackFirst = new PowerStateTest1Callback();
112 stateMachine->RegisterPowerStateCallback(callBackFirst);
113 stateMachine->SetState(PowerState::INACTIVE, StateChangeReason::STATE_CHANGE_REASON_RUNNING_LOCK, true);
114 EXPECT_TRUE(stateMachine->SetState(PowerState::AWAKE, StateChangeReason::STATE_CHANGE_REASON_RUNNING_LOCK, true));
115 stateMachine->UnRegisterPowerStateCallback(callBackFirst);
116 sptr<IPowerStateCallback> callBackSecond = new PowerStateTest2Callback();
117 stateMachine->RegisterPowerStateCallback(callBackSecond);
118 stateMachine->UnRegisterPowerStateCallback(callBackSecond);
119 sptr<IPowerStateCallback> callBackThird = nullptr;
120 stateMachine->RegisterPowerStateCallback(callBackThird);
121 stateMachine->UnRegisterPowerStateCallback(callBackThird);
122 stateMachine->SetState(PowerState::INACTIVE, StateChangeReason::STATE_CHANGE_REASON_TIMEOUT, true);
123 EXPECT_TRUE(stateMachine->SetState(PowerState::AWAKE, StateChangeReason::STATE_CHANGE_REASON_RUNNING_LOCK, true));
124
125 sptr<IPowerStateCallback> callBackFourth = new PowerStateTest1Callback();
126 stateMachine->RegisterPowerStateCallback(callBackFourth, false);
127 stateMachine->SetState(PowerState::INACTIVE, StateChangeReason::STATE_CHANGE_REASON_RUNNING_LOCK, true);
128 EXPECT_TRUE(stateMachine->SetState(PowerState::AWAKE, StateChangeReason::STATE_CHANGE_REASON_RUNNING_LOCK, true));
129 stateMachine->UnRegisterPowerStateCallback(callBackFourth);
130 sptr<IPowerStateCallback> callBackFifth = new PowerStateTest2Callback();
131 sptr<IPowerStateCallback> callBackSixth = nullptr;
132 stateMachine->RegisterPowerStateCallback(callBackFifth, false);
133 stateMachine->RegisterPowerStateCallback(callBackSixth, false);
134 stateMachine->SetState(PowerState::INACTIVE, StateChangeReason::STATE_CHANGE_REASON_TIMEOUT, true);
135 EXPECT_TRUE(stateMachine->SetState(PowerState::AWAKE, StateChangeReason::STATE_CHANGE_REASON_RUNNING_LOCK, true));
136 stateMachine->UnRegisterPowerStateCallback(callBackFifth);
137 stateMachine->UnRegisterPowerStateCallback(callBackSixth);
138 POWER_HILOGI(LABEL_TEST, "NativePowerStateMachine002::fun is end!");
139 GTEST_LOG_(INFO) << "NativePowerStateMachine002: Suspend Device end.";
140 }
141
142 /**
143 * @tc.name: NativePowerStateMachine003
144 * @tc.desc: test suspendDeviceInner in powerStateMachine
145 * @tc.type: FUNC
146 */
147 HWTEST_F(NativePowerStateMachineTest, NativePowerStateMachine003, TestSize.Level0)
148 {
149 GTEST_LOG_(INFO) << "NativePowerStateMachine003: Suspend Device start.";
150 POWER_HILOGI(LABEL_TEST, "NativePowerStateMachine003::fun is start!");
151 auto pmsTest = DelayedSpSingleton<PowerMgrService>::GetInstance();
152 pmsTest->OnStart();
153 auto stateMachine = std::make_shared<PowerStateMachine>(pmsTest);
154 EXPECT_TRUE(stateMachine->Init());
155 int32_t powermsEvent = PowerStateMachine::CHECK_USER_ACTIVITY_OFF_TIMEOUT_MSG;
156 stateMachine->SetDelayTimer(stateMachine->GetDisplayOffTime() / THREE, powermsEvent);
157
158 SuspendDeviceType suspendDeviceType = SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION;
159 stateMachine->SuspendDeviceInner(PID, CALLTIMEMS, suspendDeviceType, true, false);
160 suspendDeviceType = SuspendDeviceType::SUSPEND_DEVICE_REASON_DEVICE_ADMIN;
161 stateMachine->SuspendDeviceInner(PID, CALLTIMEMS, suspendDeviceType, true, true);
162 suspendDeviceType = SuspendDeviceType::SUSPEND_DEVICE_REASON_TIMEOUT;
163 stateMachine->SuspendDeviceInner(PID, CALLTIMEMS, suspendDeviceType, true, false);
164 suspendDeviceType = SuspendDeviceType::SUSPEND_DEVICE_REASON_LID;
165 stateMachine->SuspendDeviceInner(PID, CALLTIMEMS, suspendDeviceType, true, false);
166 suspendDeviceType = SuspendDeviceType::SUSPEND_DEVICE_REASON_SLEEP_KEY;
167 stateMachine->SuspendDeviceInner(PID, CALLTIMEMS, suspendDeviceType, true, false);
168 suspendDeviceType = SuspendDeviceType::SUSPEND_DEVICE_REASON_HDMI;
169 stateMachine->SuspendDeviceInner(PID, CALLTIMEMS, suspendDeviceType, true, false);
170 suspendDeviceType = SuspendDeviceType::SUSPEND_DEVICE_REASON_ACCESSIBILITY;
171 stateMachine->SuspendDeviceInner(PID, CALLTIMEMS, suspendDeviceType, true, false);
172 suspendDeviceType = static_cast<SuspendDeviceType>(MAXTYPE);
173 stateMachine->SuspendDeviceInner(PID, CALLTIMEMS, suspendDeviceType, true, false);
174
175 stateMachine->RegisterDisplayOffTimeObserver();
176 stateMachine->RegisterDisplayOffTimeObserver();
177 stateMachine->UnregisterDisplayOffTimeObserver();
178 stateMachine->UnregisterDisplayOffTimeObserver();
179
180 std::string result;
181 stateMachine->DumpInfo(result);
182
183 POWER_HILOGI(LABEL_TEST, "NativePowerStateMachine003::fun is end!");
184 GTEST_LOG_(INFO) << "NativePowerStateMachine003: Suspend Device end.";
185 }
186
187 /**
188 * @tc.name: NativePowerStateMachine004
189 * @tc.desc: test refreshActivityInner and wakeupDeviceInner in powerMgrService
190 * @tc.type: FUNC
191 */
192 HWTEST_F(NativePowerStateMachineTest, NativePowerStateMachine004, TestSize.Level0)
193 {
194 GTEST_LOG_(INFO) << "NativePowerStateMachine004: Suspend Device start.";
195 POWER_HILOGI(LABEL_TEST, "NativePowerStateMachine004::fun is start!");
196 auto pmsTest = DelayedSpSingleton<PowerMgrService>::GetInstance();
197 UserActivityType userActivityType = UserActivityType::USER_ACTIVITY_TYPE_OTHER;
198 auto stateMachine = std::make_shared<PowerStateMachine>(pmsTest);
199 EXPECT_TRUE(stateMachine->Init());
200 stateMachine->RefreshActivityInner(PID, CALLTIMEMS, userActivityType, true);
201 stateMachine->RefreshActivityInner(PID, CALLTIMEMS, static_cast<UserActivityType>(MAXTYPE), true);
202 bool ret = stateMachine->SetState(PowerState::AWAKE, StateChangeReason::STATE_CHANGE_REASON_RUNNING_LOCK, true);
203 EXPECT_TRUE(ret);
204 stateMachine->RefreshActivityInner(PID, CALLTIMEMS, userActivityType, true);
205 userActivityType = UserActivityType::USER_ACTIVITY_TYPE_TOUCH;
206 stateMachine->RefreshActivityInner(PID, CALLTIMEMS, userActivityType, true);
207 userActivityType = UserActivityType::USER_ACTIVITY_TYPE_SOFTWARE;
208 stateMachine->RefreshActivityInner(PID, CALLTIMEMS, userActivityType, true);
209 userActivityType = UserActivityType::USER_ACTIVITY_TYPE_BUTTON;
210 stateMachine->RefreshActivityInner(PID, CALLTIMEMS, userActivityType, true);
211
212 WakeupDeviceType type = WakeupDeviceType::WAKEUP_DEVICE_APPLICATION;
213 stateMachine->WakeupDeviceInner(PID, CALLTIMEMS, type, "7", "7");
214 type = WakeupDeviceType::WAKEUP_DEVICE_POWER_BUTTON;
215 stateMachine->WakeupDeviceInner(PID, CALLTIMEMS, type, "7", "7");
216 type = WakeupDeviceType::WAKEUP_DEVICE_WAKE_KEY;
217 stateMachine->WakeupDeviceInner(PID, CALLTIMEMS, type, "7", "7");
218 type = WakeupDeviceType::WAKEUP_DEVICE_HDMI;
219 stateMachine->WakeupDeviceInner(PID, CALLTIMEMS, type, "7", "7");
220 type = WakeupDeviceType::WAKEUP_DEVICE_GESTURE;
221 stateMachine->WakeupDeviceInner(PID, CALLTIMEMS, type, "7", "7");
222 type = WakeupDeviceType::WAKEUP_DEVICE_CAMERA_LAUNCH;
223 stateMachine->WakeupDeviceInner(PID, CALLTIMEMS, type, "7", "7");
224 type = WakeupDeviceType::WAKEUP_DEVICE_WAKE_MOTION;
225 stateMachine->WakeupDeviceInner(PID, CALLTIMEMS, type, "7", "7");
226 type = WakeupDeviceType::WAKEUP_DEVICE_LID;
227 stateMachine->WakeupDeviceInner(PID, CALLTIMEMS, type, "7", "7");
228 type = WakeupDeviceType::WAKEUP_DEVICE_DOUBLE_CLICK;
229 stateMachine->WakeupDeviceInner(PID, CALLTIMEMS, type, "7", "7");
230 type = WakeupDeviceType::WAKEUP_DEVICE_PEN;
231 stateMachine->WakeupDeviceInner(PID, CALLTIMEMS, type, "7", "7");
232 type = WakeupDeviceType::WAKEUP_DEVICE_KEYBOARD;
233 stateMachine->WakeupDeviceInner(PID, CALLTIMEMS, type, "7", "7");
234 type = WakeupDeviceType::WAKEUP_DEVICE_MOUSE;
235 stateMachine->WakeupDeviceInner(PID, CALLTIMEMS, type, "7", "7");
236 type = WakeupDeviceType::WAKEUP_DEVICE_UNKNOWN;
237 stateMachine->WakeupDeviceInner(PID, CALLTIMEMS, type, "7", "7");
238 stateMachine->WakeupDeviceInner(PID, CALLTIMEMS, static_cast<WakeupDeviceType>(MAXTYPE), "7", "7");
239
240 POWER_HILOGI(LABEL_TEST, "NativePowerStateMachine004::fun is end!");
241 GTEST_LOG_(INFO) << "NativePowerStateMachine004: Suspend Device end.";
242 }
243
244 /**
245 * @tc.name: NativePowerStateMachine005
246 * @tc.desc: test recordFailure in powerStateMachine
247 * @tc.type: FUNC
248 */
249 HWTEST_F(NativePowerStateMachineTest, NativePowerStateMachine005, TestSize.Level0)
250 {
251 GTEST_LOG_(INFO) << "NativePowerStateMachine005: Suspend Device start.";
252 POWER_HILOGI(LABEL_TEST, "NativePowerStateMachine005::fun is start!");
253 auto pmsTest = DelayedSpSingleton<PowerMgrService>::GetInstance();
254
255 auto stateMachine = std::make_shared<PowerStateMachine>(pmsTest);
256 EXPECT_TRUE(stateMachine->Init());
257
258 auto stateMachineController = std::make_shared<PowerStateMachine::StateController>(
259 PowerState::INACTIVE, stateMachine, TransitResultToStateChangeReason);
260 StateChangeReason trigger = StateChangeReason::STATE_CHANGE_REASON_BATTERY;
261 TransitResult failReason = TransitResult::LOCKING;
262 stateMachineController->RecordFailure(PowerState::INACTIVE, trigger, failReason);
263 failReason = TransitResult::HDI_ERR;
264 stateMachineController->RecordFailure(PowerState::INACTIVE, trigger, failReason);
265 failReason = TransitResult::DISPLAY_ON_ERR;
266 stateMachineController->RecordFailure(PowerState::INACTIVE, trigger, failReason);
267 failReason = TransitResult::DISPLAY_OFF_ERR;
268 stateMachineController->RecordFailure(PowerState::INACTIVE, trigger, failReason);
269 failReason = TransitResult::OTHER_ERR;
270 stateMachineController->RecordFailure(PowerState::INACTIVE, trigger, failReason);
271 #ifdef POWER_MANAGER_POWER_ENABLE_S4
272 EXPECT_TRUE(stateMachineController->TransitTo(trigger, false) == TransitResult::LOCKING);
273 #else
274 EXPECT_TRUE(stateMachineController->TransitTo(trigger, false) == TransitResult::ALREADY_IN_STATE);
275 #endif
276 stateMachine->SetDisplayOffTime(TIME, false);
277
278 auto stateMachineController2 = std::make_shared<PowerStateMachine::StateController>(
279 PowerState::INACTIVE, nullptr, TransitResultToStateChangeReason);
280 EXPECT_TRUE(stateMachineController2->TransitTo(trigger, false) == TransitResult::OTHER_ERR);
281 EXPECT_FALSE(stateMachineController2->CheckState());
282
283 POWER_HILOGI(LABEL_TEST, "NativePowerStateMachine005::fun is end!");
284 GTEST_LOG_(INFO) << "NativePowerStateMachine005: Suspend Device end.";
285 }
286
287 /**
288 * @tc.name: NativePowerStateMachine006
289 * @tc.desc: test recordFailure in powerStateMachine
290 * @tc.type: FUNC
291 */
292 HWTEST_F(NativePowerStateMachineTest, NativePowerStateMachine006, TestSize.Level0)
293 {
294 GTEST_LOG_(INFO) << "NativePowerStateMachine006: Suspend Device start.";
295 POWER_HILOGI(LABEL_TEST, "NativePowerStateMachine006::fun is start!");
296 auto stateMachine = std::make_shared<PowerStateMachine>(nullptr);
297 EXPECT_TRUE(stateMachine->Init());
298 EXPECT_FALSE(stateMachine->CheckRunningLock(PowerState::INACTIVE));
299
300 auto stateMachineController = std::make_shared<PowerStateMachine::StateController>(
301 PowerState::INACTIVE, stateMachine, TransitResultToStateChangeReason);
302 StateChangeReason trigger = StateChangeReason::STATE_CHANGE_REASON_BATTERY;
303 EXPECT_TRUE(stateMachineController->TransitTo(trigger, false) == TransitResult::LOCKING);
304 stateMachine->currentState_ = PowerState::INACTIVE;
305 stateMachine->SetDisplaySuspend(false);
306 stateMachine->SetSleepTime(TIME);
307 SuspendDeviceType suspendDeviceType = SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION;
308 stateMachine->SuspendDeviceInner(PID, CALLTIMEMS, suspendDeviceType, true, false);
309
310 POWER_HILOGI(LABEL_TEST, "NativePowerStateMachine006::fun is end!");
311 GTEST_LOG_(INFO) << "NativePowerStateMachine006: Suspend Device end.";
312 }
313
314 /**
315 * @tc.name: NativePowerStateMachine007
316 * @tc.desc: test init in powerStateMachine
317 * @tc.type: FUNC
318 */
319 HWTEST_F(NativePowerStateMachineTest, NativePowerStateMachine007, TestSize.Level0)
320 {
321 GTEST_LOG_(INFO) << "NativePowerStateMachine007: Suspend Device start.";
322 POWER_HILOGI(LABEL_TEST, "NativePowerStateMachine007::fun is start!");
323 auto pmsTest = DelayedSpSingleton<PowerMgrService>::GetInstance();
324 pmsTest->OnStart();
325 auto stateMachine = std::make_shared<PowerStateMachine>(pmsTest);
326 EXPECT_TRUE(stateMachine->Init());
327
328 bool ret = stateMachine->SetState(PowerState::AWAKE, StateChangeReason::STATE_CHANGE_REASON_BATTERY, true);
329 EXPECT_TRUE(ret);
330 stateMachine->HandleSystemWakeup();
331 stateMachine->HandleActivitySleepTimeout();
332 ret = stateMachine->SetState(PowerState::INACTIVE, StateChangeReason::STATE_CHANGE_REASON_BATTERY, true);
333 EXPECT_TRUE(ret);
334 stateMachine->HandleSystemWakeup();
335
336 sptr<IRemoteObject> token = new RunningLockTokenStub();
337 RunningLockInfo infoInactive("test1", RunningLockType::RUNNINGLOCK_SCREEN);
338 pmsTest->CreateRunningLock(token, infoInactive);
339 pmsTest->Lock(token);
340 EXPECT_EQ(pmsTest->IsUsed(token), true);
341 stateMachine->HandleActivityTimeout();
342
343 pmsTest->UnLock(token);
344 EXPECT_EQ(pmsTest->IsUsed(token), false);
345
346 pmsTest->UnLock(token);
347 EXPECT_EQ(pmsTest->IsUsed(token), false);
348 POWER_HILOGI(LABEL_TEST, "NativePowerStateMachine007::fun is end!");
349 GTEST_LOG_(INFO) << "NativePowerStateMachine007: Suspend Device end.";
350 }
351 /**
352 * @tc.name: NativePowerStateMachine008
353 * @tc.desc: test duration of DIM state
354 * @tc.type: FUNC
355 */
356 HWTEST_F(NativePowerStateMachineTest, NativePowerStateMachine008, TestSize.Level0)
357 {
358 POWER_HILOGI(LABEL_TEST, "NativePowerStateMachine008: func started!");
359 auto pmsTest = DelayedSpSingleton<PowerMgrService>::GetInstance();
360 pmsTest->OnStart();
361 auto stateMachine = pmsTest->GetPowerStateMachine();
362 stateMachine->OverrideScreenOffTimeInner(10 * 1000);
363 auto displayOffTime = stateMachine->GetDisplayOffTime();
364 EXPECT_EQ(displayOffTime, 10 * 1000);
365 EXPECT_EQ(stateMachine->GetDimTime(displayOffTime), displayOffTime / PowerStateMachine::OFF_TIMEOUT_FACTOR);
366
367 stateMachine->OverrideScreenOffTimeInner(60 * 1000);
368 displayOffTime = stateMachine->GetDisplayOffTime();
369 EXPECT_EQ(displayOffTime, 60 * 1000);
370 EXPECT_EQ(stateMachine->GetDimTime(displayOffTime), PowerStateMachine::MAX_DIM_TIME_MS);
371 POWER_HILOGI(LABEL_TEST, "NativePowerStateMachine008: func ended!");
372 }
373
374 /**
375 * @tc.name: NativePowerStateMachine009
376 * @tc.desc: test GetExternalScreenNumber
377 * @tc.type: FUNC
378 */
379 HWTEST_F(NativePowerStateMachineTest, NativePowerStateMachine009, TestSize.Level0)
380 {
381 POWER_HILOGI(LABEL_TEST, "NativePowerStateMachine009: func started!");
382 #ifdef POWER_MANAGER_ENABLE_EXTERNAL_SCREEN_MANAGEMENT
383 auto pmsTest = DelayedSpSingleton<PowerMgrService>::GetInstance();
384 pmsTest->OnStart();
385 pmsTest->RegisterExternalScreenListener();
386 EXPECT_TRUE(pmsTest->externalScreenListener_ != nullptr);
387 auto stateMachine = pmsTest->GetPowerStateMachine();
388 constexpr uint64_t SCREEN_A_ID = 10001;
389 constexpr uint64_t SCREEN_B_ID = 10002;
390 pmsTest->externalScreenListener_->OnConnect(SCREEN_A_ID);
391 EXPECT_EQ(stateMachine->GetExternalScreenNumber(), 1);
392 pmsTest->externalScreenListener_->OnConnect(SCREEN_B_ID);
393 EXPECT_EQ(stateMachine->GetExternalScreenNumber(), 2);
394 pmsTest->externalScreenListener_->OnDisconnect(SCREEN_B_ID);
395 EXPECT_EQ(stateMachine->GetExternalScreenNumber(), 1);
396 pmsTest->UnRegisterExternalScreenListener();
397 #endif
398 POWER_HILOGI(LABEL_TEST, "NativePowerStateMachine009: func ended!");
399 }
400
401 /**
402 * @tc.name: NativePowerStateMachine010
403 * @tc.desc: test ProximityNormalController in powerStateMachine
404 * @tc.type: FUNC
405 */
406 HWTEST_F(NativePowerStateMachineTest, NativePowerStateMachine010, TestSize.Level0)
407 {
408 POWER_HILOGI(LABEL_TEST, "NativePowerStateMachine010::fun is start!");
409 #ifdef HAS_SENSORS_SENSOR_PART
410 auto pmsTest = DelayedSpSingleton<PowerMgrService>::GetInstance();
411 pmsTest->OnStart();
412 auto stateMachine = pmsTest->GetPowerStateMachine();
413 SuspendDeviceType reasonSDT = SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION;
414 SensorEvent *event = new SensorEvent();
415 event->data = new uint8_t(0);
416 ProximityData* data = reinterpret_cast<ProximityData*>(event->data);
417 event->sensorTypeId = SENSOR_TYPE_ID_PROXIMITY;
418 EXPECT_TRUE(pmsTest->SuspendDevice(SUSCALLTIMEMS, reasonSDT, false) == PowerErrors::ERR_OK);
419 usleep(SLEEP_WAIT_TIME_MS);
420 EXPECT_EQ(stateMachine->IsScreenOn(), false) << "NativePowerStateMachine010: Suspend Device Fail, Screen is On";
421 sleep(SLEEP_WAIT_TIME_S);
422 stateMachine->proximityNormalController_.Disable();
423 data->distance = 5;
424 stateMachine->proximityNormalController_.RecordSensorCallback(event);
425 pmsTest->WakeupDevice(0, WakeupDeviceType::WAKEUP_DEVICE_PICKUP, "NativePowerStateMachine010");
426 usleep(SLEEP_WAIT_TIME_MS);
427 EXPECT_EQ(stateMachine->IsScreenOn(), true)
428 << "NativePowerStateMachine010: Pickup Wakeup Device When Proximity Is Away Fail, Screen is Off";
429 delete event->data;
430 event->data = nullptr;
431 data = nullptr;
432 delete event;
433 event = nullptr;
434 #endif
435 POWER_HILOGI(LABEL_TEST, "NativePowerStateMachine010::fun is end!");
436 }
437
438 } // namespace
439