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