1 /*
2 * Copyright (c) 2021-2023 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.h"
17
18 #include <datetime_ex.h>
19 #include <file_ex.h>
20 #ifdef HAS_HIVIEWDFX_HISYSEVENT_PART
21 #include <hisysevent.h>
22 #endif
23 #include <if_system_ability_manager.h>
24 #ifdef HAS_MULTIMODALINPUT_INPUT_PART
25 #include <input_manager.h>
26 #endif
27 #include <ipc_skeleton.h>
28 #include <iservice_registry.h>
29 #include <securec.h>
30 #include <string_ex.h>
31 #include <system_ability_definition.h>
32 #include <sys_mgr_client.h>
33 #include <bundle_mgr_client.h>
34 #include <unistd.h>
35 #include "ability_connect_callback_stub.h"
36 #include "ability_manager_client.h"
37 #include "ffrt_utils.h"
38 #include "permission.h"
39 #include "power_ext_intf_wrapper.h"
40 #include "power_common.h"
41 #include "power_mgr_dumper.h"
42 #include "power_vibrator.h"
43 #include "power_xcollie.h"
44 #include "setting_helper.h"
45 #include "running_lock_timer_handler.h"
46 #include "sysparam.h"
47 #include "system_suspend_controller.h"
48 #include "xcollie/watchdog.h"
49 #include "errors.h"
50 #include "parameters.h"
51 #ifdef HAS_DEVICE_STANDBY_PART
52 #include "standby_service_client.h"
53 #endif
54 #ifdef POWER_MANAGER_ENABLE_CHARGING_TYPE_SETTING
55 #include "battery_srv_client.h"
56 #endif
57 #ifdef MSDP_MOVEMENT_ENABLE
58 #include <dlfcn.h>
59 #endif
60
61 using namespace OHOS::AppExecFwk;
62 using namespace OHOS::AAFwk;
63 namespace OHOS {
64 namespace PowerMgr {
65 namespace {
66 const std::string POWERMGR_SERVICE_NAME = "PowerMgrService";
67 const std::string REASON_POWER_KEY = "power_key";
68 static std::string g_wakeupReason = "";
69 const std::string POWER_VIBRATOR_CONFIG_FILE = "etc/power_config/power_vibrator.json";
70 const std::string VENDOR_POWER_VIBRATOR_CONFIG_FILE = "/vendor/etc/power_config/power_vibrator.json";
71 const std::string SYSTEM_POWER_VIBRATOR_CONFIG_FILE = "/system/etc/power_config/power_vibrator.json";
72 static const char* POWER_MANAGER_EXT_PATH = "libpower_manager_ext.z.so";
73 constexpr int32_t WAKEUP_LOCK_TIMEOUT_MS = 5000;
74 constexpr int32_t HIBERNATE_GUARD_TIMEOUT_MS = 40000; // PREPARE_HIBERNATE_TIMEOUT_MS + 10000
75 constexpr int32_t COLLABORATION_REMOTE_DEVICE_ID = 0xAAAAAAFF;
76 constexpr uint64_t VIRTUAL_SCREEN_START_ID = 1000;
77 auto pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
78 const bool G_REGISTER_RESULT = SystemAbility::MakeAndRegisterAbility(pms.GetRefPtr());
79 SysParam::BootCompletedCallback g_bootCompletedCallback;
80 #ifdef POWER_PICKUP_ENABLE
81 bool g_isPickUpOpen = false;
82 #endif
83 constexpr int32_t API18 = 18;
84 } // namespace
85
86 std::atomic_bool PowerMgrService::isBootCompleted_ = false;
87 #ifdef HAS_SENSORS_SENSOR_PART
88 bool PowerMgrService::isInLidMode_ = false;
89 #endif
90 using namespace MMI;
91
PowerMgrService()92 PowerMgrService::PowerMgrService() : SystemAbility(POWER_MANAGER_SERVICE_ID, true) {}
93
~PowerMgrService()94 PowerMgrService::~PowerMgrService() {}
95
OnStart()96 void PowerMgrService::OnStart()
97 {
98 POWER_HILOGD(COMP_SVC, "Power Management startup");
99 if (ready_) {
100 POWER_HILOGW(COMP_SVC, "OnStart is ready, nothing to do");
101 return;
102 }
103 if (!Init()) {
104 POWER_HILOGE(COMP_SVC, "powermgr service init fail");
105 return;
106 }
107 AddSystemAbilityListener(SUSPEND_MANAGER_SYSTEM_ABILITY_ID);
108 AddSystemAbilityListener(DEVICE_STANDBY_SERVICE_SYSTEM_ABILITY_ID);
109 AddSystemAbilityListener(DISPLAY_MANAGER_SERVICE_ID);
110 AddSystemAbilityListener(DISTRIBUTED_KV_DATA_SERVICE_ABILITY_ID);
111 #ifdef MSDP_MOVEMENT_ENABLE
112 AddSystemAbilityListener(MSDP_MOVEMENT_SERVICE_ID);
113 #endif
114 #ifdef POWER_PICKUP_ENABLE
115 AddSystemAbilityListener(MSDP_MOTION_SERVICE_ID);
116 #endif
117 #ifndef FUZZ_TEST
118 SystemSuspendController::GetInstance().RegisterHdiStatusListener();
119 #endif
120 PowerExtIntfWrapper::Instance().Init();
121 if (!Publish(DelayedSpSingleton<PowerMgrService>::GetInstance())) {
122 POWER_HILOGE(COMP_SVC, "Register to system ability manager failed");
123 return;
124 }
125 ready_ = true;
126 system::SetParameter("bootevent.powermgr.ready", "true");
127 POWER_HILOGI(COMP_SVC, "Add system ability success");
128 }
129
Init()130 bool PowerMgrService::Init()
131 {
132 POWER_HILOGI(COMP_SVC, "powermgr service init start");
133 if (!ffrtTimer_) {
134 ffrtTimer_ = std::make_shared<FFRTTimer>("power_manager_ffrt_queue");
135 }
136 if (!runningLockMgr_) {
137 runningLockMgr_ = std::make_shared<RunningLockMgr>(pms);
138 }
139 if (!runningLockMgr_->Init()) {
140 POWER_HILOGE(COMP_SVC, "Running lock init fail");
141 return false;
142 }
143 if (!shutdownController_) {
144 shutdownController_ = std::make_shared<ShutdownController>();
145 }
146 if (!PowerStateMachineInit()) {
147 POWER_HILOGE(COMP_SVC, "Power state machine init fail");
148 }
149 if (!screenOffPreController_) {
150 screenOffPreController_ = std::make_shared<ScreenOffPreController>(powerStateMachine_);
151 screenOffPreController_->Init();
152 }
153 POWER_HILOGI(COMP_SVC, "powermgr service init success");
154 return true;
155 }
156
RegisterBootCompletedCallback()157 void PowerMgrService::RegisterBootCompletedCallback()
158 {
159 g_bootCompletedCallback = []() {
160 POWER_HILOGI(COMP_SVC, "BootCompletedCallback triggered");
161 auto power = DelayedSpSingleton<PowerMgrService>::GetInstance();
162 if (power == nullptr) {
163 POWER_HILOGI(COMP_SVC, "get PowerMgrService fail");
164 return;
165 }
166 auto powerStateMachine = power->GetPowerStateMachine();
167 #ifdef POWER_PICKUP_ENABLE
168 SettingHelper::CopyDataForUpdateScene();
169 #endif
170 SettingHelper::UpdateCurrentUserId(); // update setting user id before get setting values
171 #ifdef POWER_MANAGER_ENABLE_CHARGING_TYPE_SETTING
172 power->PowerConnectStatusInit();
173 power->UpdateSettingInvalidDisplayOffTime(); // update setting value if invalid before register
174 #endif
175 powerStateMachine->RegisterDisplayOffTimeObserver();
176 powerStateMachine->InitState();
177 SettingHelper::RegisterAodSwitchObserver();
178 #ifdef POWER_MANAGER_POWER_DIALOG
179 power->GetShutdownDialog().LoadDialogConfig();
180 power->GetShutdownDialog().KeyMonitorInit();
181 #endif
182 power->SwitchSubscriberInit();
183 power->InputMonitorInit();
184 SettingHelper::UpdateCurrentUserId();
185 power->SuspendControllerInit();
186 power->WakeupControllerInit();
187 power->SubscribeCommonEvent();
188 #ifdef POWER_MANAGER_WAKEUP_ACTION
189 power->WakeupActionControllerInit();
190 #endif
191 PowerExternalAbilityInit();
192 power->KeepScreenOnInit();
193 isBootCompleted_ = true;
194 };
195 SysParam::RegisterBootCompletedCallback(g_bootCompletedCallback);
196 }
197
PowerExternalAbilityInit()198 void PowerMgrService::PowerExternalAbilityInit()
199 {
200 auto power = DelayedSpSingleton<PowerMgrService>::GetInstance();
201 if (power == nullptr) {
202 POWER_HILOGI(COMP_SVC, "get PowerMgrService fail");
203 return;
204 }
205 #ifdef POWER_MANAGER_ENABLE_EXTERNAL_SCREEN_MANAGEMENT
206 // External screen listener must be registered after SuspendControllerInit and WakeupControllerInit
207 power->UnRegisterExternalScreenListener();
208 power->RegisterExternalScreenListener();
209 power->ExternalScreenInit();
210 #endif
211 power->VibratorInit();
212 #ifdef POWER_DOUBLECLICK_ENABLE
213 power->RegisterSettingWakeupDoubleClickObservers();
214 #endif
215 #ifdef POWER_PICKUP_ENABLE
216 power->RegisterSettingWakeupPickupGestureObserver();
217 #endif
218 #ifndef CONFIG_FACTORY_MODE
219 power->RegisterSettingWakeUpLidObserver();
220 POWER_HILOGI(COMP_SVC, "Allow subscribe Hall sensor");
221 #else
222 POWER_HILOGI(COMP_SVC, "Not allow subscribe Hall sensor");
223 #endif
224 power->RegisterSettingPowerModeObservers();
225 power->RegisterExternalCallback();
226 }
227
RegisterSettingPowerModeObservers()228 void PowerMgrService::RegisterSettingPowerModeObservers()
229 {
230 SettingObserver::UpdateFunc updateFunc = [&](const std::string &key) { PowerModeSettingUpdateFunc(key); };
231 SettingHelper::RegisterSettingPowerModeObserver(updateFunc);
232 }
233
PowerModeSettingUpdateFunc(const std::string & key)234 void PowerMgrService::PowerModeSettingUpdateFunc(const std::string &key)
235 {
236 auto power = DelayedSpSingleton<PowerMgrService>::GetInstance();
237 int32_t currMode = static_cast<int32_t>(power->GetDeviceMode());
238 int32_t saveMode = SettingHelper::ReadCurrentMode(currMode);
239 if (currMode == saveMode) {
240 return;
241 }
242 POWER_HILOGI(COMP_SVC, "PowerModeSettingUpdateFunc curr:%{public}d, saveMode:%{public}d", currMode, saveMode);
243 power->SetDeviceMode(static_cast<PowerMode>(saveMode));
244 }
245
IsDeveloperMode()246 bool PowerMgrService::IsDeveloperMode()
247 {
248 return OHOS::system::GetBoolParameter("const.security.developermode.state", true);
249 }
250
KeepScreenOnInit()251 void PowerMgrService::KeepScreenOnInit()
252 {
253 if (ptoken_ != nullptr) {
254 POWER_HILOGI(COMP_SVC, "runninglock token is not null");
255 return;
256 }
257 ptoken_ = new (std::nothrow) RunningLockTokenStub();
258 if (ptoken_ == nullptr) {
259 POWER_HILOGI(COMP_SVC, "create runninglock token failed");
260 return;
261 }
262 RunningLockInfo info = {"PowerMgrKeepOnLock", OHOS::PowerMgr::RunningLockType::RUNNINGLOCK_SCREEN};
263 PowerErrors ret = pms->CreateRunningLock(ptoken_, info);
264 if (ret != PowerErrors::ERR_OK) {
265 POWER_HILOGI(COMP_SVC, "create runninglock failed");
266 }
267 return;
268 }
269
KeepScreenOn(bool isOpenOn)270 void PowerMgrService::KeepScreenOn(bool isOpenOn)
271 {
272 if (!IsDeveloperMode()) {
273 POWER_HILOGI(COMP_SVC, "not developer mode");
274 return;
275 }
276 if (ptoken_ == nullptr) {
277 POWER_HILOGI(COMP_SVC, "runninglock token is null");
278 return;
279 }
280 if (isOpenOn) {
281 POWER_HILOGI(COMP_SVC, "try lock RUNNINGLOCK_SCREEN");
282 pms->Lock(ptoken_);
283 } else {
284 POWER_HILOGI(COMP_SVC, "try unlock RUNNINGLOCK_SCREEN");
285 pms->UnLock(ptoken_);
286 }
287 return;
288 }
289
290 #ifdef POWER_DOUBLECLICK_ENABLE
RegisterSettingWakeupDoubleClickObservers()291 void PowerMgrService::RegisterSettingWakeupDoubleClickObservers()
292 {
293 SettingObserver::UpdateFunc updateFunc = [&](const std::string& key) {WakeupDoubleClickSettingUpdateFunc(key); };
294 SettingHelper::RegisterSettingWakeupDoubleObserver(updateFunc);
295 }
296
WakeupDoubleClickSettingUpdateFunc(const std::string & key)297 void PowerMgrService::WakeupDoubleClickSettingUpdateFunc(const std::string& key)
298 {
299 bool isSettingEnable = GetSettingWakeupDoubleClick(key);
300 WakeupController::ChangeWakeupSourceConfig(isSettingEnable);
301 WakeupController::SetWakeupDoubleClickSensor(isSettingEnable);
302 POWER_HILOGI(COMP_SVC, "WakeupDoubleClickSettingUpdateFunc isSettingEnable=%{public}d", isSettingEnable);
303 }
304
GetSettingWakeupDoubleClick(const std::string & key)305 bool PowerMgrService::GetSettingWakeupDoubleClick(const std::string& key)
306 {
307 return SettingHelper::GetSettingWakeupDouble(key);
308 }
309 #endif
310 #ifdef POWER_PICKUP_ENABLE
RegisterSettingWakeupPickupGestureObserver()311 void PowerMgrService::RegisterSettingWakeupPickupGestureObserver()
312 {
313 SettingObserver::UpdateFunc updateFunc = [&](const std::string& key) {WakeupPickupGestureSettingUpdateFunc(key);};
314 SettingHelper::RegisterSettingWakeupPickupObserver(updateFunc);
315 }
316
WakeupPickupGestureSettingUpdateFunc(const std::string & key)317 void PowerMgrService::WakeupPickupGestureSettingUpdateFunc(const std::string& key)
318 {
319 bool isSettingEnable = SettingHelper::GetSettingWakeupPickup(key);
320 g_isPickUpOpen = isSettingEnable;
321 WakeupController::PickupConnectMotionConfig(isSettingEnable);
322 POWER_HILOGI(COMP_SVC, "PickupConnectMotionConfig done, isSettingEnable=%{public}d", isSettingEnable);
323 WakeupController::ChangePickupWakeupSourceConfig(isSettingEnable);
324 POWER_HILOGI(COMP_SVC, "ChangePickupWakeupSourceConfig done");
325 }
326 #endif
327
PowerStateMachineInit()328 bool PowerMgrService::PowerStateMachineInit()
329 {
330 if (powerStateMachine_ == nullptr) {
331 powerStateMachine_ = std::make_shared<PowerStateMachine>(pms, ffrtTimer_);
332 if (!(powerStateMachine_->Init())) {
333 POWER_HILOGE(COMP_SVC, "Power state machine start fail!");
334 return false;
335 }
336 }
337 if (powerMgrNotify_ == nullptr) {
338 powerMgrNotify_ = std::make_shared<PowerMgrNotify>();
339 powerMgrNotify_->RegisterPublishEvents();
340 }
341 return true;
342 }
343
KeyMonitorCancel()344 void PowerMgrService::KeyMonitorCancel()
345 {
346 #ifdef HAS_MULTIMODALINPUT_INPUT_PART
347 POWER_HILOGI(FEATURE_INPUT, "Unsubscribe key information");
348 InputManager* inputManager = InputManager::GetInstance();
349 if (inputManager == nullptr) {
350 POWER_HILOGI(FEATURE_INPUT, "InputManager is null");
351 return;
352 }
353 shutdownDialog_.KeyMonitorCancel();
354 if (doubleClickId_ >= 0) {
355 inputManager->UnsubscribeKeyEvent(doubleClickId_);
356 }
357 if (monitorId_ >= 0) {
358 inputManager->RemoveMonitor(monitorId_);
359 }
360 #endif
361 }
362
WakeupLidSettingUpdateFunc(const std::string & key)363 void PowerMgrService::WakeupLidSettingUpdateFunc(const std::string& key)
364 {
365 POWER_HILOGI(COMP_SVC, "Receive lid wakeup setting update.");
366 bool enable = SettingHelper::GetSettingWakeupLid(key);
367 if (enable) {
368 pms->HallSensorSubscriberInit();
369 } else {
370 pms->HallSensorSubscriberCancel();
371 }
372 std::shared_ptr<WakeupController> wakeupController = pms->GetWakeupController();
373 if (wakeupController == nullptr) {
374 POWER_HILOGE(FEATURE_INPUT, "wakeupController is not init");
375 return;
376 }
377 wakeupController->ChangeLidWakeupSourceConfig(enable);
378 POWER_HILOGI(COMP_SVC, "ChangeLidWakeupSourceConfig done");
379 }
380
RegisterSettingWakeUpLidObserver()381 void PowerMgrService::RegisterSettingWakeUpLidObserver()
382 {
383 pms->HallSensorSubscriberInit();
384 POWER_HILOGI(COMP_SVC, "Start to registerSettingWakeUpLidObserver");
385 if (!SettingHelper::IsWakeupLidSettingValid()) {
386 POWER_HILOGE(COMP_UTILS, "settings.power.wakeup_lid is valid.");
387 return;
388 }
389 SettingObserver::UpdateFunc updateFunc = [&](const std::string& key) {WakeupLidSettingUpdateFunc(key);};
390 SettingHelper::RegisterSettingWakeupLidObserver(updateFunc);
391 }
392
HallSensorSubscriberInit()393 void PowerMgrService::HallSensorSubscriberInit()
394 {
395 #ifdef HAS_SENSORS_SENSOR_PART
396 POWER_HILOGI(COMP_SVC, "Start to subscribe hall sensor");
397 if (!IsSupportSensor(SENSOR_TYPE_ID_HALL)) {
398 POWER_HILOGW(FEATURE_INPUT, "SENSOR_TYPE_ID_HALL sensor not support");
399 return;
400 }
401 if (strcpy_s(sensorUser_.name, sizeof(sensorUser_.name), "PowerManager") != EOK) {
402 POWER_HILOGW(FEATURE_INPUT, "strcpy_s error");
403 return;
404 }
405 isInLidMode_ = false;
406 sensorUser_.userData = nullptr;
407 sensorUser_.callback = &HallSensorCallback;
408 SubscribeSensor(SENSOR_TYPE_ID_HALL, &sensorUser_);
409 SetBatch(SENSOR_TYPE_ID_HALL, &sensorUser_, HALL_SAMPLING_RATE, HALL_REPORT_INTERVAL);
410 ActivateSensor(SENSOR_TYPE_ID_HALL, &sensorUser_);
411 #endif
412 }
413
414 #ifdef HAS_SENSORS_SENSOR_PART
IsSupportSensor(SensorTypeId typeId)415 bool PowerMgrService::IsSupportSensor(SensorTypeId typeId)
416 {
417 bool isSupport = false;
418 SensorInfo* sensorInfo = nullptr;
419 int32_t count;
420 int32_t ret = GetAllSensors(&sensorInfo, &count);
421 if (ret != 0 || sensorInfo == nullptr) {
422 POWER_HILOGW(FEATURE_INPUT, "Get sensors fail, ret=%{public}d", ret);
423 return isSupport;
424 }
425 for (int32_t i = 0; i < count; i++) {
426 if (sensorInfo[i].sensorTypeId == typeId) {
427 isSupport = true;
428 break;
429 }
430 }
431 return isSupport;
432 }
433
HallSensorCallback(SensorEvent * event)434 void PowerMgrService::HallSensorCallback(SensorEvent* event)
435 {
436 if (event == nullptr || event->sensorTypeId != SENSOR_TYPE_ID_HALL || event->data == nullptr) {
437 POWER_HILOGW(FEATURE_INPUT, "Hall sensor event is invalid");
438 return;
439 }
440
441 std::shared_ptr<SuspendController> suspendController = pms->GetSuspendController();
442 if (suspendController == nullptr) {
443 POWER_HILOGE(FEATURE_INPUT, "get suspendController instance error");
444 return;
445 }
446
447 std::shared_ptr<WakeupController> wakeupController = pms->GetWakeupController();
448 if (wakeupController == nullptr) {
449 POWER_HILOGE(FEATURE_INPUT, "wakeupController is not init");
450 return;
451 }
452 const uint32_t LID_CLOSED_HALL_FLAG = 0x1;
453 auto data = reinterpret_cast<HallData*>(event->data);
454 auto status = static_cast<uint32_t>(data->status);
455
456 if (status & LID_CLOSED_HALL_FLAG) {
457 POWER_HILOGI(FEATURE_SUSPEND, "[UL_POWER] Lid close event received, begin to suspend");
458 isInLidMode_ = true;
459 SuspendDeviceType reason = SuspendDeviceType::SUSPEND_DEVICE_REASON_LID;
460 suspendController->ExecSuspendMonitorByReason(reason);
461 } else {
462 if (!isInLidMode_) {
463 return;
464 }
465 POWER_HILOGI(FEATURE_WAKEUP, "[UL_POWER] Lid open event received, begin to wakeup");
466 isInLidMode_ = false;
467 WakeupDeviceType reason = WakeupDeviceType::WAKEUP_DEVICE_LID;
468 wakeupController->ExecWakeupMonitorByReason(reason);
469 }
470 }
471 #endif
472
HallSensorSubscriberCancel()473 void PowerMgrService::HallSensorSubscriberCancel()
474 {
475 #ifdef HAS_SENSORS_SENSOR_PART
476 POWER_HILOGI(COMP_SVC, "Start to cancel the subscribe of hall sensor");
477 if (IsSupportSensor(SENSOR_TYPE_ID_HALL)) {
478 DeactivateSensor(SENSOR_TYPE_ID_HALL, &sensorUser_);
479 UnsubscribeSensor(SENSOR_TYPE_ID_HALL, &sensorUser_);
480 }
481 isInLidMode_ = false;
482 #endif
483 }
484
CheckDialogFlag()485 bool PowerMgrService::CheckDialogFlag()
486 {
487 bool isLongPress = shutdownDialog_.IsLongPress();
488 if (isLongPress) {
489 shutdownDialog_.ResetLongPressFlag();
490 }
491 return true;
492 }
493
CheckDialogAndShuttingDown()494 bool PowerMgrService::CheckDialogAndShuttingDown()
495 {
496 bool isShuttingDown = shutdownController_->IsShuttingDown();
497 bool isLongPress = shutdownDialog_.IsLongPress();
498 if (isLongPress || isShuttingDown) {
499 POWER_HILOGW(
500 FEATURE_INPUT, "isLongPress: %{public}d, isShuttingDown: %{public}d", isLongPress, isShuttingDown);
501 shutdownDialog_.ResetLongPressFlag();
502 return true;
503 }
504 return false;
505 }
506
SwitchSubscriberInit()507 void PowerMgrService::SwitchSubscriberInit()
508 {
509 #ifdef HAS_MULTIMODALINPUT_INPUT_PART
510 POWER_HILOGW(FEATURE_INPUT, "Initialize the subscription switch");
511 switchId_ =
512 InputManager::GetInstance()->SubscribeSwitchEvent([this](std::shared_ptr<OHOS::MMI::SwitchEvent> switchEvent) {
513 POWER_HILOGI(FEATURE_WAKEUP, "switch event received");
514 if (switchEvent->GetSwitchValue() == SwitchEvent::SWITCH_OFF) {
515 POWER_HILOGI(FEATURE_SUSPEND, "[UL_POWER] Switch close event received, begin to suspend");
516 std::shared_ptr<SuspendController> suspendController = pms->GetSuspendController();
517 if (suspendController == nullptr) {
518 POWER_HILOGE(FEATURE_INPUT, "get suspendController instance error");
519 return;
520 }
521 powerStateMachine_->SetSwitchState(false);
522 SuspendDeviceType reason = SuspendDeviceType::SUSPEND_DEVICE_REASON_SWITCH;
523 suspendController->ExecSuspendMonitorByReason(reason);
524 } else {
525 POWER_HILOGI(FEATURE_WAKEUP, "[UL_POWER] Switch open event received, begin to wakeup");
526 std::shared_ptr<WakeupController> wakeupController = pms->GetWakeupController();
527 if (wakeupController == nullptr) {
528 POWER_HILOGE(FEATURE_INPUT, "get wakeupController instance error");
529 return;
530 }
531 powerStateMachine_->SetSwitchState(true);
532 WakeupDeviceType reason = WakeupDeviceType::WAKEUP_DEVICE_SWITCH;
533 wakeupController->ExecWakeupMonitorByReason(reason);
534 }
535 });
536 #endif
537 }
538
SwitchSubscriberCancel()539 void PowerMgrService::SwitchSubscriberCancel()
540 {
541 #ifdef HAS_MULTIMODALINPUT_INPUT_PART
542 POWER_HILOGI(FEATURE_INPUT, "Unsubscribe switch information");
543 if (switchId_ >= 0) {
544 InputManager::GetInstance()->UnsubscribeSwitchEvent(switchId_);
545 switchId_ = -1;
546 }
547 #endif
548 }
549
InputMonitorInit()550 void PowerMgrService::InputMonitorInit()
551 {
552 #ifdef HAS_MULTIMODALINPUT_INPUT_PART
553 POWER_HILOGI(FEATURE_INPUT, "PowerMgr service input monitor init");
554 std::shared_ptr<PowerMgrInputMonitor> inputMonitor = std::make_shared<PowerMgrInputMonitor>();
555 if (inputMonitorId_ < 0) {
556 inputMonitorId_ =
557 InputManager::GetInstance()->AddMonitor(std::static_pointer_cast<IInputEventConsumer>(inputMonitor));
558 }
559 #endif
560 }
561
InputMonitorCancel()562 void PowerMgrService::InputMonitorCancel()
563 {
564 #ifdef HAS_MULTIMODALINPUT_INPUT_PART
565 POWER_HILOGI(FEATURE_INPUT, "PowerMgr service input monitor cancel");
566 InputManager* inputManager = InputManager::GetInstance();
567 if (inputMonitorId_ >= 0) {
568 inputManager->RemoveMonitor(inputMonitorId_);
569 inputMonitorId_ = -1;
570 }
571 #endif
572 }
573
HandleKeyEvent(int32_t keyCode)574 void PowerMgrService::HandleKeyEvent(int32_t keyCode)
575 {
576 #ifdef HAS_MULTIMODALINPUT_INPUT_PART
577 POWER_HILOGD(FEATURE_INPUT, "keyCode: %{public}d", keyCode);
578 int64_t now = static_cast<int64_t>(time(nullptr));
579 if (IsScreenOn()) {
580 this->RefreshActivityInner(now, UserActivityType::USER_ACTIVITY_TYPE_BUTTON, false);
581 } else {
582 if (keyCode == KeyEvent::KEYCODE_F1) {
583 POWER_HILOGI(FEATURE_WAKEUP, "[UL_POWER] Wakeup by double click");
584 std::string reason = "double click";
585 reason.append(std::to_string(keyCode));
586 this->WakeupDevice(now, WakeupDeviceType::WAKEUP_DEVICE_DOUBLE_CLICK, reason);
587 } else if (keyCode >= KeyEvent::KEYCODE_0 && keyCode <= KeyEvent::KEYCODE_NUMPAD_RIGHT_PAREN) {
588 POWER_HILOGI(FEATURE_WAKEUP, "[UL_POWER] Wakeup by keyboard");
589 std::string reason = "keyboard:";
590 reason.append(std::to_string(keyCode));
591 this->WakeupDevice(now, WakeupDeviceType::WAKEUP_DEVICE_KEYBOARD, reason);
592 }
593 }
594 #endif
595 }
596
HandlePointEvent(int32_t type)597 void PowerMgrService::HandlePointEvent(int32_t type)
598 {
599 #ifdef HAS_MULTIMODALINPUT_INPUT_PART
600 POWER_HILOGD(FEATURE_INPUT, "type: %{public}d", type);
601 int64_t now = static_cast<int64_t>(time(nullptr));
602 if (this->IsScreenOn()) {
603 this->RefreshActivityInner(now, UserActivityType::USER_ACTIVITY_TYPE_ATTENTION, false);
604 } else {
605 if (type == PointerEvent::SOURCE_TYPE_MOUSE) {
606 std::string reason = "mouse click";
607 POWER_HILOGI(FEATURE_WAKEUP, "[UL_POWER] Wakeup by mouse");
608 this->WakeupDevice(now, WakeupDeviceType::WAKEUP_DEVICE_MOUSE, reason);
609 }
610 }
611 #endif
612 }
613
OnStop()614 void PowerMgrService::OnStop()
615 {
616 POWER_HILOGW(COMP_SVC, "Stop service");
617 if (!ready_) {
618 return;
619 }
620 powerStateMachine_->CancelDelayTimer(PowerStateMachine::CHECK_USER_ACTIVITY_TIMEOUT_MSG);
621 powerStateMachine_->CancelDelayTimer(PowerStateMachine::CHECK_USER_ACTIVITY_OFF_TIMEOUT_MSG);
622 powerStateMachine_->UnregisterDisplayOffTimeObserver();
623 if (suspendController_) {
624 suspendController_->StopSleep();
625 }
626
627 SystemSuspendController::GetInstance().UnRegisterPowerHdiCallback();
628 KeyMonitorCancel();
629 HallSensorSubscriberCancel();
630 #ifdef POWER_MANAGER_ENABLE_EXTERNAL_SCREEN_MANAGEMENT
631 UnRegisterExternalScreenListener();
632 #endif
633 SwitchSubscriberCancel();
634 InputMonitorCancel();
635 ready_ = false;
636 isBootCompleted_ = false;
637 RemoveSystemAbilityListener(SUSPEND_MANAGER_SYSTEM_ABILITY_ID);
638 RemoveSystemAbilityListener(DEVICE_STANDBY_SERVICE_SYSTEM_ABILITY_ID);
639 RemoveSystemAbilityListener(DISPLAY_MANAGER_SERVICE_ID);
640 #ifdef MSDP_MOVEMENT_ENABLE
641 RemoveSystemAbilityListener(MSDP_MOVEMENT_SERVICE_ID);
642 #endif
643 #ifdef POWER_PICKUP_ENABLE
644 RemoveSystemAbilityListener(MSDP_MOTION_SERVICE_ID);
645 #endif
646 #ifdef POWER_DOUBLECLICK_ENABLE
647 SettingHelper::UnregisterSettingWakeupDoubleObserver();
648 #endif
649 #ifdef POWER_PICKUP_ENABLE
650 SettingHelper::UnregisterSettingWakeupPickupObserver();
651 #endif
652 SettingHelper::UnRegisterSettingWakeupLidObserver();
653 SettingHelper::UnRegisterSettingPowerModeObserver();
654 if (!OHOS::EventFwk::CommonEventManager::UnSubscribeCommonEvent(subscriberPtr_)) {
655 POWER_HILOGE(COMP_SVC, "Power Onstop unregister to commonevent manager failed!");
656 }
657 #ifdef MSDP_MOVEMENT_ENABLE
658 UnRegisterMovementCallback();
659 #endif
660 UnregisterExternalCallback();
661 #ifndef FUZZ_TEST
662 PowerExtIntfWrapper::Instance().DeInit();
663 #endif
664 }
665
Reset()666 void PowerMgrService::Reset()
667 {
668 POWER_HILOGW(COMP_SVC, "start destruct ffrt_queue");
669 if (powerStateMachine_) {
670 // release one strong reference to ffrtTimer
671 powerStateMachine_->Reset();
672 }
673 if (suspendController_) {
674 // release one strong reference to ffrtTimer
675 suspendController_->Reset();
676 }
677 ffrtTimer_.reset(); // all strong references gone, ffrtTimer will be destructed.
678 if (screenOffPreController_) {
679 // another queue without using FFRTTimer, leave it as is for now.
680 screenOffPreController_->Reset();
681 }
682 }
683
OnRemoveSystemAbility(int32_t systemAbilityId,const std::string & deviceId)684 void PowerMgrService::OnRemoveSystemAbility(int32_t systemAbilityId, const std::string& deviceId)
685 {
686 POWER_HILOGI(COMP_SVC, "systemAbilityId=%{public}d, deviceId=%{private}s", systemAbilityId, deviceId.c_str());
687 if (systemAbilityId == SUSPEND_MANAGER_SYSTEM_ABILITY_ID ||
688 systemAbilityId == DEVICE_STANDBY_SERVICE_SYSTEM_ABILITY_ID) {
689 std::lock_guard lock(lockMutex_);
690 runningLockMgr_->ResetRunningLocks();
691 }
692 #ifdef MSDP_MOVEMENT_ENABLE
693 if (systemAbilityId == MSDP_MOVEMENT_SERVICE_ID) {
694 auto power = DelayedSpSingleton<PowerMgrService>::GetInstance();
695 if (power == nullptr) {
696 POWER_HILOGI(COMP_SVC, "get PowerMgrService fail");
697 return;
698 }
699 power->ResetMovementState();
700 }
701 #endif
702 }
703
OnAddSystemAbility(int32_t systemAbilityId,const std::string & deviceId)704 void PowerMgrService::OnAddSystemAbility(int32_t systemAbilityId, const std::string& deviceId)
705 {
706 POWER_HILOGI(COMP_SVC, "systemAbilityId=%{public}d, deviceId=%{private}s Add",
707 systemAbilityId, deviceId.c_str());
708 if (systemAbilityId == DISTRIBUTED_KV_DATA_SERVICE_ABILITY_ID) {
709 if (DelayedSpSingleton<PowerSaveMode>::GetInstance()) {
710 this->GetPowerModeModule().InitPowerMode();
711 }
712 }
713 if (systemAbilityId == DISPLAY_MANAGER_SERVICE_ID) {
714 RegisterBootCompletedCallback();
715 }
716 #ifdef MSDP_MOVEMENT_ENABLE
717 if (systemAbilityId == MSDP_MOVEMENT_SERVICE_ID) {
718 auto power = DelayedSpSingleton<PowerMgrService>::GetInstance();
719 if (power == nullptr) {
720 POWER_HILOGI(COMP_SVC, "get PowerMgrService fail");
721 return;
722 }
723 power->UnRegisterMovementCallback();
724 power->RegisterMovementCallback();
725 }
726 #endif
727 #ifdef POWER_PICKUP_ENABLE
728 if (systemAbilityId == MSDP_MOTION_SERVICE_ID && g_isPickUpOpen == true) {
729 WakeupController::PickupConnectMotionConfig(false);
730 WakeupController::PickupConnectMotionConfig(true);
731 }
732 #endif
733 }
734
735 #ifdef MSDP_MOVEMENT_ENABLE
736 static const char* MOVEMENT_SUBSCRIBER_CONFIG = "RegisterMovementCallback";
737 static const char* MOVEMENT_UNSUBSCRIBER_CONFIG = "UnRegisterMovementCallback";
738 static const char* RESET_MOVEMENT_STATE_CONFIG = "ResetMovementState";
739 typedef void(*FuncMovementSubscriber)();
740 typedef void(*FuncMovementUnsubscriber)();
741 typedef void(*FuncResetMovementState)();
742
RegisterMovementCallback()743 void PowerMgrService::RegisterMovementCallback()
744 {
745 POWER_HILOGI(COMP_SVC, "Start to RegisterMovementCallback");
746 void *subscriberHandler = dlopen(POWER_MANAGER_EXT_PATH, RTLD_LAZY | RTLD_NODELETE);
747 if (subscriberHandler == nullptr) {
748 POWER_HILOGE(COMP_SVC, "Dlopen RegisterMovementCallback failed, reason : %{public}s", dlerror());
749 return;
750 }
751
752 FuncMovementSubscriber MovementSubscriber =
753 reinterpret_cast<FuncMovementSubscriber>(dlsym(subscriberHandler, MOVEMENT_SUBSCRIBER_CONFIG));
754 if (MovementSubscriber == nullptr) {
755 POWER_HILOGE(COMP_SVC, "RegisterMovementCallback is null, reason : %{public}s", dlerror());
756 dlclose(subscriberHandler);
757 subscriberHandler = nullptr;
758 return;
759 }
760 MovementSubscriber();
761 POWER_HILOGI(COMP_SVC, "RegisterMovementCallback Success");
762 dlclose(subscriberHandler);
763 subscriberHandler = nullptr;
764 return;
765 }
766
UnRegisterMovementCallback()767 void PowerMgrService::UnRegisterMovementCallback()
768 {
769 POWER_HILOGI(COMP_SVC, "Start to UnRegisterMovementCallback");
770 void *unSubscriberHandler = dlopen(POWER_MANAGER_EXT_PATH, RTLD_LAZY | RTLD_NODELETE);
771 if (unSubscriberHandler == nullptr) {
772 POWER_HILOGE(COMP_SVC, "Dlopen UnRegisterMovementCallback failed, reason : %{public}s", dlerror());
773 return;
774 }
775
776 FuncMovementUnsubscriber MovementUnsubscriber =
777 reinterpret_cast<FuncMovementUnsubscriber>(dlsym(unSubscriberHandler, MOVEMENT_UNSUBSCRIBER_CONFIG));
778 if (MovementUnsubscriber == nullptr) {
779 POWER_HILOGE(COMP_SVC, "UnRegisterMovementCallback is null, reason : %{public}s", dlerror());
780 dlclose(unSubscriberHandler);
781 unSubscriberHandler = nullptr;
782 return;
783 }
784 MovementUnsubscriber();
785 POWER_HILOGI(COMP_SVC, "UnRegisterMovementCallback Success");
786 dlclose(unSubscriberHandler);
787 unSubscriberHandler = nullptr;
788 return;
789 }
790
ResetMovementState()791 void PowerMgrService::ResetMovementState()
792 {
793 POWER_HILOGI(COMP_SVC, "Start to ResetMovementState");
794 void *resetMovementStateHandler = dlopen(POWER_MANAGER_EXT_PATH, RTLD_LAZY | RTLD_NODELETE);
795 if (resetMovementStateHandler == nullptr) {
796 POWER_HILOGE(COMP_SVC, "Dlopen ResetMovementState failed, reason : %{public}s", dlerror());
797 return;
798 }
799
800 FuncResetMovementState ResetMovementState =
801 reinterpret_cast<FuncResetMovementState>(dlsym(resetMovementStateHandler, RESET_MOVEMENT_STATE_CONFIG));
802 if (ResetMovementState == nullptr) {
803 POWER_HILOGE(COMP_SVC, "ResetMovementState is null, reason : %{public}s", dlerror());
804 dlclose(resetMovementStateHandler);
805 resetMovementStateHandler = nullptr;
806 return;
807 }
808 ResetMovementState();
809 POWER_HILOGI(COMP_SVC, "ResetMovementState Success");
810 dlclose(resetMovementStateHandler);
811 resetMovementStateHandler = nullptr;
812 return;
813 }
814 #endif
815
816 static const char* REGISTER_EXTERNAL_CONFIG = "RegisterExternalCallback";
817 static const char* UNREGISTER_EXTERNAL_CONFIG = "UnregisterExternalCallback";
818 using WakeupFunc = std::function<void(WakeupDeviceType)>;
819 using SuspendFunc = std::function<void(SuspendDeviceType)>;
820 using PowerConfigFunc = std::function<int32_t(std::string&, std::string&)>;
821 typedef void (*FuncRegisterExternalCallback)(WakeupFunc, SuspendFunc, PowerConfigFunc, PowerConfigFunc);
822 typedef void (*FuncUnregisterExternalCallback)();
823
RegisterExternalCallback()824 void PowerMgrService::RegisterExternalCallback()
825 {
826 POWER_HILOGI(COMP_SVC, "Start to RegisterExternalCallback");
827 void* subscriberHandler = dlopen(POWER_MANAGER_EXT_PATH, RTLD_LAZY | RTLD_NODELETE);
828 if (subscriberHandler == nullptr) {
829 POWER_HILOGE(COMP_SVC, "Dlopen RegisterExternalCallback failed, reason : %{public}s", dlerror());
830 return;
831 }
832
833 FuncRegisterExternalCallback registerExternalCallback =
834 reinterpret_cast<FuncRegisterExternalCallback>(dlsym(subscriberHandler, REGISTER_EXTERNAL_CONFIG));
835 if (registerExternalCallback == nullptr) {
836 POWER_HILOGE(COMP_SVC, "RegisterExternalCallback is null, reason : %{public}s", dlerror());
837 dlclose(subscriberHandler);
838 subscriberHandler = nullptr;
839 return;
840 }
841 registerExternalCallback(
842 [this](WakeupDeviceType reason) {
843 POWER_HILOGI(COMP_SVC, "[UL_POWER] wakeup callback triggered, reason: %{public}d", reason);
844 wakeupController_->ExecWakeupMonitorByReason(reason);
845 },
846 [this](SuspendDeviceType reason) {
847 POWER_HILOGI(COMP_SVC, "[UL_POWER] suspend callback triggered, reason: %{public}d", reason);
848 suspendController_->ExecSuspendMonitorByReason(reason);
849 },
850 [](std::string& sceneName, std::string& value) {
851 return SystemSuspendController::GetInstance().GetPowerConfig(sceneName, value);
852 },
853 [](std::string& sceneName, std::string value) {
854 return SystemSuspendController::GetInstance().SetPowerConfig(sceneName, value);
855 });
856 POWER_HILOGI(COMP_SVC, "RegisterExternalCallback Success");
857 dlclose(subscriberHandler);
858 subscriberHandler = nullptr;
859 }
860
UnregisterExternalCallback()861 void PowerMgrService::UnregisterExternalCallback()
862 {
863 POWER_HILOGI(COMP_SVC, "Start to UnregisterExternalCallback");
864 void* unSubscriberHandler = dlopen(POWER_MANAGER_EXT_PATH, RTLD_LAZY | RTLD_NODELETE);
865 if (unSubscriberHandler == nullptr) {
866 POWER_HILOGE(COMP_SVC, "Dlopen UnregisterExternalCallback failed, reason : %{public}s", dlerror());
867 return;
868 }
869
870 FuncUnregisterExternalCallback unregisterExternalCallback =
871 reinterpret_cast<FuncUnregisterExternalCallback>(dlsym(unSubscriberHandler, UNREGISTER_EXTERNAL_CONFIG));
872 if (unregisterExternalCallback == nullptr) {
873 POWER_HILOGE(COMP_SVC, "UnregisterExternalCallback is null, reason : %{public}s", dlerror());
874 dlclose(unSubscriberHandler);
875 unSubscriberHandler = nullptr;
876 return;
877 }
878 unregisterExternalCallback();
879 POWER_HILOGI(COMP_SVC, "UnregisterExternalCallback Success");
880 dlclose(unSubscriberHandler);
881 unSubscriberHandler = nullptr;
882 }
883
884 static const char* ON_CHARGE_STATE_CHANGED_CONFIG = "OnChargeStateChanged";
885 typedef void (*FuncOnChargeStateChanged)();
886
OnChargeStateChanged()887 void PowerMgrService::OnChargeStateChanged()
888 {
889 POWER_HILOGI(COMP_SVC, "Start to OnChargeStateChanged");
890 void* subscriberHandler = dlopen(POWER_MANAGER_EXT_PATH, RTLD_LAZY | RTLD_NODELETE);
891 if (subscriberHandler == nullptr) {
892 POWER_HILOGE(COMP_SVC, "Dlopen OnChargeStateChanged failed, reason : %{public}s", dlerror());
893 return;
894 }
895
896 FuncOnChargeStateChanged onChargeStateChanged =
897 reinterpret_cast<FuncOnChargeStateChanged>(dlsym(subscriberHandler, ON_CHARGE_STATE_CHANGED_CONFIG));
898 if (onChargeStateChanged == nullptr) {
899 POWER_HILOGE(COMP_SVC, "OnChargeStateChanged is null, reason : %{public}s", dlerror());
900 dlclose(subscriberHandler);
901 subscriberHandler = nullptr;
902 return;
903 }
904 onChargeStateChanged();
905 POWER_HILOGI(COMP_SVC, "OnChargeStateChanged Success");
906 dlclose(subscriberHandler);
907 subscriberHandler = nullptr;
908 }
909
Dump(int32_t fd,const std::vector<std::u16string> & args)910 int32_t PowerMgrService::Dump(int32_t fd, const std::vector<std::u16string>& args)
911 {
912 if (!isBootCompleted_) {
913 return ERR_NO_INIT;
914 }
915 if (!Permission::IsSystem()) {
916 return ERR_PERMISSION_DENIED;
917 }
918 std::vector<std::string> argsInStr;
919 std::transform(args.begin(), args.end(), std::back_inserter(argsInStr), [](const std::u16string& arg) {
920 std::string ret = Str16ToStr8(arg);
921 POWER_HILOGD(COMP_SVC, "arg: %{public}s", ret.c_str());
922 return ret;
923 });
924 std::string result;
925 PowerMgrDumper::Dump(argsInStr, result);
926 if (!SaveStringToFd(fd, result)) {
927 POWER_HILOGE(COMP_SVC, "Dump failed, save to fd failed.");
928 POWER_HILOGE(COMP_SVC, "Dump Info:\n");
929 POWER_HILOGE(COMP_SVC, "%{public}s", result.c_str());
930 return ERR_OK;
931 }
932 return ERR_OK;
933 }
934
RebootDevice(const std::string & reason)935 PowerErrors PowerMgrService::RebootDevice(const std::string& reason)
936 {
937 if (!Permission::IsSystem()) {
938 return PowerErrors::ERR_SYSTEM_API_DENIED;
939 }
940 return RebootDeviceForDeprecated(reason);
941 }
942
RebootDeviceForDeprecated(const std::string & reason)943 PowerErrors PowerMgrService::RebootDeviceForDeprecated(const std::string& reason)
944 {
945 std::lock_guard lock(shutdownMutex_);
946 pid_t pid = IPCSkeleton::GetCallingPid();
947 auto uid = IPCSkeleton::GetCallingUid();
948 if (!Permission::IsPermissionGranted("ohos.permission.REBOOT")) {
949 return PowerErrors::ERR_PERMISSION_DENIED;
950 }
951 POWER_HILOGI(FEATURE_SHUTDOWN, "Cancel auto sleep timer");
952 powerStateMachine_->CancelDelayTimer(PowerStateMachine::CHECK_USER_ACTIVITY_TIMEOUT_MSG);
953 powerStateMachine_->CancelDelayTimer(PowerStateMachine::CHECK_USER_ACTIVITY_OFF_TIMEOUT_MSG);
954 if (suspendController_) {
955 suspendController_->StopSleep();
956 }
957 POWER_KHILOGI(FEATURE_SHUTDOWN, "Do reboot, called pid: %{public}d, uid: %{public}d", pid, uid);
958 shutdownController_->Reboot(reason);
959 return PowerErrors::ERR_OK;
960 }
961
ShutDownDevice(const std::string & reason)962 PowerErrors PowerMgrService::ShutDownDevice(const std::string& reason)
963 {
964 auto now = static_cast<int64_t>(time(nullptr));
965 if (!Permission::IsSystem()) {
966 return PowerErrors::ERR_SYSTEM_API_DENIED;
967 }
968 if (!Permission::IsPermissionGranted("ohos.permission.REBOOT")) {
969 return PowerErrors::ERR_PERMISSION_DENIED;
970 }
971 if (reason == SHUTDOWN_FAST_REASON) {
972 g_wakeupReason = reason;
973 POWER_HILOGD(FEATURE_SHUTDOWN, "Calling Fast ShutDownDevice success");
974 return SuspendDevice(now, SuspendDeviceType::SUSPEND_DEVICE_REASON_STR, true);
975 }
976 g_wakeupReason = "";
977 std::lock_guard lock(shutdownMutex_);
978 pid_t pid = IPCSkeleton::GetCallingPid();
979 auto uid = IPCSkeleton::GetCallingUid();
980 POWER_HILOGI(FEATURE_SHUTDOWN, "Cancel auto sleep timer");
981 powerStateMachine_->CancelDelayTimer(PowerStateMachine::CHECK_USER_ACTIVITY_TIMEOUT_MSG);
982 powerStateMachine_->CancelDelayTimer(PowerStateMachine::CHECK_USER_ACTIVITY_OFF_TIMEOUT_MSG);
983 if (suspendController_) {
984 suspendController_->StopSleep();
985 }
986 SystemSuspendController::GetInstance().Wakeup(); // stop suspend loop
987
988 POWER_KHILOGI(FEATURE_SHUTDOWN, "[UL_POWER] Do shutdown, called pid: %{public}d, uid: %{public}d", pid, uid);
989 shutdownController_->Shutdown(reason);
990 return PowerErrors::ERR_OK;
991 }
992
SetSuspendTag(const std::string & tag)993 PowerErrors PowerMgrService::SetSuspendTag(const std::string& tag)
994 {
995 std::lock_guard lock(suspendMutex_);
996 pid_t pid = IPCSkeleton::GetCallingPid();
997 auto uid = IPCSkeleton::GetCallingUid();
998 if (!Permission::IsSystem()) {
999 return PowerErrors::ERR_SYSTEM_API_DENIED;
1000 }
1001 POWER_HILOGI(FEATURE_SUSPEND, "pid: %{public}d, uid: %{public}d, tag: %{public}s", pid, uid, tag.c_str());
1002 SystemSuspendController::GetInstance().SetSuspendTag(tag);
1003 return PowerErrors::ERR_OK;
1004 }
1005
SuspendDevice(int64_t callTimeMs,SuspendDeviceType reason,bool suspendImmed,const std::string & apiVersion)1006 PowerErrors PowerMgrService::SuspendDevice(
1007 int64_t callTimeMs, SuspendDeviceType reason, bool suspendImmed, const std::string& apiVersion)
1008 {
1009 std::lock_guard lock(suspendMutex_);
1010 pid_t pid = IPCSkeleton::GetCallingPid();
1011 auto uid = IPCSkeleton::GetCallingUid();
1012 if (!Permission::IsSystem()) {
1013 POWER_HILOGI(FEATURE_SUSPEND, "SuspendDevice failed, System permission intercept");
1014 return PowerErrors::ERR_SYSTEM_API_DENIED;
1015 }
1016 int32_t version = static_cast<int32_t>(strtol(apiVersion.c_str(), nullptr, 10));
1017 if (version >= API18 && !Permission::IsPermissionGranted("ohos.permission.POWER_MANAGER")) {
1018 POWER_HILOGI(FEATURE_SUSPEND, "SuspendDevice failed, The application does not have the permission");
1019 return PowerErrors::ERR_PERMISSION_DENIED;
1020 }
1021
1022 #ifdef POWER_MANAGER_ENABLE_WATCH_BOOT_COMPLETED
1023 if (isBootCompleted_ == false) {
1024 POWER_HILOGE(FEATURE_SUSPEND, "SuspendDevice failed, not boot completed, pid: %{public}d, uid: %{public}d",
1025 pid, uid);
1026 return PowerErrors::ERR_FAILURE;
1027 }
1028 #endif
1029
1030 if (shutdownController_->IsShuttingDown()) {
1031 POWER_HILOGW(FEATURE_SUSPEND, "System is shutting down, can't suspend");
1032 return PowerErrors::ERR_OK;
1033 }
1034 POWER_HILOGI(FEATURE_SUSPEND, "[UL_POWER] Try to suspend device, pid: %{public}d, uid: %{public}d", pid, uid);
1035 powerStateMachine_->SuspendDeviceInner(pid, callTimeMs, reason, suspendImmed);
1036 return PowerErrors::ERR_OK;
1037 }
1038
WakeupDevice(int64_t callTimeMs,WakeupDeviceType reason,const std::string & details,const std::string & apiVersion)1039 PowerErrors PowerMgrService::WakeupDevice(
1040 int64_t callTimeMs, WakeupDeviceType reason, const std::string& details, const std::string& apiVersion)
1041 {
1042 std::lock_guard lock(wakeupMutex_);
1043 if (!Permission::IsSystem()) {
1044 POWER_HILOGI(FEATURE_SUSPEND, "WakeupDevice failed, System permission intercept");
1045 return PowerErrors::ERR_SYSTEM_API_DENIED;
1046 }
1047 int32_t version = static_cast<int32_t>(strtol(apiVersion.c_str(), nullptr, 10));
1048 if (version >= API18 && !Permission::IsPermissionGranted("ohos.permission.POWER_MANAGER")) {
1049 POWER_HILOGI(FEATURE_SUSPEND, "WakeupDevice failed, The application does not have the permission");
1050 return PowerErrors::ERR_PERMISSION_DENIED;
1051 }
1052 pid_t pid = IPCSkeleton::GetCallingPid();
1053 auto uid = IPCSkeleton::GetCallingUid();
1054
1055 #ifdef POWER_MANAGER_ENABLE_WATCH_BOOT_COMPLETED
1056 if (isBootCompleted_ == false) {
1057 POWER_HILOGE(FEATURE_WAKEUP, "WakeupDevice failed, not boot completed, pid: %{public}d, uid: %{public}d",
1058 pid, uid);
1059 return PowerErrors::ERR_FAILURE;
1060 }
1061 #endif
1062
1063 POWER_HILOGI(FEATURE_WAKEUP, "[UL_POWER] Try to wakeup device, pid: %{public}d, uid: %{public}d", pid, uid);
1064
1065 BackgroundRunningLock wakeupRunningLock("WakeupLock", WAKEUP_LOCK_TIMEOUT_MS);
1066 if (details == "display_doze") {
1067 bool ret = powerStateMachine_->SetDozeMode(DisplayState::DISPLAY_DOZE);
1068 return ret ? PowerErrors::ERR_OK : PowerErrors::ERR_FAILURE;
1069 }
1070 if (details == "display_doze_suspend") {
1071 bool ret = powerStateMachine_->SetDozeMode(DisplayState::DISPLAY_DOZE_SUSPEND);
1072 return ret ? PowerErrors::ERR_OK : PowerErrors::ERR_FAILURE;
1073 }
1074 if (details == "display_off") {
1075 bool ret = powerStateMachine_->SetDozeMode(DisplayState::DISPLAY_OFF);
1076 return ret ? PowerErrors::ERR_OK : PowerErrors::ERR_FAILURE;
1077 }
1078 powerStateMachine_->WakeupDeviceInner(pid, callTimeMs, reason, details, "OHOS");
1079 return PowerErrors::ERR_OK;
1080 }
1081
RefreshActivity(int64_t callTimeMs,UserActivityType type,bool needChangeBacklight)1082 bool PowerMgrService::RefreshActivity(int64_t callTimeMs, UserActivityType type, bool needChangeBacklight)
1083 {
1084 if (!Permission::IsPermissionGranted("ohos.permission.REFRESH_USER_ACTION") || !Permission::IsSystem()) {
1085 return false;
1086 }
1087 pid_t pid = IPCSkeleton::GetCallingPid();
1088 auto uid = IPCSkeleton::GetCallingUid();
1089 POWER_HILOGI(FEATURE_ACTIVITY,
1090 "Try to refresh activity, pid: %{public}d, uid: %{public}d, activity type: %{public}u", pid, uid, type);
1091 return RefreshActivityInner(callTimeMs, type, needChangeBacklight);
1092 }
1093
RefreshActivityInner(int64_t callTimeMs,UserActivityType type,bool needChangeBacklight)1094 bool PowerMgrService::RefreshActivityInner(int64_t callTimeMs, UserActivityType type, bool needChangeBacklight)
1095 {
1096 std::lock_guard lock(screenMutex_);
1097 if (powerStateMachine_->CheckRefreshTime()) {
1098 return false;
1099 }
1100 pid_t pid = IPCSkeleton::GetCallingPid();
1101 powerStateMachine_->RefreshActivityInner(pid, callTimeMs, type, needChangeBacklight);
1102 return true;
1103 }
1104
OverrideScreenOffTime(int64_t timeout,const std::string & apiVersion)1105 PowerErrors PowerMgrService::OverrideScreenOffTime(int64_t timeout, const std::string& apiVersion)
1106 {
1107 std::lock_guard lock(screenMutex_);
1108 pid_t pid = IPCSkeleton::GetCallingPid();
1109 auto uid = IPCSkeleton::GetCallingUid();
1110 if (!Permission::IsSystem()) {
1111 POWER_HILOGI(COMP_SVC, "OverrideScreenOffTime failed, System permission intercept");
1112 return PowerErrors::ERR_SYSTEM_API_DENIED;
1113 }
1114 int32_t version = static_cast<int32_t>(strtol(apiVersion.c_str(), nullptr, 10));
1115 if (version >= API18 && !Permission::IsPermissionGranted("ohos.permission.POWER_MANAGER")) {
1116 POWER_HILOGI(FEATURE_SUSPEND, "OverrideScreenOffTime failed, The application does not have the permission");
1117 return PowerErrors::ERR_PERMISSION_DENIED;
1118 }
1119 POWER_HILOGI(COMP_SVC,
1120 "Try to override screenOffTime, timeout=%{public}" PRId64 ", pid: %{public}d, uid: %{public}d",
1121 timeout, pid, uid);
1122 return powerStateMachine_->OverrideScreenOffTimeInner(timeout) ?
1123 PowerErrors::ERR_OK : PowerErrors::ERR_FAILURE;
1124 }
1125
RestoreScreenOffTime(const std::string & apiVersion)1126 PowerErrors PowerMgrService::RestoreScreenOffTime(const std::string& apiVersion)
1127 {
1128 std::lock_guard lock(screenMutex_);
1129 if (!Permission::IsSystem()) {
1130 POWER_HILOGI(COMP_SVC, "RestoreScreenOffTime failed, System permission intercept");
1131 return PowerErrors::ERR_SYSTEM_API_DENIED;
1132 }
1133 int32_t version = static_cast<int32_t>(strtol(apiVersion.c_str(), nullptr, 10));
1134 if (version >= API18 && !Permission::IsPermissionGranted("ohos.permission.POWER_MANAGER")) {
1135 POWER_HILOGI(FEATURE_SUSPEND, "RestoreScreenOffTime failed, The application does not have the permission");
1136 return PowerErrors::ERR_PERMISSION_DENIED;
1137 }
1138 POWER_HILOGD(COMP_SVC, "Try to restore screen off time");
1139 return powerStateMachine_->RestoreScreenOffTimeInner() ?
1140 PowerErrors::ERR_OK : PowerErrors::ERR_FAILURE;
1141 }
1142
GetState()1143 PowerState PowerMgrService::GetState()
1144 {
1145 std::lock_guard lock(stateMutex_);
1146 auto state = powerStateMachine_->GetState();
1147 POWER_HILOGD(FEATURE_POWER_STATE, "state: %{public}d", state);
1148 return state;
1149 }
1150
IsScreenOn(bool needPrintLog)1151 bool PowerMgrService::IsScreenOn(bool needPrintLog)
1152 {
1153 std::lock_guard lock(stateMutex_);
1154 auto isScreenOn = powerStateMachine_->IsScreenOn();
1155 if (needPrintLog) {
1156 POWER_HILOGD(COMP_SVC, "isScreenOn: %{public}d", isScreenOn);
1157 }
1158 return isScreenOn;
1159 }
1160
IsFoldScreenOn()1161 bool PowerMgrService::IsFoldScreenOn()
1162 {
1163 std::lock_guard lock(stateMutex_);
1164 auto isFoldScreenOn = powerStateMachine_->IsFoldScreenOn();
1165 POWER_HILOGI(COMP_SVC, "isFoldScreenOn: %{public}d", isFoldScreenOn);
1166 return isFoldScreenOn;
1167 }
1168
IsCollaborationScreenOn()1169 bool PowerMgrService::IsCollaborationScreenOn()
1170 {
1171 std::lock_guard lock(stateMutex_);
1172 auto isCollaborationScreenOn = powerStateMachine_->IsCollaborationScreenOn();
1173 POWER_HILOGI(COMP_SVC, "isCollaborationScreenOn: %{public}d", isCollaborationScreenOn);
1174 return isCollaborationScreenOn;
1175 }
1176
ForceSuspendDevice(int64_t callTimeMs,const std::string & apiVersion)1177 PowerErrors PowerMgrService::ForceSuspendDevice(int64_t callTimeMs, const std::string& apiVersion)
1178 {
1179 std::lock_guard lock(suspendMutex_);
1180 pid_t pid = IPCSkeleton::GetCallingPid();
1181 auto uid = IPCSkeleton::GetCallingUid();
1182 if (!Permission::IsSystem()) {
1183 POWER_HILOGI(FEATURE_SUSPEND, "ForceSuspendDevice failed, System permission intercept");
1184 return PowerErrors::ERR_SYSTEM_API_DENIED;
1185 }
1186 int32_t version = static_cast<int32_t>(strtol(apiVersion.c_str(), nullptr, 10));
1187 if (version >= API18 && !Permission::IsPermissionGranted("ohos.permission.POWER_MANAGER")) {
1188 POWER_HILOGI(FEATURE_SUSPEND, "ForceSuspendDevice failed, The application does not have the permission");
1189 return PowerErrors::ERR_PERMISSION_DENIED;
1190 }
1191 if (shutdownController_->IsShuttingDown()) {
1192 POWER_HILOGI(FEATURE_SUSPEND, "System is shutting down, can't force suspend");
1193 return PowerErrors::ERR_FAILURE;
1194 }
1195 POWER_HILOGI(FEATURE_SUSPEND, "[UL_POWER] Try to force suspend device, pid: %{public}d, uid: %{public}d", pid, uid);
1196 powerStateMachine_->ForceSuspendDeviceInner(pid, callTimeMs);
1197 return PowerErrors::ERR_OK;
1198 }
1199
Hibernate(bool clearMemory,const std::string & apiVersion)1200 PowerErrors PowerMgrService::Hibernate(bool clearMemory, const std::string& apiVersion)
1201 {
1202 POWER_HILOGI(FEATURE_SUSPEND, "power mgr service hibernate begin.");
1203 if (!Permission::IsSystem()) {
1204 POWER_HILOGI(FEATURE_SUSPEND, "Hibernate failed, System permission intercept");
1205 return PowerErrors::ERR_SYSTEM_API_DENIED;
1206 }
1207 int32_t version = static_cast<int32_t>(strtol(apiVersion.c_str(), nullptr, 10));
1208 if (version >= API18 && !Permission::IsPermissionGranted("ohos.permission.POWER_MANAGER")) {
1209 POWER_HILOGI(FEATURE_SUSPEND, "Hibernate failed, The application does not have the permission");
1210 return PowerErrors::ERR_PERMISSION_DENIED;
1211 }
1212 #ifdef POWER_MANAGER_POWER_ENABLE_S4
1213 std::lock_guard lock(hibernateMutex_);
1214 pid_t pid = IPCSkeleton::GetCallingPid();
1215 auto uid = IPCSkeleton::GetCallingUid();
1216 if (shutdownController_->IsShuttingDown()) {
1217 POWER_HILOGI(FEATURE_SUSPEND, "System is shutting down, can't hibernate");
1218 return PowerErrors::ERR_FAILURE;
1219 }
1220 POWER_HILOGI(FEATURE_SUSPEND,
1221 "[UL_POWER] Try to hibernate, pid: %{public}d, uid: %{public}d, clearMemory: %{public}d",
1222 pid, uid, static_cast<int>(clearMemory));
1223 BackgroundRunningLock hibernateGuard(
1224 "hibernateGuard", HIBERNATE_GUARD_TIMEOUT_MS); // avoid hibernate breaked by S3/ULSR
1225 HibernateControllerInit();
1226 #ifdef HAS_HIVIEWDFX_HISYSEVENT_PART
1227 HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::POWER, "HIBERNATE_START",
1228 HiviewDFX::HiSysEvent::EventType::BEHAVIOR, "CLEAR_MEMORY", static_cast<int32_t>(clearMemory));
1229 #endif
1230 bool ret = powerStateMachine_->HibernateInner(clearMemory);
1231 return ret ? PowerErrors::ERR_OK : PowerErrors::ERR_FAILURE;
1232 #else
1233 POWER_HILOGI(FEATURE_SUSPEND, "Hibernate interface not supported.");
1234 return PowerErrors::ERR_FAILURE;
1235 #endif
1236 }
1237
GetBundleNameByUid(const int32_t uid)1238 std::string PowerMgrService::GetBundleNameByUid(const int32_t uid)
1239 {
1240 std::string tempBundleName = "";
1241 if (uid < OHOS::AppExecFwk::Constants::BASE_APP_UID) {
1242 return tempBundleName;
1243 }
1244 BundleMgrClient bundleObj;
1245
1246 std::string identity = IPCSkeleton::ResetCallingIdentity();
1247 ErrCode res = bundleObj.GetNameForUid(uid, tempBundleName);
1248 IPCSkeleton::SetCallingIdentity(identity);
1249 if (res != ERR_OK) {
1250 POWER_HILOGE(FEATURE_RUNNING_LOCK, "get B for U=%{public}d,Err:%{public}d",
1251 uid, static_cast<int32_t>(res));
1252 }
1253 POWER_HILOGD(FEATURE_RUNNING_LOCK, "U=%{public}d,B=%{public}s", uid, tempBundleName.c_str());
1254 return tempBundleName;
1255 }
1256
FillRunningLockParam(const RunningLockInfo & info,const uint64_t lockid,int32_t timeOutMS)1257 RunningLockParam PowerMgrService::FillRunningLockParam(const RunningLockInfo& info,
1258 const uint64_t lockid, int32_t timeOutMS)
1259 {
1260 RunningLockParam filledParam {};
1261 filledParam.lockid = lockid;
1262 filledParam.name = info.name;
1263 filledParam.type = info.type;
1264 if (filledParam.type == RunningLockType::RUNNINGLOCK_BACKGROUND) {
1265 filledParam.type = RunningLockType::RUNNINGLOCK_BACKGROUND_TASK;
1266 }
1267 filledParam.timeoutMs = timeOutMS;
1268 filledParam.pid = IPCSkeleton::GetCallingPid();
1269 filledParam.uid = IPCSkeleton::GetCallingUid();
1270 filledParam.bundleName = GetBundleNameByUid(filledParam.uid);
1271 return filledParam;
1272 }
1273
CreateRunningLock(const sptr<IRemoteObject> & remoteObj,const RunningLockInfo & runningLockInfo)1274 PowerErrors PowerMgrService::CreateRunningLock(
1275 const sptr<IRemoteObject>& remoteObj, const RunningLockInfo& runningLockInfo)
1276 {
1277 PowerXCollie powerXCollie("PowerMgrService::CreateRunningLock", true);
1278 std::lock_guard lock(lockMutex_);
1279 if (!Permission::IsPermissionGranted("ohos.permission.RUNNING_LOCK")) {
1280 return PowerErrors::ERR_PERMISSION_DENIED;
1281 }
1282 if (!IsRunningLockTypeSupported(runningLockInfo.type)) {
1283 POWER_HILOGW(FEATURE_RUNNING_LOCK,
1284 "runninglock type is not supported, name=%{public}s, type=%{public}d",
1285 runningLockInfo.name.c_str(), runningLockInfo.type);
1286 return PowerErrors::ERR_PARAM_INVALID;
1287 }
1288
1289 uintptr_t remoteObjPtr = reinterpret_cast<uintptr_t>(remoteObj.GetRefPtr());
1290 uint64_t lockid = std::hash<uintptr_t>()(remoteObjPtr);
1291 RunningLockParam runningLockParam = FillRunningLockParam(runningLockInfo, lockid);
1292 runningLockMgr_->CreateRunningLock(remoteObj, runningLockParam);
1293 return PowerErrors::ERR_OK;
1294 }
1295
ReleaseRunningLock(const sptr<IRemoteObject> & remoteObj,const std::string & name)1296 bool PowerMgrService::ReleaseRunningLock(const sptr<IRemoteObject>& remoteObj, const std::string& name)
1297 {
1298 PowerXCollie powerXCollie("PowerMgrService::ReleaseRunningLock", true);
1299 std::lock_guard lock(lockMutex_);
1300 bool result = false;
1301 if (!Permission::IsPermissionGranted("ohos.permission.RUNNING_LOCK")) {
1302 return result;
1303 }
1304
1305 result = runningLockMgr_->ReleaseLock(remoteObj, name);
1306 return result;
1307 }
1308
IsRunningLockTypeSupported(RunningLockType type)1309 bool PowerMgrService::IsRunningLockTypeSupported(RunningLockType type)
1310 {
1311 if (Permission::IsHap()) {
1312 if (Permission::IsSystem()) {
1313 return type <= RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL;
1314 }
1315 return type == RunningLockType::RUNNINGLOCK_BACKGROUND ||
1316 type == RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL;
1317 }
1318 return type == RunningLockType::RUNNINGLOCK_SCREEN ||
1319 type == RunningLockType::RUNNINGLOCK_BACKGROUND || // this will be instead by BACKGROUND_XXX types.
1320 type == RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL ||
1321 type == RunningLockType::RUNNINGLOCK_COORDINATION ||
1322 type == RunningLockType::RUNNINGLOCK_BACKGROUND_PHONE ||
1323 type == RunningLockType::RUNNINGLOCK_BACKGROUND_NOTIFICATION ||
1324 type == RunningLockType::RUNNINGLOCK_BACKGROUND_AUDIO ||
1325 type == RunningLockType::RUNNINGLOCK_BACKGROUND_SPORT ||
1326 type == RunningLockType::RUNNINGLOCK_BACKGROUND_NAVIGATION ||
1327 type == RunningLockType::RUNNINGLOCK_BACKGROUND_TASK;
1328 }
1329
UpdateWorkSource(const sptr<IRemoteObject> & remoteObj,const std::vector<int32_t> & workSources)1330 bool PowerMgrService::UpdateWorkSource(const sptr<IRemoteObject>& remoteObj,
1331 const std::vector<int32_t>& workSources)
1332 {
1333 PowerXCollie powerXCollie("PowerMgrService::UpdateWorkSource", true);
1334 if (!Permission::IsPermissionGranted("ohos.permission.RUNNING_LOCK")) {
1335 return false;
1336 }
1337 std::map<int32_t, std::string> wks;
1338 for (const auto& uid : workSources) {
1339 std::string bundleName = GetBundleNameByUid(uid);
1340 wks.emplace(std::make_pair(uid, bundleName));
1341 }
1342 std::lock_guard lock(lockMutex_);
1343 runningLockMgr_->UpdateWorkSource(remoteObj, wks);
1344 return true;
1345 }
1346
Lock(const sptr<IRemoteObject> & remoteObj,int32_t timeOutMs)1347 PowerErrors PowerMgrService::Lock(const sptr<IRemoteObject>& remoteObj, int32_t timeOutMs)
1348 {
1349 #ifdef HAS_HIVIEWDFX_HISYSEVENT_PART
1350 constexpr int32_t RUNNINGLOCK_TIMEOUT_MS = 50;
1351 int32_t beginTimeMs = GetTickCount();
1352 pid_t pid = IPCSkeleton::GetCallingPid();
1353 auto uid = IPCSkeleton::GetCallingUid();
1354 #endif
1355 PowerXCollie powerXCollie("PowerMgrService::Lock", true);
1356 if (!Permission::IsPermissionGranted("ohos.permission.RUNNING_LOCK")) {
1357 return PowerErrors::ERR_PERMISSION_DENIED;
1358 }
1359 std::lock_guard lock(lockMutex_);
1360 runningLockMgr_->Lock(remoteObj);
1361 if (timeOutMs > 0) {
1362 std::function<void()> task = [this, remoteObj, timeOutMs]() {
1363 std::lock_guard lock(lockMutex_);
1364 RunningLockTimerHandler::GetInstance().UnregisterRunningLockTimer(remoteObj);
1365 runningLockMgr_->UpdateWorkSource(remoteObj, {});
1366 runningLockMgr_->UnLock(remoteObj);
1367 };
1368 RunningLockTimerHandler::GetInstance().RegisterRunningLockTimer(remoteObj, task, timeOutMs);
1369 }
1370 #ifdef HAS_HIVIEWDFX_HISYSEVENT_PART
1371 int32_t endTimeMs = GetTickCount();
1372 if (endTimeMs - beginTimeMs > RUNNINGLOCK_TIMEOUT_MS) {
1373 POWER_HILOGI(FEATURE_RUNNING_LOCK, "Lock interface timeout=%{public}d", (endTimeMs - beginTimeMs));
1374 HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::POWER, "INTERFACE_CONSUMING_TIMEOUT",
1375 HiviewDFX::HiSysEvent::EventType::BEHAVIOR, "PID", pid, "UID", uid, "TYPE",
1376 static_cast<int32_t>(InterfaceTimeoutType::INTERFACE_TIMEOUT_TYPE_RUNNINGLOCK_LOCK), "REASON", "",
1377 "TIME", (endTimeMs - beginTimeMs));
1378 }
1379 #endif
1380 return PowerErrors::ERR_OK;
1381 }
1382
UnLock(const sptr<IRemoteObject> & remoteObj,const std::string & name)1383 PowerErrors PowerMgrService::UnLock(const sptr<IRemoteObject>& remoteObj, const std::string& name)
1384 {
1385 #ifdef HAS_HIVIEWDFX_HISYSEVENT_PART
1386 constexpr int32_t RUNNINGLOCK_TIMEOUT_MS = 50;
1387 int32_t beginTimeMs = GetTickCount();
1388 pid_t pid = IPCSkeleton::GetCallingPid();
1389 auto uid = IPCSkeleton::GetCallingUid();
1390 #endif
1391 PowerXCollie powerXCollie("PowerMgrService::UnLock", true);
1392 if (!Permission::IsPermissionGranted("ohos.permission.RUNNING_LOCK")) {
1393 return PowerErrors::ERR_PERMISSION_DENIED;
1394 }
1395 std::lock_guard lock(lockMutex_);
1396 RunningLockTimerHandler::GetInstance().UnregisterRunningLockTimer(remoteObj);
1397 runningLockMgr_->UnLock(remoteObj, name);
1398 #ifdef HAS_HIVIEWDFX_HISYSEVENT_PART
1399 int32_t endTimeMs = GetTickCount();
1400 if (endTimeMs - beginTimeMs > RUNNINGLOCK_TIMEOUT_MS) {
1401 POWER_HILOGI(FEATURE_RUNNING_LOCK, "UnLock interface timeout=%{public}d", (endTimeMs - beginTimeMs));
1402 HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::POWER, "INTERFACE_CONSUMING_TIMEOUT",
1403 HiviewDFX::HiSysEvent::EventType::BEHAVIOR, "PID", pid, "UID", uid, "TYPE",
1404 static_cast<int32_t>(InterfaceTimeoutType::INTERFACE_TIMEOUT_TYPE_RUNNINGLOCK_UNLOCK), "REASON", "",
1405 "TIME", (endTimeMs - beginTimeMs));
1406 }
1407 #endif
1408 return PowerErrors::ERR_OK;
1409 }
1410
QueryRunningLockLists(std::map<std::string,RunningLockInfo> & runningLockLists)1411 bool PowerMgrService::QueryRunningLockLists(std::map<std::string, RunningLockInfo>& runningLockLists)
1412 {
1413 PowerXCollie powerXCollie("PowerMgrService::QueryRunningLockLists", true);
1414 std::lock_guard lock(lockMutex_);
1415 if (!Permission::IsPermissionGranted("ohos.permission.RUNNING_LOCK")) {
1416 return false;
1417 }
1418 QueryRunningLockListsInner(runningLockLists);
1419 return true;
1420 }
1421
QueryRunningLockListsInner(std::map<std::string,RunningLockInfo> & runningLockLists)1422 void PowerMgrService::QueryRunningLockListsInner(std::map<std::string, RunningLockInfo>& runningLockLists)
1423 {
1424 runningLockMgr_->QueryRunningLockLists(runningLockLists);
1425 }
1426
RegisterRunningLockCallback(const sptr<IPowerRunninglockCallback> & callback)1427 bool PowerMgrService::RegisterRunningLockCallback(const sptr<IPowerRunninglockCallback>& callback)
1428 {
1429 std::lock_guard lock(lockMutex_);
1430 pid_t pid = IPCSkeleton::GetCallingPid();
1431 auto uid = IPCSkeleton::GetCallingUid();
1432 if (!Permission::IsPermissionGranted("ohos.permission.POWER_MANAGER")) {
1433 return false;
1434 }
1435 POWER_HILOGI(FEATURE_RUNNING_LOCK, "%{public}s: pid: %{public}d, uid: %{public}d", __func__, pid, uid);
1436 runningLockMgr_->RegisterRunningLockCallback(callback);
1437 return true;
1438 }
1439
UnRegisterRunningLockCallback(const sptr<IPowerRunninglockCallback> & callback)1440 bool PowerMgrService::UnRegisterRunningLockCallback(const sptr<IPowerRunninglockCallback>& callback)
1441 {
1442 std::lock_guard lock(lockMutex_);
1443 pid_t pid = IPCSkeleton::GetCallingPid();
1444 auto uid = IPCSkeleton::GetCallingUid();
1445 if (!Permission::IsPermissionGranted("ohos.permission.POWER_MANAGER")) {
1446 return false;
1447 }
1448 POWER_HILOGI(FEATURE_RUNNING_LOCK, "%{public}s: pid: %{public}d, uid: %{public}d", __func__, pid, uid);
1449 runningLockMgr_->RegisterRunningLockCallback(callback);
1450 return true;
1451 }
1452
ForceUnLock(const sptr<IRemoteObject> & remoteObj)1453 void PowerMgrService::ForceUnLock(const sptr<IRemoteObject>& remoteObj)
1454 {
1455 PowerXCollie powerXCollie("PowerMgrService::ForceUnLock", true);
1456 std::lock_guard lock(lockMutex_);
1457 runningLockMgr_->UnLock(remoteObj);
1458 runningLockMgr_->ReleaseLock(remoteObj);
1459 }
1460
IsUsed(const sptr<IRemoteObject> & remoteObj)1461 bool PowerMgrService::IsUsed(const sptr<IRemoteObject>& remoteObj)
1462 {
1463 PowerXCollie powerXCollie("PowerMgrService::IsUsed", true);
1464 std::lock_guard lock(lockMutex_);
1465 auto isUsed = runningLockMgr_->IsUsed(remoteObj);
1466 POWER_HILOGD(FEATURE_RUNNING_LOCK, "RunningLock is Used: %{public}d", isUsed);
1467 return isUsed;
1468 }
1469
ProxyRunningLock(bool isProxied,pid_t pid,pid_t uid)1470 bool PowerMgrService::ProxyRunningLock(bool isProxied, pid_t pid, pid_t uid)
1471 {
1472 PowerXCollie powerXCollie("PowerMgrService::ProxyRunningLock", true);
1473 std::lock_guard lock(lockMutex_);
1474 if (!Permission::IsSystem()) {
1475 return false;
1476 }
1477 return runningLockMgr_->ProxyRunningLock(isProxied, pid, uid);
1478 }
1479
ProxyRunningLocks(bool isProxied,const std::vector<std::pair<pid_t,pid_t>> & processInfos)1480 bool PowerMgrService::ProxyRunningLocks(bool isProxied, const std::vector<std::pair<pid_t, pid_t>>& processInfos)
1481 {
1482 PowerXCollie powerXCollie("PowerMgrService::ProxyRunningLocks", true);
1483 if (!Permission::IsSystem()) {
1484 return false;
1485 }
1486 std::lock_guard lock(lockMutex_);
1487 runningLockMgr_->ProxyRunningLocks(isProxied, processInfos);
1488 return true;
1489 }
1490
ResetRunningLocks()1491 bool PowerMgrService::ResetRunningLocks()
1492 {
1493 PowerXCollie powerXCollie("PowerMgrService::ResetRunningLocks", true);
1494 if (!Permission::IsSystem()) {
1495 return false;
1496 }
1497 std::lock_guard lock(lockMutex_);
1498 runningLockMgr_->ResetRunningLocks();
1499 return true;
1500 }
1501
RegisterPowerStateCallback(const sptr<IPowerStateCallback> & callback,bool isSync)1502 bool PowerMgrService::RegisterPowerStateCallback(const sptr<IPowerStateCallback>& callback, bool isSync)
1503 {
1504 std::lock_guard lock(stateMutex_);
1505 pid_t pid = IPCSkeleton::GetCallingPid();
1506 auto uid = IPCSkeleton::GetCallingUid();
1507 if (!Permission::IsPermissionGranted("ohos.permission.POWER_MANAGER")) {
1508 return false;
1509 }
1510 POWER_HILOGI(FEATURE_POWER_STATE, "%{public}s: pid: %{public}d, uid: %{public}d, isSync: %{public}u", __func__, pid,
1511 uid, static_cast<uint32_t>(isSync));
1512 powerStateMachine_->RegisterPowerStateCallback(callback, isSync);
1513 return true;
1514 }
1515
UnRegisterPowerStateCallback(const sptr<IPowerStateCallback> & callback)1516 bool PowerMgrService::UnRegisterPowerStateCallback(const sptr<IPowerStateCallback>& callback)
1517 {
1518 std::lock_guard lock(stateMutex_);
1519 pid_t pid = IPCSkeleton::GetCallingPid();
1520 auto uid = IPCSkeleton::GetCallingUid();
1521 if (!Permission::IsPermissionGranted("ohos.permission.POWER_MANAGER")) {
1522 return false;
1523 }
1524 POWER_HILOGI(FEATURE_POWER_STATE, "%{public}s: pid: %{public}d, uid: %{public}d", __func__, pid, uid);
1525 powerStateMachine_->UnRegisterPowerStateCallback(callback);
1526 return true;
1527 }
1528
RegisterSyncSleepCallback(const sptr<ISyncSleepCallback> & callback,SleepPriority priority)1529 bool PowerMgrService::RegisterSyncSleepCallback(const sptr<ISyncSleepCallback>& callback, SleepPriority priority)
1530 {
1531 std::lock_guard lock(suspendMutex_);
1532 pid_t pid = IPCSkeleton::GetCallingPid();
1533 auto uid = IPCSkeleton::GetCallingUid();
1534 if (!Permission::IsPermissionGranted("ohos.permission.POWER_MANAGER")) {
1535 return false;
1536 }
1537 POWER_HILOGI(FEATURE_SUSPEND, "%{public}s: pid: %{public}d, uid: %{public}d", __func__, pid, uid);
1538 suspendController_->AddCallback(callback, priority);
1539 return true;
1540 }
1541
UnRegisterSyncSleepCallback(const sptr<ISyncSleepCallback> & callback)1542 bool PowerMgrService::UnRegisterSyncSleepCallback(const sptr<ISyncSleepCallback>& callback)
1543 {
1544 std::lock_guard lock(suspendMutex_);
1545 pid_t pid = IPCSkeleton::GetCallingPid();
1546 auto uid = IPCSkeleton::GetCallingUid();
1547 if (!Permission::IsPermissionGranted("ohos.permission.POWER_MANAGER")) {
1548 return false;
1549 }
1550 POWER_HILOGI(FEATURE_SUSPEND, "%{public}s: pid: %{public}d, uid: %{public}d", __func__, pid, uid);
1551 suspendController_->RemoveCallback(callback);
1552 return true;
1553 }
1554
RegisterSyncHibernateCallback(const sptr<ISyncHibernateCallback> & callback)1555 bool PowerMgrService::RegisterSyncHibernateCallback(const sptr<ISyncHibernateCallback>& callback)
1556 {
1557 #ifdef POWER_MANAGER_POWER_ENABLE_S4
1558 POWER_HILOGI(FEATURE_SUSPEND, "RegisterSyncHibernateCallback begin.");
1559 HibernateControllerInit();
1560 hibernateController_->RegisterSyncHibernateCallback(callback);
1561 return true;
1562 #else
1563 POWER_HILOGI(FEATURE_SUSPEND, "RegisterSyncHibernateCallback interface not supported.");
1564 return false;
1565 #endif
1566 }
1567
UnRegisterSyncHibernateCallback(const sptr<ISyncHibernateCallback> & callback)1568 bool PowerMgrService::UnRegisterSyncHibernateCallback(const sptr<ISyncHibernateCallback>& callback)
1569 {
1570 #ifdef POWER_MANAGER_POWER_ENABLE_S4
1571 POWER_HILOGI(FEATURE_SUSPEND, "UnRegisterSyncHibernateCallback begin.");
1572 HibernateControllerInit();
1573 hibernateController_->UnregisterSyncHibernateCallback(callback);
1574 return true;
1575 #else
1576 POWER_HILOGI(FEATURE_SUSPEND, "UnRegisterSyncHibernateCallback interface not supported.");
1577 return false;
1578 #endif
1579 }
1580
RegisterPowerModeCallback(const sptr<IPowerModeCallback> & callback)1581 bool PowerMgrService::RegisterPowerModeCallback(const sptr<IPowerModeCallback>& callback)
1582 {
1583 std::lock_guard lock(modeMutex_);
1584 pid_t pid = IPCSkeleton::GetCallingPid();
1585 auto uid = IPCSkeleton::GetCallingUid();
1586 if (!Permission::IsSystem()) {
1587 return false;
1588 }
1589 POWER_HILOGI(FEATURE_POWER_MODE, "%{public}s: pid: %{public}d, uid: %{public}d", __func__, pid, uid);
1590 powerModeModule_.AddPowerModeCallback(callback);
1591 return true;
1592 }
1593
UnRegisterPowerModeCallback(const sptr<IPowerModeCallback> & callback)1594 bool PowerMgrService::UnRegisterPowerModeCallback(const sptr<IPowerModeCallback>& callback)
1595 {
1596 std::lock_guard lock(modeMutex_);
1597 pid_t pid = IPCSkeleton::GetCallingPid();
1598 auto uid = IPCSkeleton::GetCallingUid();
1599 if (!Permission::IsSystem()) {
1600 return false;
1601 }
1602 POWER_HILOGI(FEATURE_POWER_MODE, "%{public}s: pid: %{public}d, uid: %{public}d", __func__, pid, uid);
1603 powerModeModule_.DelPowerModeCallback(callback);
1604 return true;
1605 }
1606
RegisterScreenStateCallback(int32_t remainTime,const sptr<IScreenOffPreCallback> & callback)1607 bool PowerMgrService::RegisterScreenStateCallback(int32_t remainTime, const sptr<IScreenOffPreCallback>& callback)
1608 {
1609 std::lock_guard lock(screenOffPreMutex_);
1610 pid_t pid = IPCSkeleton::GetCallingPid();
1611 auto uid = IPCSkeleton::GetCallingUid();
1612 if (!Permission::IsSystem()) {
1613 return false;
1614 }
1615 POWER_HILOGI(FEATURE_SCREEN_OFF_PRE, "%{public}s: pid: %{public}d, uid: %{public}d", __func__, pid, uid);
1616 screenOffPreController_->AddScreenStateCallback(remainTime, callback);
1617 return true;
1618 }
1619
UnRegisterScreenStateCallback(const sptr<IScreenOffPreCallback> & callback)1620 bool PowerMgrService::UnRegisterScreenStateCallback(const sptr<IScreenOffPreCallback>& callback)
1621 {
1622 std::lock_guard lock(screenOffPreMutex_);
1623 pid_t pid = IPCSkeleton::GetCallingPid();
1624 auto uid = IPCSkeleton::GetCallingUid();
1625 if (!Permission::IsSystem()) {
1626 return false;
1627 }
1628 POWER_HILOGI(FEATURE_SCREEN_OFF_PRE, "%{public}s: pid: %{public}d, uid: %{public}d", __func__, pid, uid);
1629 screenOffPreController_->DelScreenStateCallback(callback);
1630 return true;
1631 }
1632
SetDisplaySuspend(bool enable)1633 bool PowerMgrService::SetDisplaySuspend(bool enable)
1634 {
1635 std::lock_guard lock(screenMutex_);
1636 pid_t pid = IPCSkeleton::GetCallingPid();
1637 auto uid = IPCSkeleton::GetCallingUid();
1638 if (!Permission::IsSystem()) {
1639 return false;
1640 }
1641 POWER_HILOGI(FEATURE_SUSPEND, "%{public}s: pid: %{public}d, uid: %{public}d, enable: %{public}d",
1642 __func__, pid, uid, enable);
1643 powerStateMachine_->SetDisplaySuspend(enable);
1644 return true;
1645 }
1646
SetDeviceMode(const PowerMode & mode)1647 PowerErrors PowerMgrService::SetDeviceMode(const PowerMode& mode)
1648 {
1649 std::lock_guard lock(modeMutex_);
1650 pid_t pid = IPCSkeleton::GetCallingPid();
1651 auto uid = IPCSkeleton::GetCallingUid();
1652 POWER_HILOGI(FEATURE_POWER_MODE, "%{public}s: pid: %{public}d, uid: %{public}d, mode: %{public}u",
1653 __func__, pid, uid, mode);
1654 if (!Permission::IsSystem()) {
1655 return PowerErrors::ERR_SYSTEM_API_DENIED;
1656 }
1657 if (!Permission::IsPermissionGranted("ohos.permission.POWER_OPTIMIZATION")) {
1658 return PowerErrors::ERR_PERMISSION_DENIED;
1659 }
1660 powerModeModule_.SetModeItem(mode);
1661 return PowerErrors::ERR_OK;
1662 }
1663
GetDeviceMode()1664 PowerMode PowerMgrService::GetDeviceMode()
1665 {
1666 std::lock_guard lock(modeMutex_);
1667 pid_t pid = IPCSkeleton::GetCallingPid();
1668 auto uid = IPCSkeleton::GetCallingUid();
1669 auto mode = powerModeModule_.GetModeItem();
1670 POWER_HILOGI(FEATURE_POWER_MODE, "%{public}s: pid: %{public}d, uid: %{public}d, mode: %{public}u",
1671 __func__, pid, uid, mode);
1672 return mode;
1673 }
1674
ShellDump(const std::vector<std::string> & args,uint32_t argc)1675 std::string PowerMgrService::ShellDump(const std::vector<std::string>& args, uint32_t argc)
1676 {
1677 if (!Permission::IsSystem() || !isBootCompleted_) {
1678 return "";
1679 }
1680 std::lock_guard lock(dumpMutex_);
1681 pid_t pid = IPCSkeleton::GetCallingPid();
1682 auto uid = IPCSkeleton::GetCallingUid();
1683
1684 std::string result;
1685 bool ret = PowerMgrDumper::Dump(args, result);
1686 POWER_HILOGI(COMP_SVC, "%{public}s: pid: %{public}d, uid: %{public}d ret :%{public}d", __func__, pid, uid, ret);
1687 return result;
1688 }
1689
RegisterShutdownCallback(const sptr<ITakeOverShutdownCallback> & callback,ShutdownPriority priority)1690 void PowerMgrService::RegisterShutdownCallback(
1691 const sptr<ITakeOverShutdownCallback>& callback, ShutdownPriority priority)
1692 {
1693 RETURN_IF (callback == nullptr);
1694 RETURN_IF (!Permission::IsSystem());
1695
1696 std::lock_guard lock(shutdownMutex_);
1697 shutdownController_->AddCallback(callback, priority);
1698 }
1699
UnRegisterShutdownCallback(const sptr<ITakeOverShutdownCallback> & callback)1700 void PowerMgrService::UnRegisterShutdownCallback(const sptr<ITakeOverShutdownCallback>& callback)
1701 {
1702 RETURN_IF (callback == nullptr);
1703 RETURN_IF (!Permission::IsSystem());
1704
1705 std::lock_guard lock(shutdownMutex_);
1706 shutdownController_->RemoveCallback(callback);
1707 }
1708
RegisterShutdownCallback(const sptr<IAsyncShutdownCallback> & callback,ShutdownPriority priority)1709 void PowerMgrService::RegisterShutdownCallback(
1710 const sptr<IAsyncShutdownCallback>& callback, ShutdownPriority priority)
1711 {
1712 RETURN_IF (callback == nullptr);
1713 RETURN_IF (!Permission::IsSystem());
1714
1715 std::lock_guard lock(shutdownMutex_);
1716 shutdownController_->AddCallback(callback, priority);
1717 }
1718
UnRegisterShutdownCallback(const sptr<IAsyncShutdownCallback> & callback)1719 void PowerMgrService::UnRegisterShutdownCallback(const sptr<IAsyncShutdownCallback>& callback)
1720 {
1721 RETURN_IF (callback == nullptr);
1722 RETURN_IF (!Permission::IsSystem());
1723
1724 std::lock_guard lock(shutdownMutex_);
1725 shutdownController_->RemoveCallback(callback);
1726 }
1727
RegisterShutdownCallback(const sptr<ISyncShutdownCallback> & callback,ShutdownPriority priority)1728 void PowerMgrService::RegisterShutdownCallback(
1729 const sptr<ISyncShutdownCallback>& callback, ShutdownPriority priority)
1730 {
1731 RETURN_IF (callback == nullptr);
1732 RETURN_IF (!Permission::IsSystem());
1733
1734 std::lock_guard lock(shutdownMutex_);
1735 shutdownController_->AddCallback(callback, priority);
1736 }
1737
UnRegisterShutdownCallback(const sptr<ISyncShutdownCallback> & callback)1738 void PowerMgrService::UnRegisterShutdownCallback(const sptr<ISyncShutdownCallback>& callback)
1739 {
1740 RETURN_IF (callback == nullptr);
1741 RETURN_IF (!Permission::IsSystem());
1742
1743 std::lock_guard lock(shutdownMutex_);
1744 shutdownController_->RemoveCallback(callback);
1745 }
1746
BackgroundRunningLock(std::string name,int32_t timeOutMs)1747 PowerMgrService::BackgroundRunningLock::BackgroundRunningLock(std::string name, int32_t timeOutMs)
1748 {
1749 token_ = new (std::nothrow) RunningLockTokenStub();
1750 if (token_ == nullptr) {
1751 POWER_HILOGE(COMP_SVC, "create runninglock token failed");
1752 return;
1753 }
1754 RunningLockInfo info = {name, OHOS::PowerMgr::RunningLockType::RUNNINGLOCK_BACKGROUND};
1755 pms->CreateRunningLock(token_, info);
1756 pms->Lock(token_, timeOutMs);
1757 }
1758
~BackgroundRunningLock()1759 PowerMgrService::BackgroundRunningLock::~BackgroundRunningLock()
1760 {
1761 if (token_ == nullptr) {
1762 POWER_HILOGE(COMP_SVC, "token_ is nullptr");
1763 return;
1764 }
1765 pms->ReleaseRunningLock(token_);
1766 }
1767
SuspendControllerInit()1768 void PowerMgrService::SuspendControllerInit()
1769 {
1770 if (!suspendController_) {
1771 suspendController_ = std::make_shared<SuspendController>(shutdownController_, powerStateMachine_, ffrtTimer_);
1772 }
1773 suspendController_->Init();
1774 }
1775
WakeupControllerInit()1776 void PowerMgrService::WakeupControllerInit()
1777 {
1778 if (!wakeupController_) {
1779 wakeupController_ = std::make_shared<WakeupController>(powerStateMachine_);
1780 }
1781 wakeupController_->Init();
1782 }
1783
1784 #ifdef POWER_MANAGER_POWER_ENABLE_S4
HibernateControllerInit()1785 void PowerMgrService::HibernateControllerInit()
1786 {
1787 if (!hibernateController_) {
1788 hibernateController_ = std::make_shared<HibernateController>();
1789 }
1790 }
1791 #endif
1792
IsCollaborationState()1793 bool PowerMgrService::IsCollaborationState()
1794 {
1795 bool collaborationState = false;
1796 auto pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
1797 if (pms == nullptr) {
1798 return collaborationState;
1799 }
1800 auto stateMachine = pms->GetPowerStateMachine();
1801 if (stateMachine == nullptr) {
1802 return collaborationState;
1803 }
1804 collaborationState = stateMachine->IsRunningLockEnabled(RunningLockType::RUNNINGLOCK_COORDINATION);
1805 return collaborationState;
1806 }
1807
1808 #ifdef POWER_MANAGER_WAKEUP_ACTION
WakeupActionControllerInit()1809 void PowerMgrService::WakeupActionControllerInit()
1810 {
1811 if (!wakeupActionController_) {
1812 wakeupActionController_ = std::make_shared<WakeupActionController>(shutdownController_, powerStateMachine_);
1813 }
1814 wakeupActionController_->Init();
1815 }
1816 #endif
1817
1818 #ifdef POWER_MANAGER_ENABLE_CHARGING_TYPE_SETTING
PowerConnectStatusInit()1819 void PowerMgrService::PowerConnectStatusInit()
1820 {
1821 auto pluggedType = BatterySrvClient::GetInstance().GetPluggedType();
1822 if (pluggedType == BatteryPluggedType::PLUGGED_TYPE_BUTT) {
1823 POWER_HILOGE(COMP_SVC, "BatterySrvClient GetPluggedType error");
1824 SetPowerConnectStatus(PowerConnectStatus::POWER_CONNECT_INVALID);
1825 } else if ((pluggedType == BatteryPluggedType::PLUGGED_TYPE_AC) ||
1826 (pluggedType == BatteryPluggedType::PLUGGED_TYPE_USB) ||
1827 (pluggedType == BatteryPluggedType::PLUGGED_TYPE_WIRELESS)) {
1828 SetPowerConnectStatus(PowerConnectStatus::POWER_CONNECT_AC);
1829 } else {
1830 SetPowerConnectStatus(PowerConnectStatus::POWER_CONNECT_DC);
1831 }
1832 }
1833
IsPowerConnected()1834 bool PowerMgrService::IsPowerConnected()
1835 {
1836 if (GetPowerConnectStatus() == PowerConnectStatus::POWER_CONNECT_INVALID) {
1837 PowerConnectStatusInit(); // try to init again if invalid
1838 }
1839 return GetPowerConnectStatus() == PowerConnectStatus::POWER_CONNECT_AC;
1840 }
1841 #endif
1842
VibratorInit()1843 void PowerMgrService::VibratorInit()
1844 {
1845 std::shared_ptr<PowerVibrator> vibrator = PowerVibrator::GetInstance();
1846 vibrator->LoadConfig(POWER_VIBRATOR_CONFIG_FILE,
1847 VENDOR_POWER_VIBRATOR_CONFIG_FILE, SYSTEM_POWER_VIBRATOR_CONFIG_FILE);
1848 }
1849
IsStandby(bool & isStandby)1850 PowerErrors PowerMgrService::IsStandby(bool& isStandby)
1851 {
1852 #ifdef HAS_DEVICE_STANDBY_PART
1853 DevStandbyMgr::StandbyServiceClient& standbyServiceClient = DevStandbyMgr::StandbyServiceClient::GetInstance();
1854 ErrCode code = standbyServiceClient.IsDeviceInStandby(isStandby);
1855 if (code == ERR_OK) {
1856 return PowerErrors::ERR_OK;
1857 }
1858 return PowerErrors::ERR_FAILURE;
1859 #else
1860 return PowerErrors::ERR_OK;
1861 #endif
1862 }
1863
OnRemoteDied(const wptr<IRemoteObject> & remote)1864 void PowerMgrService::InvokerDeathRecipient::OnRemoteDied(const wptr<IRemoteObject>& remote)
1865 {
1866 POWER_HILOGI(COMP_SVC, "OnRemoteDied Called");
1867 if (!remote.promote()) {
1868 POWER_HILOGI(COMP_SVC, "proxy no longer exists, return early");
1869 return;
1870 }
1871 POWER_HILOGI(COMP_SVC, "the last client using %{public}s has died", interfaceName_.c_str());
1872 auto pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
1873 if (!pms) {
1874 POWER_HILOGE(COMP_SVC, "cannot get PowerMgrService, return early");
1875 return;
1876 }
1877 callback_(pms);
1878 }
1879
SetForceTimingOut(bool enabled,const sptr<IRemoteObject> & token)1880 PowerErrors PowerMgrService::SetForceTimingOut(bool enabled, const sptr<IRemoteObject>& token)
1881 {
1882 static sptr<IRemoteObject> thisInterfaceInvoker = nullptr;
1883 static std::mutex localMutex;
1884 static sptr<InvokerDeathRecipient> drt =
1885 sptr<InvokerDeathRecipient>::MakeSptr(__func__, [](const sptr<PowerMgrService>& pms) {
1886 auto stateMachine = pms->GetPowerStateMachine();
1887 if (!stateMachine) {
1888 POWER_HILOGE(COMP_SVC, "cannot get PowerStateMachine, return early");
1889 return;
1890 }
1891 stateMachine->SetForceTimingOut(false);
1892 POWER_HILOGI(COMP_SVC, "the variables related to SetForceTimingOut has been reset");
1893 });
1894
1895 if (!Permission::IsSystem()) {
1896 return PowerErrors::ERR_SYSTEM_API_DENIED;
1897 }
1898
1899 // even if drt is nullptr(unlikely), it will be checked in IPCObjectProxy::SendObituary()
1900 localMutex.lock();
1901 if (token && token->IsProxyObject() && token != thisInterfaceInvoker) {
1902 // The localMutex only ensures that the "remove, assign, add" actions for THIS drt are thread safe.
1903 // AddDeathRecipient/RemoveDeathRecipient are thread safe theirselves.
1904 // Different remote objects(invokers) do not interfere wich each other
1905 // Different DeathRecipients for the same invoker do not interfere wich each other
1906 // Only one RemoteObject may hold the death recipient defined in this method and only once.
1907 if (thisInterfaceInvoker) {
1908 thisInterfaceInvoker->RemoveDeathRecipient(drt);
1909 } // removed from the old invoker
1910 thisInterfaceInvoker = token;
1911 thisInterfaceInvoker->AddDeathRecipient(drt); // added to the new invoker
1912 }
1913 localMutex.unlock();
1914 powerStateMachine_->SetForceTimingOut(enabled);
1915 return PowerErrors::ERR_OK;
1916 }
1917
LockScreenAfterTimingOut(bool enabledLockScreen,bool checkLock,bool sendScreenOffEvent,const sptr<IRemoteObject> & token)1918 PowerErrors PowerMgrService::LockScreenAfterTimingOut(
1919 bool enabledLockScreen, bool checkLock, bool sendScreenOffEvent, const sptr<IRemoteObject>& token)
1920 {
1921 static sptr<IRemoteObject> thisInterfaceInvoker = nullptr;
1922 static std::mutex localMutex;
1923 static sptr<InvokerDeathRecipient> drt =
1924 sptr<InvokerDeathRecipient>::MakeSptr(__func__, [](sptr<PowerMgrService> pms) {
1925 auto stateMachine = pms->GetPowerStateMachine();
1926 if (!stateMachine) {
1927 POWER_HILOGE(COMP_SVC, "cannot get PowerStateMachine, return early");
1928 return;
1929 }
1930 stateMachine->LockScreenAfterTimingOut(true, false, true);
1931 POWER_HILOGI(COMP_SVC, "the variables related to LockScreenAfterTimingOut has been reset");
1932 });
1933
1934 if (!Permission::IsSystem()) {
1935 return PowerErrors::ERR_SYSTEM_API_DENIED;
1936 }
1937 localMutex.lock();
1938 if (token && token->IsProxyObject() && token != thisInterfaceInvoker) {
1939 // The localMutex only ensures that the "remove, assign, add" actions are thread safe.
1940 // AddDeathRecipient/RemoveDeathRecipient are thread safe theirselves.
1941 if (thisInterfaceInvoker) {
1942 thisInterfaceInvoker->RemoveDeathRecipient(drt);
1943 } // removed from the old invoker
1944 thisInterfaceInvoker = token;
1945 thisInterfaceInvoker->AddDeathRecipient(drt); // added to the new invoker
1946 }
1947 localMutex.unlock();
1948 powerStateMachine_->LockScreenAfterTimingOut(enabledLockScreen, checkLock, sendScreenOffEvent);
1949 return PowerErrors::ERR_OK;
1950 }
1951
SetEnableDoze(bool enable)1952 void PowerMgrService::SetEnableDoze(bool enable)
1953 {
1954 auto stateMachine = pms->GetPowerStateMachine();
1955 if (stateMachine == nullptr) {
1956 return;
1957 }
1958 stateMachine->SetEnableDoze(enable);
1959 }
1960
1961 #ifdef HAS_MULTIMODALINPUT_INPUT_PART
OnInputEvent(std::shared_ptr<KeyEvent> keyEvent) const1962 void PowerMgrInputMonitor::OnInputEvent(std::shared_ptr<KeyEvent> keyEvent) const
1963 {
1964 auto pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
1965 if (pms == nullptr) {
1966 return;
1967 }
1968 auto stateMachine = pms->GetPowerStateMachine();
1969 if (stateMachine == nullptr) {
1970 return;
1971 }
1972 if (keyEvent->GetDeviceId() == COLLABORATION_REMOTE_DEVICE_ID &&
1973 stateMachine->IsRunningLockEnabled(RunningLockType::RUNNINGLOCK_COORDINATION) &&
1974 stateMachine->GetState() == PowerState::AWAKE) {
1975 stateMachine->SetState(PowerState::DIM, StateChangeReason::STATE_CHANGE_REASON_COORDINATION, true);
1976 POWER_HILOGD(FEATURE_INPUT, "remote Key event in coordinated state, override screen off time");
1977 }
1978 }
1979
OnInputEvent(std::shared_ptr<PointerEvent> pointerEvent) const1980 void PowerMgrInputMonitor::OnInputEvent(std::shared_ptr<PointerEvent> pointerEvent) const
1981 {
1982 auto pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
1983 if (pms == nullptr) {
1984 return;
1985 }
1986 auto stateMachine = pms->GetPowerStateMachine();
1987 if (stateMachine == nullptr) {
1988 return;
1989 }
1990 auto action = pointerEvent->GetPointerAction();
1991 if (action == PointerEvent::POINTER_ACTION_ENTER_WINDOW ||
1992 action == PointerEvent::POINTER_ACTION_LEAVE_WINDOW ||
1993 action == PointerEvent::POINTER_ACTION_PULL_IN_WINDOW ||
1994 action == PointerEvent::POINTER_ACTION_PULL_OUT_WINDOW) {
1995 return;
1996 }
1997 if (pointerEvent->GetDeviceId() == COLLABORATION_REMOTE_DEVICE_ID &&
1998 stateMachine->IsRunningLockEnabled(RunningLockType::RUNNINGLOCK_COORDINATION) &&
1999 stateMachine->GetState() == PowerState::AWAKE) {
2000 stateMachine->SetState(PowerState::DIM, StateChangeReason::STATE_CHANGE_REASON_COORDINATION, true);
2001 POWER_HILOGD(FEATURE_INPUT, "remote pointer event in coordinated state, override screen off time");
2002 }
2003 }
2004
OnInputEvent(std::shared_ptr<AxisEvent> axisEvent) const2005 void PowerMgrInputMonitor::OnInputEvent(std::shared_ptr<AxisEvent> axisEvent) const {};
2006 #endif
2007
2008 #ifdef POWER_MANAGER_ENABLE_EXTERNAL_SCREEN_MANAGEMENT
ExternalScreenInit()2009 void PowerMgrService::ExternalScreenInit()
2010 {
2011 auto stateMachine = pms->GetPowerStateMachine();
2012 auto suspendController = pms->GetSuspendController();
2013 auto wakeupController = pms->GetWakeupController();
2014 if (stateMachine == nullptr || suspendController == nullptr || wakeupController == nullptr) {
2015 POWER_HILOGE(COMP_SVC, "Get important instance error");
2016 return;
2017 }
2018
2019 std::vector<uint64_t> screenIds;
2020 auto ret = Rosen::ScreenManagerLite::GetInstance().GetPhysicalScreenIds(screenIds);
2021 if (ret != Rosen::DMError::DM_OK) {
2022 POWER_HILOGE(COMP_SVC, "Failed to get physical screen ids");
2023 return;
2024 }
2025 POWER_HILOGI(COMP_SVC, "Number of current physical screen is %{public}u", static_cast<uint32_t>(screenIds.size()));
2026 if (screenIds.size() <= 1) { // there's at least a main screen, we only care about external screen
2027 return;
2028 }
2029
2030 bool isSwitchOpen = stateMachine->IsSwitchOpen();
2031 bool isScreenOn = stateMachine->IsScreenOn();
2032 stateMachine->SetExternalScreenNumber(static_cast<int32_t>(screenIds.size()) - 1);
2033 POWER_HILOGI(
2034 COMP_SVC, "Init external screen, isSwitchOpen: %{public}d, isScreenOn: %{public}d", isSwitchOpen, isScreenOn);
2035 if (isScreenOn) {
2036 wakeupController->PowerOnAllScreens(WakeupDeviceType::WAKEUP_DEVICE_EX_SCREEN_INIT);
2037 if (!isSwitchOpen) {
2038 suspendController->PowerOffInternalScreen(SuspendDeviceType::SUSPEND_DEVICE_REASON_SWITCH);
2039 }
2040 } else {
2041 suspendController->PowerOffAllScreens(SuspendDeviceType::SUSPEND_DEVICE_REASON_EX_SCREEN_INIT);
2042 }
2043 }
2044
RegisterExternalScreenListener()2045 void PowerMgrService::RegisterExternalScreenListener()
2046 {
2047 auto ret = Rosen::DMError::DM_OK;
2048 if (externalScreenListener_ == nullptr) {
2049 externalScreenListener_ = sptr<ExternalScreenListener>::MakeSptr();
2050 ret = Rosen::ScreenManagerLite::GetInstance().RegisterScreenListener(externalScreenListener_);
2051 POWER_HILOGI(COMP_SVC, "Register external screen listener, ret: %{public}d", static_cast<int32_t>(ret));
2052 }
2053
2054 if (abnormalExScreenListener_ == nullptr) {
2055 abnormalExScreenListener_ = sptr<AbnormalExternalScreenConnectListener>::MakeSptr();
2056 ret = Rosen::ScreenManagerLite::GetInstance().RegisterAbnormalScreenConnectChangeListener(
2057 abnormalExScreenListener_);
2058 POWER_HILOGI(
2059 COMP_SVC, "Register abnormal external screen listener, ret: %{public}d", static_cast<int32_t>(ret));
2060 }
2061 }
2062
UnRegisterExternalScreenListener()2063 void PowerMgrService::UnRegisterExternalScreenListener()
2064 {
2065 auto ret = Rosen::DMError::DM_OK;
2066 if (externalScreenListener_ != nullptr) {
2067 ret = Rosen::ScreenManagerLite::GetInstance().UnregisterScreenListener(externalScreenListener_);
2068 externalScreenListener_ = nullptr;
2069 POWER_HILOGI(COMP_SVC, "Unregister external screen listener, ret: %{public}d", static_cast<int32_t>(ret));
2070 }
2071
2072 if (abnormalExScreenListener_ != nullptr) {
2073 ret = Rosen::ScreenManagerLite::GetInstance().UnregisterAbnormalScreenConnectChangeListener(
2074 abnormalExScreenListener_);
2075 abnormalExScreenListener_ = nullptr;
2076 POWER_HILOGI(
2077 COMP_SVC, "Unregister abnormal external screen listener, ret: %{public}d", static_cast<int32_t>(ret));
2078 }
2079 }
2080
OnConnect(uint64_t screenId)2081 void PowerMgrService::ExternalScreenListener::OnConnect(uint64_t screenId)
2082 {
2083 if (screenId >= VIRTUAL_SCREEN_START_ID) {
2084 POWER_HILOGI(
2085 COMP_SVC, "Ignore virtual screen connecting event, screenId: %{public}u", static_cast<uint32_t>(screenId));
2086 return;
2087 }
2088 auto powerStateMachine = pms->GetPowerStateMachine();
2089 auto suspendController = pms->GetSuspendController();
2090 auto wakeupController = pms->GetWakeupController();
2091 if (powerStateMachine == nullptr || suspendController == nullptr || wakeupController == nullptr) {
2092 POWER_HILOGE(COMP_SVC, "Get important instance error, screenId: %{public}u", static_cast<uint32_t>(screenId));
2093 return;
2094 }
2095
2096 int32_t curExternalScreenNum = powerStateMachine->GetExternalScreenNumber() + 1;
2097 powerStateMachine->SetExternalScreenNumber(curExternalScreenNum);
2098 bool isSwitchOpen = powerStateMachine->IsSwitchOpen();
2099 bool isScreenOn = powerStateMachine->IsScreenOn();
2100 POWER_HILOGI(COMP_SVC,
2101 "External screen is connected, screenId: %{public}u, externalScreenNumber: %{public}d, isSwitchOpen: "
2102 "%{public}d, isScreenOn: %{public}d",
2103 static_cast<uint32_t>(screenId), curExternalScreenNum, isSwitchOpen, isScreenOn);
2104
2105 if (isSwitchOpen && isScreenOn) {
2106 wakeupController->PowerOnAllScreens(WakeupDeviceType::WAKEUP_DEVICE_SCREEN_CONNECT);
2107 pms->RefreshActivity(GetTickCount(), UserActivityType::USER_ACTIVITY_TYPE_CABLE, false);
2108 } else if (isSwitchOpen && !isScreenOn) {
2109 POWER_HILOGI(FEATURE_SUSPEND, "[UL_POWER] Skip wakeup by external screen connected when screen off");
2110 } else if (!isSwitchOpen && !isScreenOn) {
2111 suspendController->PowerOffAllScreens(SuspendDeviceType::SUSPEND_DEVICE_REASON_SWITCH);
2112 } else {
2113 if (curExternalScreenNum > 1) {
2114 // When the power state is ON and there are 2 external screens or more, power off closed internal screen
2115 POWER_HILOGI(FEATURE_SUSPEND, "[UL_POWER] Power on all screens except for the closed internal screen");
2116 wakeupController->PowerOnAllScreens(WakeupDeviceType::WAKEUP_DEVICE_SCREEN_CONNECT);
2117 suspendController->PowerOffInternalScreen(SuspendDeviceType::SUSPEND_DEVICE_REASON_SWITCH);
2118 }
2119 }
2120 }
2121
OnDisconnect(uint64_t screenId)2122 void PowerMgrService::ExternalScreenListener::OnDisconnect(uint64_t screenId)
2123 {
2124 if (screenId >= VIRTUAL_SCREEN_START_ID) {
2125 POWER_HILOGI(COMP_SVC, "Ignore virtual screen disconnecting event, screenId: %{public}u",
2126 static_cast<uint32_t>(screenId));
2127 return;
2128 }
2129 auto powerStateMachine = pms->GetPowerStateMachine();
2130 auto suspendController = pms->GetSuspendController();
2131 if (powerStateMachine == nullptr || suspendController == nullptr) {
2132 POWER_HILOGE(COMP_SVC, "Get important instance error, screenId:%{public}u", static_cast<uint32_t>(screenId));
2133 return;
2134 }
2135
2136 int32_t curExternalScreenNum = powerStateMachine->GetExternalScreenNumber() - 1;
2137 powerStateMachine->SetExternalScreenNumber(curExternalScreenNum);
2138 bool isSwitchOpen = powerStateMachine->IsSwitchOpen();
2139 bool isScreenOn = powerStateMachine->IsScreenOn();
2140 POWER_HILOGI(COMP_SVC,
2141 "External screen is disconnected, screenId: %{public}u, externalScreenNumber: %{public}d, isSwitchOpen: "
2142 "%{public}d, isScreenOn: %{public}d",
2143 static_cast<uint32_t>(screenId), curExternalScreenNum, isSwitchOpen, isScreenOn);
2144
2145 if (isSwitchOpen && isScreenOn) {
2146 pms->RefreshActivity(GetTickCount(), UserActivityType::USER_ACTIVITY_TYPE_CABLE, false);
2147 } else if (!isSwitchOpen && isScreenOn) {
2148 // When there's no external screen, we should suspend the device, oterwise do nothing
2149 if (curExternalScreenNum == 0) {
2150 POWER_HILOGI(
2151 FEATURE_SUSPEND, "[UL_POWER] Suspend device when external screen is disconnected and switch is closed");
2152 suspendController->ExecSuspendMonitorByReason(SuspendDeviceType::SUSPEND_DEVICE_REASON_SWITCH);
2153 } else {
2154 POWER_HILOGI(FEATURE_SUSPEND,
2155 "[UL_POWER] Refresh device rather than suspend device when there's still external screen");
2156 pms->RefreshActivity(GetTickCount(), UserActivityType::USER_ACTIVITY_TYPE_CABLE, false);
2157 }
2158 }
2159 }
2160
NotifyAbnormalScreenConnectChange(uint64_t screenId)2161 void PowerMgrService::AbnormalExternalScreenConnectListener::NotifyAbnormalScreenConnectChange(uint64_t screenId)
2162 {
2163 if (screenId >= VIRTUAL_SCREEN_START_ID) {
2164 POWER_HILOGI(COMP_SVC, "Ignore virtual screen abnormal connecting event, screenId: %{public}u",
2165 static_cast<uint32_t>(screenId));
2166 return;
2167 }
2168 auto powerStateMachine = pms->GetPowerStateMachine();
2169 auto suspendController = pms->GetSuspendController();
2170 auto wakeupController = pms->GetWakeupController();
2171 if (powerStateMachine == nullptr || suspendController == nullptr || wakeupController == nullptr) {
2172 POWER_HILOGE(COMP_SVC, "Get important instance error, screenId: %{public}u", static_cast<uint32_t>(screenId));
2173 return;
2174 }
2175
2176 bool isSwitchOpen = powerStateMachine->IsSwitchOpen();
2177 bool isScreenOn = powerStateMachine->IsScreenOn();
2178 POWER_HILOGI(COMP_SVC,
2179 "Received abnormal external screen connecting event, screenId: %{public}u, isSwitchOpen: %{public}d, "
2180 "isScreenOn: %{public}d",
2181 static_cast<uint32_t>(screenId), isSwitchOpen, isScreenOn);
2182 if (isScreenOn) {
2183 wakeupController->PowerOnAllScreens(WakeupDeviceType::WAKEUP_DEVICE_ABNORMAL_SCREEN_CONNECT);
2184 if (!isSwitchOpen) {
2185 suspendController->PowerOffInternalScreen(SuspendDeviceType::SUSPEND_DEVICE_REASON_SWITCH);
2186 }
2187 }
2188 }
2189 #endif
2190
SubscribeCommonEvent()2191 void PowerMgrService::SubscribeCommonEvent()
2192 {
2193 using namespace OHOS::EventFwk;
2194 MatchingSkills matchingSkills;
2195 matchingSkills.AddEvent(CommonEventSupport::COMMON_EVENT_USER_SWITCHED);
2196 #ifdef POWER_MANAGER_ENABLE_CHARGING_TYPE_SETTING
2197 matchingSkills.AddEvent(CommonEventSupport::COMMON_EVENT_POWER_CONNECTED);
2198 matchingSkills.AddEvent(CommonEventSupport::COMMON_EVENT_POWER_DISCONNECTED);
2199 #endif
2200 CommonEventSubscribeInfo subscribeInfo(matchingSkills);
2201 subscribeInfo.SetThreadMode(CommonEventSubscribeInfo::ThreadMode::COMMON);
2202 if (!subscriberPtr_) {
2203 subscriberPtr_ = std::make_shared<PowerCommonEventSubscriber>(subscribeInfo);
2204 }
2205 bool result = CommonEventManager::SubscribeCommonEvent(subscriberPtr_);
2206 if (!result) {
2207 POWER_HILOGE(COMP_SVC, "Subscribe COMMON_EVENT failed");
2208 }
2209 }
2210
UnregisterAllSettingObserver()2211 void PowerMgrService::UnregisterAllSettingObserver()
2212 {
2213 auto pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
2214 if (pms == nullptr) {
2215 POWER_HILOGI(COMP_SVC, "get PowerMgrService fail");
2216 return;
2217 }
2218 auto stateMachine = pms->GetPowerStateMachine();
2219 auto suspendController = pms->GetSuspendController();
2220 auto wakeupController = pms->GetWakeupController();
2221 if (stateMachine == nullptr || suspendController == nullptr || wakeupController == nullptr) {
2222 POWER_HILOGE(COMP_SVC, "get stateMachine, suspendController or wakeupController fail");
2223 return;
2224 }
2225
2226 #ifdef POWER_DOUBLECLICK_ENABLE
2227 SettingHelper::UnregisterSettingWakeupDoubleObserver();
2228 #endif
2229 #ifdef POWER_PICKUP_ENABLE
2230 SettingHelper::UnregisterSettingWakeupPickupObserver();
2231 #endif
2232 wakeupController->UnregisterSettingsObserver();
2233 #ifdef POWER_MANAGER_ENABLE_CHARGING_TYPE_SETTING
2234 suspendController->UnregisterSettingsObserver();
2235 stateMachine->UnregisterDisplayOffTimeObserver();
2236 #endif
2237 }
2238
RegisterAllSettingObserver()2239 void PowerMgrService::RegisterAllSettingObserver()
2240 {
2241 auto pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
2242 if (pms == nullptr) {
2243 POWER_HILOGI(COMP_SVC, "get PowerMgrService fail");
2244 return;
2245 }
2246
2247 #ifdef POWER_DOUBLECLICK_ENABLE
2248 pms->RegisterSettingWakeupDoubleClickObservers();
2249 #endif
2250 #ifdef POWER_PICKUP_ENABLE
2251 pms->RegisterSettingWakeupPickupGestureObserver();
2252 #endif
2253 pms->WakeupControllerInit();
2254 #ifdef POWER_MANAGER_ENABLE_CHARGING_TYPE_SETTING
2255 pms->SuspendControllerInit();
2256 pms->UpdateSettingInvalidDisplayOffTime(); // update setting value if invalid before register
2257 auto stateMachine = pms->GetPowerStateMachine();
2258 if (stateMachine == nullptr) {
2259 POWER_HILOGE(COMP_SVC, "get PowerStateMachine fail");
2260 return;
2261 }
2262 stateMachine->RegisterDisplayOffTimeObserver();
2263 #endif
2264 }
2265
GetSettingDisplayOffTime(int64_t defaultTime)2266 int64_t PowerMgrService::GetSettingDisplayOffTime(int64_t defaultTime)
2267 {
2268 int64_t settingTime = defaultTime;
2269 #ifdef POWER_MANAGER_ENABLE_CHARGING_TYPE_SETTING
2270 auto pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
2271 if (pms == nullptr) {
2272 POWER_HILOGE(FEATURE_POWER_MODE, "get PowerMgrService fail");
2273 return settingTime;
2274 }
2275 if (pms->IsPowerConnected()) {
2276 settingTime = SettingHelper::GetSettingDisplayAcScreenOffTime(defaultTime);
2277 } else {
2278 settingTime = SettingHelper::GetSettingDisplayDcScreenOffTime(defaultTime);
2279 }
2280 #else
2281 settingTime = SettingHelper::GetSettingDisplayOffTime(defaultTime);
2282 #endif
2283 return settingTime;
2284 }
2285
2286 #ifdef POWER_MANAGER_ENABLE_CHARGING_TYPE_SETTING
UpdateSettingInvalidDisplayOffTime()2287 void PowerMgrService::UpdateSettingInvalidDisplayOffTime()
2288 {
2289 if (!SettingHelper::IsSettingDisplayAcScreenOffTimeValid()) {
2290 SettingHelper::SetSettingDisplayAcScreenOffTime(PowerStateMachine::DEFAULT_AC_DISPLAY_OFF_TIME_MS);
2291 }
2292 if (!SettingHelper::IsSettingDisplayDcScreenOffTimeValid()) {
2293 SettingHelper::SetSettingDisplayDcScreenOffTime(PowerStateMachine::DEFAULT_DC_DISPLAY_OFF_TIME_MS);
2294 }
2295 }
2296
OnPowerConnectStatusChanged(PowerConnectStatus status)2297 void PowerCommonEventSubscriber::OnPowerConnectStatusChanged(PowerConnectStatus status)
2298 {
2299 auto power = DelayedSpSingleton<PowerMgrService>::GetInstance();
2300 if (power == nullptr) {
2301 POWER_HILOGE(COMP_SVC, "get PowerMgrService fail");
2302 return;
2303 }
2304 power->SetPowerConnectStatus(status);
2305
2306 auto suspendController = power->GetSuspendController();
2307 if (suspendController == nullptr) {
2308 POWER_HILOGE(COMP_SVC, "get suspendController fail");
2309 return;
2310 }
2311 suspendController->UpdateSuspendSources();
2312
2313 auto stateMachine = power->GetPowerStateMachine();
2314 if (stateMachine == nullptr) {
2315 POWER_HILOGE(COMP_SVC, "get PowerStateMachine fail");
2316 return;
2317 }
2318 stateMachine->DisplayOffTimeUpdateFunc();
2319
2320 power->OnChargeStateChanged(); // should be called after suspend sources settings updated
2321 }
2322 #endif
2323
OnReceiveEvent(const OHOS::EventFwk::CommonEventData & data)2324 void PowerCommonEventSubscriber::OnReceiveEvent(const OHOS::EventFwk::CommonEventData &data)
2325 {
2326 std::string action = data.GetWant().GetAction();
2327 auto pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
2328 if (pms == nullptr) {
2329 POWER_HILOGI(COMP_SVC, "get PowerMgrService fail");
2330 return;
2331 }
2332 if (action == OHOS::EventFwk::CommonEventSupport::COMMON_EVENT_USER_SWITCHED) {
2333 pms->UnregisterAllSettingObserver(); // unregister old user observer
2334 SettingHelper::UpdateCurrentUserId(); // update user Id
2335 pms->RegisterAllSettingObserver(); // register new user observer
2336 #ifdef POWER_MANAGER_ENABLE_CHARGING_TYPE_SETTING
2337 } else if (action == OHOS::EventFwk::CommonEventSupport::COMMON_EVENT_POWER_CONNECTED) {
2338 OnPowerConnectStatusChanged(PowerConnectStatus::POWER_CONNECT_AC);
2339 } else if (action == OHOS::EventFwk::CommonEventSupport::COMMON_EVENT_POWER_DISCONNECTED) {
2340 OnPowerConnectStatusChanged(PowerConnectStatus::POWER_CONNECT_DC);
2341 #endif
2342 }
2343 }
2344
IsRunningLockEnabled(const RunningLockType type,bool & result)2345 PowerErrors PowerMgrService::IsRunningLockEnabled(const RunningLockType type, bool& result)
2346 {
2347 if (!Permission::IsPermissionGranted("ohos.permission.RUNNING_LOCK")) {
2348 return PowerErrors::ERR_PERMISSION_DENIED;
2349 }
2350 std::lock_guard lock(lockMutex_);
2351 uint32_t num = runningLockMgr_->GetValidRunningLockNum(type);
2352 POWER_HILOGI(COMP_SVC, "Hold running lock type:%{public}u, num:%{public}u", static_cast<uint32_t>(type), num);
2353 result = num > 0 ? true : false;
2354 return PowerErrors::ERR_OK;
2355 }
2356 } // namespace PowerMgr
2357 } // namespace OHOS
2358