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_state_machine.h"
17
18 #include <algorithm>
19 #include <cinttypes>
20 #include <datetime_ex.h>
21 #ifdef HAS_HIVIEWDFX_HISYSEVENT_PART
22 #include <hisysevent.h>
23 #endif
24 #include <ipc_skeleton.h>
25 #ifdef HAS_HIVIEWDFX_HITRACE_PART
26 #include "power_hitrace.h"
27 #endif
28 #include "power_mode_policy.h"
29 #include "power_mgr_factory.h"
30 #include "power_mgr_service.h"
31 #include "power_utils.h"
32 #include "setting_helper.h"
33 #include "system_suspend_controller.h"
34 #ifdef POWER_MANAGER_POWER_ENABLE_S4
35 #include "os_account_manager.h"
36 #include "parameters.h"
37 #endif
38 #ifdef MSDP_MOVEMENT_ENABLE
39 #include <dlfcn.h>
40 #endif
41
42 namespace OHOS {
43 namespace PowerMgr {
44 namespace {
45 #ifdef POWER_MANAGER_ENABLE_CHARGING_TYPE_SETTING
46 sptr<SettingObserver> g_displayOffTimeAcObserver;
47 sptr<SettingObserver> g_displayOffTimeDcObserver;
48 #else
49 sptr<SettingObserver> g_displayOffTimeObserver;
50 #endif
51 static int64_t g_beforeOverrideTime {-1};
52 #ifdef HAS_HIVIEWDFX_HISYSEVENT_PART
53 constexpr int32_t DISPLAY_OFF = 0;
54 constexpr int32_t DISPLAY_ON = 2;
55 #endif
56 const std::string POWERMGR_STOPSERVICE = "persist.powermgr.stopservice";
57 constexpr uint32_t PRE_BRIGHT_AUTH_TIMER_DELAY_MS = 3000;
58 #ifdef POWER_MANAGER_POWER_ENABLE_S4
59 constexpr uint32_t HIBERNATE_DELAY_MS = 3500;
60 static int64_t g_preHibernateStart = 0;
61 #endif
62 }
PowerStateMachine(const wptr<PowerMgrService>& pms, const std::shared_ptr<FFRTTimer>& ffrtTimer)63 PowerStateMachine::PowerStateMachine(const wptr<PowerMgrService>& pms, const std::shared_ptr<FFRTTimer>& ffrtTimer)
64 : pms_(pms), ffrtTimer_(ffrtTimer), currentState_(PowerState::UNKNOWN)
65 {
66 POWER_HILOGD(FEATURE_POWER_STATE, "Instance start");
67 // NOTICE Need get screen state when device startup,
68 // rightnow we set screen is on as default
69 mDeviceState_.screenState.lastOnTime = GetTickCount();
70 mDeviceState_.screenState.lastOffTime = 0;
71 mDeviceState_.lastWakeupEventTime = 0;
72 mDeviceState_.lastRefreshActivityTime = 0;
73 mDeviceState_.lastWakeupDeviceTime = 0;
74 mDeviceState_.lastSuspendDeviceTime = 0;
75
76 // init lock map which will block state transit
77 std::vector<RunningLockType> awakeBlocker {};
78 std::vector<RunningLockType> freezeBlocker {};
79 std::vector<RunningLockType> inactiveBlocker {RunningLockType::RUNNINGLOCK_SCREEN};
80 std::vector<RunningLockType> standByBlocker {};
81 std::vector<RunningLockType> dozeBlocker {};
82 std::vector<RunningLockType> sleepBlocker {
83 RunningLockType::RUNNINGLOCK_COORDINATION
84 };
85 std::vector<RunningLockType> hibernateBlocker {};
86 std::vector<RunningLockType> shutdownBlocker {};
87
88 lockMap_.emplace(PowerState::AWAKE, std::make_shared<std::vector<RunningLockType>>(awakeBlocker));
89 lockMap_.emplace(PowerState::FREEZE, std::make_shared<std::vector<RunningLockType>>(freezeBlocker));
90 lockMap_.emplace(PowerState::INACTIVE, std::make_shared<std::vector<RunningLockType>>(inactiveBlocker));
91 lockMap_.emplace(PowerState::STAND_BY, std::make_shared<std::vector<RunningLockType>>(standByBlocker));
92 lockMap_.emplace(PowerState::DOZE, std::make_shared<std::vector<RunningLockType>>(dozeBlocker));
93 lockMap_.emplace(PowerState::SLEEP, std::make_shared<std::vector<RunningLockType>>(sleepBlocker));
94 lockMap_.emplace(PowerState::HIBERNATE, std::make_shared<std::vector<RunningLockType>>(hibernateBlocker));
95 lockMap_.emplace(PowerState::SHUTDOWN, std::make_shared<std::vector<RunningLockType>>(shutdownBlocker));
96
97 POWER_HILOGD(FEATURE_POWER_STATE, "Instance end");
98 }
99
~PowerStateMachine()100 PowerStateMachine::~PowerStateMachine()
101 {
102 ffrtTimer_.reset();
103 }
104
Init()105 bool PowerStateMachine::Init()
106 {
107 POWER_HILOGD(FEATURE_POWER_STATE, "Start init");
108 stateAction_ = PowerMgrFactory::GetDeviceStateAction();
109 InitTransitMap();
110 InitStateMap();
111
112 if (powerStateCBDeathRecipient_ == nullptr) {
113 powerStateCBDeathRecipient_ = new PowerStateCallbackDeathRecipient();
114 }
115 POWER_HILOGD(FEATURE_POWER_STATE, "Init success");
116 return true;
117 }
118
InitTransitMap()119 void PowerStateMachine::InitTransitMap()
120 {
121 #ifdef POWER_MANAGER_POWER_ENABLE_S4
122 std::vector<PowerState> awake { PowerState::SLEEP };
123 #else
124 std::vector<PowerState> awake { PowerState::SLEEP, PowerState::HIBERNATE };
125 #endif
126 std::vector<PowerState> inactive { PowerState::DIM };
127 std::vector<PowerState> sleep { PowerState::DIM };
128
129 forbidMap_.emplace(PowerState::AWAKE, std::set<PowerState>(awake.begin(), awake.end()));
130 forbidMap_.emplace(PowerState::INACTIVE, std::set<PowerState>(inactive.begin(), inactive.end()));
131 forbidMap_.emplace(PowerState::SLEEP, std::set<PowerState>(sleep.begin(), sleep.end()));
132
133 allowMapByReason_.insert({
134 {
135 StateChangeReason::STATE_CHANGE_REASON_REFRESH,
136 {
137 {PowerState::DIM, {PowerState::AWAKE}},
138 {PowerState::AWAKE, {PowerState::AWAKE}}
139 }
140 },
141 {
142 StateChangeReason::STATE_CHANGE_REASON_TIMEOUT,
143 {
144 // allow AWAKE to INACTIVE without going to DIM for UTs to pass
145 {PowerState::AWAKE, {PowerState::DIM, PowerState::INACTIVE}},
146 {PowerState::DIM, {PowerState::INACTIVE}},
147 {PowerState::INACTIVE, {PowerState::SLEEP}}
148 }
149 },
150 {
151 StateChangeReason::STATE_CHANGE_REASON_TIMEOUT_NO_SCREEN_LOCK,
152 {
153 {PowerState::DIM, {PowerState::INACTIVE}},
154 // allow AWAKE to INACTIVE without going to DIM for UTs to pass
155 {PowerState::AWAKE, {PowerState::INACTIVE}}
156 }
157 },
158 });
159 }
160
161 #ifdef MSDP_MOVEMENT_ENABLE
162 static const char* MOVEMENT_STATE_CONFIG = "GetMovementState";
163 static const char* POWER_MANAGER_EXT_PATH = "libpower_manager_ext.z.so";
164 typedef bool(*FuncMovementState)();
165
IsMovementStateOn()166 bool PowerStateMachine::IsMovementStateOn()
167 {
168 POWER_HILOGD(FEATURE_POWER_STATE, "Start to GetMovementState");
169 void *stateHandler = dlopen(POWER_MANAGER_EXT_PATH, RTLD_LAZY | RTLD_NODELETE);
170 if (stateHandler == nullptr) {
171 POWER_HILOGE(FEATURE_POWER_STATE, "Dlopen GetMovementState failed, reason : %{public}s", dlerror());
172 return false;
173 }
174
175 FuncMovementState MovementStateFlag = reinterpret_cast<FuncMovementState>(dlsym(stateHandler,
176 MOVEMENT_STATE_CONFIG));
177 if (MovementStateFlag == nullptr) {
178 POWER_HILOGE(FEATURE_POWER_STATE, "GetMovementState is null, reason : %{public}s", dlerror());
179 dlclose(stateHandler);
180 stateHandler = nullptr;
181 return false;
182 }
183 bool ret = MovementStateFlag();
184 dlclose(stateHandler);
185 stateHandler = nullptr;
186 return ret;
187 }
188 #endif
189
CanTransitTo(PowerState to, StateChangeReason reason)190 bool PowerStateMachine::CanTransitTo(PowerState to, StateChangeReason reason)
191 {
192 bool isForbidden = forbidMap_.count(currentState_) && forbidMap_[currentState_].count(to);
193 if (isForbidden) {
194 return false;
195 }
196 // prevent the double click and pickup to light up the screen when calling or sporting
197 if ((reason == StateChangeReason::STATE_CHANGE_REASON_DOUBLE_CLICK ||
198 reason == StateChangeReason::STATE_CHANGE_REASON_PICKUP) && to == PowerState::AWAKE) {
199 #ifdef HAS_SENSORS_SENSOR_PART
200 if (IsProximityClose()) {
201 POWER_HILOGI(FEATURE_POWER_STATE,
202 "Double-click or pickup isn't allowed to wakeup device when proximity is close.");
203 return false;
204 }
205 #endif
206 #ifdef MSDP_MOVEMENT_ENABLE
207 if (IsMovementStateOn()) {
208 POWER_HILOGI(FEATURE_POWER_STATE,
209 "Double-click or pickup isn't allowed to wakeup device when movement state is on.");
210 return false;
211 }
212 #endif
213 }
214 bool isAllowed = (!allowMapByReason_.count(reason) ||
215 (allowMapByReason_[reason].count(currentState_) && allowMapByReason_[reason][currentState_].count(to)));
216 return isAllowed;
217 }
218
InitState()219 void PowerStateMachine::InitState()
220 {
221 POWER_HILOGD(FEATURE_POWER_STATE, "Init power state");
222 if (IsScreenOn()) {
223 #ifdef HAS_HIVIEWDFX_HISYSEVENT_PART
224 HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::DISPLAY, "SCREEN_STATE",
225 HiviewDFX::HiSysEvent::EventType::STATISTIC, "STATE", DISPLAY_ON);
226 #endif
227 SetState(PowerState::AWAKE, StateChangeReason::STATE_CHANGE_REASON_INIT, true);
228 } else {
229 #ifdef HAS_HIVIEWDFX_HISYSEVENT_PART
230 HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::DISPLAY, "SCREEN_STATE",
231 HiviewDFX::HiSysEvent::EventType::STATISTIC, "STATE", DISPLAY_OFF);
232 #endif
233 SetState(PowerState::INACTIVE, StateChangeReason::STATE_CHANGE_REASON_INIT, true);
234 }
235 }
236
EmplaceAwake()237 void PowerStateMachine::EmplaceAwake()
238 {
239 controllerMap_.emplace(PowerState::AWAKE,
240 std::make_shared<StateController>(PowerState::AWAKE, shared_from_this(), [this](StateChangeReason reason) {
241 POWER_HILOGD(FEATURE_POWER_STATE, "[UL_POWER] StateController_AWAKE lambda start, reason=%{public}s",
242 PowerUtils::GetReasonTypeString(reason).c_str());
243 #ifdef HAS_HIVIEWDFX_HISYSEVENT_PART
244 HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::POWER_UE, "SCREEN_ON",
245 HiviewDFX::HiSysEvent::EventType::BEHAVIOR, "PNAMEID", "PowerManager", "PVERSIONID", "1.0",
246 "REASON", PowerUtils::GetReasonTypeString(reason).c_str());
247 HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::POWER, "SCREEN_ON",
248 HiviewDFX::HiSysEvent::EventType::BEHAVIOR, "REASON", PowerUtils::GetReasonTypeString(reason).c_str());
249 #endif
250 mDeviceState_.screenState.lastOnTime = GetTickCount();
251 uint32_t ret = this->stateAction_->SetDisplayState(DisplayState::DISPLAY_ON, reason);
252 if (ret != ActionResult::SUCCESS) {
253 POWER_HILOGE(FEATURE_POWER_STATE, "Failed to go to AWAKE, display error, ret: %{public}u", ret);
254 return TransitResult::DISPLAY_ON_ERR;
255 }
256 if (reason != StateChangeReason::STATE_CHANGE_REASON_PRE_BRIGHT) {
257 ResetInactiveTimer();
258 }
259 SystemSuspendController::GetInstance().DisallowAutoSleep();
260 SystemSuspendController::GetInstance().Wakeup();
261 return TransitResult::SUCCESS;
262 }));
263 }
264
EmplaceFreeze()265 void PowerStateMachine::EmplaceFreeze()
266 {
267 controllerMap_.emplace(PowerState::FREEZE,
268 std::make_shared<StateController>(PowerState::FREEZE, shared_from_this(), [this](StateChangeReason reason) {
269 POWER_HILOGI(FEATURE_POWER_STATE, "StateController_FREEZE lambda start");
270 // Subsequent added functions
271 return TransitResult::SUCCESS;
272 }));
273 }
274
EmplaceInactive()275 void PowerStateMachine::EmplaceInactive()
276 {
277 controllerMap_.emplace(PowerState::INACTIVE,
278 std::make_shared<StateController>(PowerState::INACTIVE, shared_from_this(), [this](StateChangeReason reason) {
279 POWER_HILOGD(FEATURE_POWER_STATE, "[UL_POWER] StateController_INACTIVE lambda start");
280 #ifdef HAS_HIVIEWDFX_HISYSEVENT_PART
281 HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::POWER_UE, "SCREEN_OFF",
282 HiviewDFX::HiSysEvent::EventType::BEHAVIOR, "PNAMEID", "PowerManager", "PVERSIONID", "1.0",
283 "REASON", PowerUtils::GetReasonTypeString(reason).c_str());
284 #endif
285 mDeviceState_.screenState.lastOffTime = GetTickCount();
286 DisplayState state = DisplayState::DISPLAY_OFF;
287 if (enableDisplaySuspend_) {
288 POWER_HILOGI(FEATURE_POWER_STATE, "Display suspend enabled");
289 state = DisplayState::DISPLAY_SUSPEND;
290 }
291 uint32_t ret = this->stateAction_->SetDisplayState(state, reason);
292 if (ret != ActionResult::SUCCESS) {
293 POWER_HILOGE(FEATURE_POWER_STATE, "Failed to go to INACTIVE, display error, ret: %{public}u", ret);
294 return TransitResult::DISPLAY_OFF_ERR;
295 }
296 CancelDelayTimer(PowerStateMachine::CHECK_USER_ACTIVITY_TIMEOUT_MSG);
297 CancelDelayTimer(PowerStateMachine::CHECK_USER_ACTIVITY_OFF_TIMEOUT_MSG);
298 return TransitResult::SUCCESS;
299 }));
300 }
301
EmplaceStandBy()302 void PowerStateMachine::EmplaceStandBy()
303 {
304 controllerMap_.emplace(PowerState::STAND_BY,
305 std::make_shared<StateController>(PowerState::STAND_BY, shared_from_this(), [this](StateChangeReason reason) {
306 POWER_HILOGI(FEATURE_POWER_STATE, "StateController_STAND_BY lambda start");
307 mDeviceState_.screenState.lastOffTime = GetTickCount();
308 // Subsequent added functions
309 return TransitResult::SUCCESS;
310 }));
311 }
312
EmplaceDoze()313 void PowerStateMachine::EmplaceDoze()
314 {
315 controllerMap_.emplace(PowerState::DOZE,
316 std::make_shared<StateController>(PowerState::DOZE, shared_from_this(), [this](StateChangeReason reason) {
317 POWER_HILOGI(FEATURE_POWER_STATE, "StateController_DOZE lambda start");
318 mDeviceState_.screenState.lastOffTime = GetTickCount();
319 // Subsequent added functions
320 return TransitResult::SUCCESS;
321 }));
322 }
323
EmplaceSleep()324 void PowerStateMachine::EmplaceSleep()
325 {
326 controllerMap_.emplace(PowerState::SLEEP,
327 std::make_shared<StateController>(PowerState::SLEEP, shared_from_this(), [this](StateChangeReason reason) {
328 POWER_HILOGI(FEATURE_POWER_STATE, "StateController_SLEEP lambda start");
329 SystemSuspendController::GetInstance().AllowAutoSleep();
330 return TransitResult::SUCCESS;
331 }));
332 }
333
EmplaceHibernate()334 void PowerStateMachine::EmplaceHibernate()
335 {
336 controllerMap_.emplace(PowerState::HIBERNATE,
337 std::make_shared<StateController>(PowerState::HIBERNATE, shared_from_this(), [this](StateChangeReason reason) {
338 POWER_HILOGI(FEATURE_POWER_STATE, "StateController_HIBERNATE lambda start");
339 return TransitResult::SUCCESS;
340 }));
341 }
342
EmplaceShutdown()343 void PowerStateMachine::EmplaceShutdown()
344 {
345 controllerMap_.emplace(PowerState::SHUTDOWN,
346 std::make_shared<StateController>(PowerState::SHUTDOWN, shared_from_this(), [this](StateChangeReason reason) {
347 POWER_HILOGI(FEATURE_POWER_STATE, "StateController_SHUTDOWN lambda start");
348 // Subsequent added functions
349 return TransitResult::SUCCESS;
350 }));
351 }
352
EmplaceDim()353 void PowerStateMachine::EmplaceDim()
354 {
355 controllerMap_.emplace(PowerState::DIM,
356 std::make_shared<StateController>(PowerState::DIM, shared_from_this(), [this](StateChangeReason reason) {
357 POWER_HILOGD(FEATURE_POWER_STATE, "[UL_POWER] StateController_DIM lambda start");
358 if (GetDisplayOffTime() < 0) {
359 POWER_HILOGD(FEATURE_ACTIVITY, "Auto display off is disabled");
360 return TransitResult::OTHER_ERR;
361 }
362 int64_t dimTime = GetDimTime(GetDisplayOffTime());
363 if (reason == StateChangeReason::STATE_CHANGE_REASON_COORDINATION) {
364 dimTime = COORDINATED_STATE_SCREEN_OFF_TIME_MS;
365 }
366 uint32_t ret = stateAction_->SetDisplayState(DisplayState::DISPLAY_DIM, reason);
367 if (ret != ActionResult::SUCCESS) {
368 // failed but not return, still need to set screen off
369 POWER_HILOGE(FEATURE_POWER_STATE, "Failed to go to DIM, display error, ret: %{public}u", ret);
370 }
371 CancelDelayTimer(PowerStateMachine::CHECK_USER_ACTIVITY_TIMEOUT_MSG);
372 CancelDelayTimer(PowerStateMachine::CHECK_USER_ACTIVITY_OFF_TIMEOUT_MSG);
373 // Set a timer without checking runninglock, but the actual timeout event can still be blocked.
374 // Theoretically, this timer is always cancelable before the current task is finished.
375 SetDelayTimer(dimTime, PowerStateMachine::CHECK_USER_ACTIVITY_OFF_TIMEOUT_MSG);
376 // in case a refresh action occurs, change display state back to on
377 if (settingStateFlag_.load() ==
378 static_cast<int64_t>(SettingStateFlag::StateFlag::SETTING_DIM_INTERRUPTED)) {
379 stateAction_->SetDisplayState(DisplayState::DISPLAY_ON, StateChangeReason::STATE_CHANGE_REASON_REFRESH);
380 ResetInactiveTimer();
381 POWER_HILOGW(FEATURE_POWER_STATE, "Setting DIM interrupted!");
382 return TransitResult::OTHER_ERR;
383 }
384 return ret == ActionResult::SUCCESS ? TransitResult::SUCCESS : TransitResult::OTHER_ERR;
385 }));
386 }
387
InitStateMap()388 void PowerStateMachine::InitStateMap()
389 {
390 EmplaceAwake();
391 EmplaceFreeze();
392 EmplaceInactive();
393 EmplaceStandBy();
394 EmplaceDoze();
395 EmplaceSleep();
396 EmplaceHibernate();
397 EmplaceShutdown();
398 EmplaceDim();
399 }
400
onSuspend()401 void PowerStateMachine::onSuspend()
402 {
403 POWER_HILOGI(FEATURE_SUSPEND, "System is suspending");
404 }
405
onWakeup()406 void PowerStateMachine::onWakeup()
407 {
408 POWER_HILOGI(FEATURE_WAKEUP, "System is awaking");
409 auto pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
410 if (pms == nullptr) {
411 return;
412 }
413 FFRTTask task = [&pms] {
414 pms->GetPowerStateMachine()->HandleSystemWakeup();
415 };
416 }
417
SuspendDeviceInner( pid_t pid, int64_t callTimeMs, SuspendDeviceType type, bool suspendImmed, bool ignoreScreenState)418 void PowerStateMachine::SuspendDeviceInner(
419 pid_t pid, int64_t callTimeMs, SuspendDeviceType type, bool suspendImmed, bool ignoreScreenState)
420 {
421 #ifdef HAS_HIVIEWDFX_HITRACE_PART
422 PowerHitrace powerHitrace("SuspendDevice");
423 #endif
424 if (type > SuspendDeviceType::SUSPEND_DEVICE_REASON_MAX) {
425 POWER_HILOGW(FEATURE_SUSPEND, "Invalid type: %{public}d", type);
426 return;
427 }
428 // Check the screen state
429 if (!ignoreScreenState) {
430 if (stateAction_ != nullptr) {
431 stateAction_->Suspend(
432 callTimeMs, type, suspendImmed ? SUSPEND_DEVICE_IMMEDIATELY : SUSPEND_DEVICE_NEED_DOZE);
433 }
434 mDeviceState_.lastSuspendDeviceTime = callTimeMs;
435 POWER_HILOGD(FEATURE_SUSPEND, "Suspend device success");
436 } else {
437 POWER_HILOGD(FEATURE_SUSPEND, "Do not suspend device, screen state is ignored");
438 }
439
440 if (SetState(PowerState::INACTIVE, GetReasonBySuspendType(type), true)) {
441 uint32_t delay = 0;
442 SetAutoSuspend(type, delay);
443 }
444 POWER_HILOGD(FEATURE_SUSPEND, "Suspend device finish");
445 }
446
ParseWakeupDeviceType(const std::string& details)447 WakeupDeviceType PowerStateMachine::ParseWakeupDeviceType(const std::string& details)
448 {
449 WakeupDeviceType parsedType = WakeupDeviceType::WAKEUP_DEVICE_APPLICATION;
450
451 if (strcmp(details.c_str(), "pre_bright") == 0) {
452 parsedType = WakeupDeviceType::WAKEUP_DEVICE_PRE_BRIGHT;
453 } else if (strcmp(details.c_str(), "pre_bright_auth_success") == 0) {
454 parsedType = WakeupDeviceType::WAKEUP_DEVICE_PRE_BRIGHT_AUTH_SUCCESS;
455 } else if (strcmp(details.c_str(), "pre_bright_auth_fail_screen_on") == 0) {
456 parsedType = WakeupDeviceType::WAKEUP_DEVICE_PRE_BRIGHT_AUTH_FAIL_SCREEN_ON;
457 } else if (strcmp(details.c_str(), "pre_bright_auth_fail_screen_off") == 0) {
458 parsedType = WakeupDeviceType::WAKEUP_DEVICE_PRE_BRIGHT_AUTH_FAIL_SCREEN_OFF;
459 } else if (strcmp(details.c_str(), "incoming call") == 0) {
460 parsedType = WakeupDeviceType::WAKEUP_DEVICE_INCOMING_CALL;
461 } else if (strcmp(details.c_str(), "fake_str_check_unlock") == 0) {
462 parsedType = WakeupDeviceType::WAKEUP_DEVICE_EXIT_SYSTEM_STR;
463 } else if (strcmp(details.c_str(), "shell") == 0) {
464 parsedType = WakeupDeviceType::WAKEUP_DEVICE_SHELL;
465 }
466
467 if (parsedType != WakeupDeviceType::WAKEUP_DEVICE_APPLICATION) {
468 POWER_HILOGI(FEATURE_WAKEUP, "Parsed wakeup type is %{public}d", static_cast<uint32_t>(parsedType));
469 }
470 return parsedType;
471 }
472
IsPreBrightAuthReason(StateChangeReason reason)473 bool PowerStateMachine::IsPreBrightAuthReason(StateChangeReason reason)
474 {
475 bool ret = false;
476 switch (reason) {
477 case StateChangeReason::STATE_CHANGE_REASON_PRE_BRIGHT_AUTH_SUCCESS:
478 ret = true;
479 break;
480 case StateChangeReason::STATE_CHANGE_REASON_PRE_BRIGHT_AUTH_FAIL_SCREEN_ON:
481 ret = true;
482 break;
483 case StateChangeReason::STATE_CHANGE_REASON_PRE_BRIGHT_AUTH_FAIL_SCREEN_OFF:
484 ret = true;
485 break;
486 default:
487 break;
488 }
489 return ret;
490 }
491
IsPreBrightWakeUp(WakeupDeviceType type)492 bool PowerStateMachine::IsPreBrightWakeUp(WakeupDeviceType type)
493 {
494 bool ret = false;
495 switch (type) {
496 case WakeupDeviceType::WAKEUP_DEVICE_PRE_BRIGHT:
497 ret = true;
498 break;
499 case WakeupDeviceType::WAKEUP_DEVICE_PRE_BRIGHT_AUTH_SUCCESS:
500 ret = true;
501 break;
502 case WakeupDeviceType::WAKEUP_DEVICE_PRE_BRIGHT_AUTH_FAIL_SCREEN_ON:
503 ret = true;
504 break;
505 case WakeupDeviceType::WAKEUP_DEVICE_PRE_BRIGHT_AUTH_FAIL_SCREEN_OFF:
506 ret = true;
507 break;
508 default:
509 break;
510 }
511 return ret;
512 }
513
HandlePreBrightWakeUp(int64_t callTimeMs, WakeupDeviceType type, const std::string& details, const std::string& pkgName, bool timeoutTriggered)514 void PowerStateMachine::HandlePreBrightWakeUp(int64_t callTimeMs, WakeupDeviceType type, const std::string& details,
515 const std::string& pkgName, bool timeoutTriggered)
516 {
517 POWER_HILOGD(FEATURE_WAKEUP, "This wakeup event is trigged by %{public}s.", details.c_str());
518
519 auto pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
520 auto suspendController = pms->GetSuspendController();
521 if (suspendController != nullptr) {
522 suspendController->StopSleep();
523 } else {
524 POWER_HILOGI(FEATURE_WAKEUP, "suspendController is nullptr, can't stop sleep ffrt task");
525 }
526 if (stateAction_ != nullptr) {
527 stateAction_->Wakeup(callTimeMs, type, details, pkgName);
528 }
529 mDeviceState_.lastWakeupDeviceTime = callTimeMs;
530
531 StateChangeReason reason = GetReasonByWakeType(type);
532 if (!timeoutTriggered && IsPreBrightAuthReason(reason)) {
533 POWER_HILOGD(FEATURE_WAKEUP, "Cancel pre-bright-auth timer, rason=%{public}s",
534 PowerUtils::GetReasonTypeString(reason).c_str());
535 CancelDelayTimer(PowerStateMachine::CHECK_PRE_BRIGHT_AUTH_TIMEOUT_MSG);
536 }
537 SetState(PowerState::AWAKE, reason, true);
538
539 switch (type) {
540 case WakeupDeviceType::WAKEUP_DEVICE_PRE_BRIGHT: {
541 break;
542 }
543 case WakeupDeviceType::WAKEUP_DEVICE_PRE_BRIGHT_AUTH_SUCCESS: // fall through
544 case WakeupDeviceType::WAKEUP_DEVICE_PRE_BRIGHT_AUTH_FAIL_SCREEN_ON:
545 if (suspendController != nullptr) {
546 POWER_HILOGD(FEATURE_WAKEUP, "HandlePreBrightWakeUp. TriggerSyncSleepCallback start.");
547 suspendController->TriggerSyncSleepCallback(true);
548 } else {
549 POWER_HILOGI(FEATURE_WAKEUP, "HandlePreBrightWakeUp. suspendController is nullptr");
550 }
551 break;
552 case WakeupDeviceType::WAKEUP_DEVICE_PRE_BRIGHT_AUTH_FAIL_SCREEN_OFF:
553 if (suspendController != nullptr) {
554 suspendController->StartSleepTimer(
555 SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION,
556 static_cast<uint32_t>(SuspendAction::ACTION_AUTO_SUSPEND), 0);
557 } else {
558 POWER_HILOGI(FEATURE_WAKEUP, "suspendController is nullptr, can't restore sleep ffrt task");
559 }
560 break;
561 default:
562 break;
563 }
564
565 return;
566 }
567
WakeupDeviceInner( pid_t pid, int64_t callTimeMs, WakeupDeviceType type, const std::string& details, const std::string& pkgName)568 void PowerStateMachine::WakeupDeviceInner(
569 pid_t pid, int64_t callTimeMs, WakeupDeviceType type, const std::string& details, const std::string& pkgName)
570 {
571 #ifdef HAS_HIVIEWDFX_HITRACE_PART
572 PowerHitrace powerHitrace("WakeupDevice");
573 #endif
574 if (type > WakeupDeviceType::WAKEUP_DEVICE_MAX) {
575 POWER_HILOGW(FEATURE_WAKEUP, "Invalid type: %{public}d", type);
576 return;
577 }
578
579 #ifdef POWER_MANAGER_POWER_ENABLE_S4
580 if (!IsSwitchOpen() || IsHibernating()) {
581 #else
582 if (!IsSwitchOpen()) {
583 #endif
584 POWER_HILOGI(FEATURE_WAKEUP, "Switch is closed or hibernating, wakeup device do nothing.");
585 return;
586 }
587
588 if (type == WakeupDeviceType::WAKEUP_DEVICE_APPLICATION) {
589 type = ParseWakeupDeviceType(details);
590 }
591
592 if (IsPreBrightWakeUp(type)) {
593 HandlePreBrightWakeUp(callTimeMs, type, details, pkgName);
594 return;
595 }
596
597 // Call legacy wakeup, Check the screen state
598 auto pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
599 auto suspendController = pms->GetSuspendController();
600 if (suspendController != nullptr) {
601 POWER_HILOGI(FEATURE_WAKEUP, "Stop sleep ffrt task");
602 suspendController->StopSleep();
603 }
604
605 if (stateAction_ != nullptr) {
606 stateAction_->Wakeup(callTimeMs, type, details, pkgName);
607 }
608 mDeviceState_.lastWakeupDeviceTime = callTimeMs;
609
610 SetState(PowerState::AWAKE, GetReasonByWakeType(type), true);
611
612 if (suspendController != nullptr) {
613 POWER_HILOGD(FEATURE_WAKEUP, "WakeupDeviceInner. TriggerSyncSleepCallback start.");
614 suspendController->TriggerSyncSleepCallback(true);
615 } else {
616 POWER_HILOGI(FEATURE_WAKEUP, "WakeupDeviceInner. suspendController is nullptr");
617 }
618
619 POWER_HILOGD(FEATURE_WAKEUP, "Wakeup device finish");
620 }
621
622 void PowerStateMachine::RefreshActivityInner(
623 pid_t pid, int64_t callTimeMs, UserActivityType type, bool needChangeBacklight)
624 {
625 if (type > UserActivityType::USER_ACTIVITY_TYPE_MAX) {
626 POWER_HILOGW(FEATURE_ACTIVITY, "Invalid type: %{public}d", type);
627 return;
628 }
629 // Check the screen state
630 if (IsScreenOn() && !IsSettingState(PowerState::INACTIVE)) {
631 if (stateAction_ != nullptr) {
632 stateAction_->RefreshActivity(callTimeMs, type,
633 needChangeBacklight ? REFRESH_ACTIVITY_NEED_CHANGE_LIGHTS : REFRESH_ACTIVITY_NO_CHANGE_LIGHTS);
634 mDeviceState_.screenState.lastOnTime = GetTickCount();
635 }
636 if (GetState() == PowerState::DIM || IsSettingState(PowerState::DIM)) {
637 // Inactive to Awake will be blocked for this reason in CanTransitTo()
638 SetState(PowerState::AWAKE, StateChangeReason::STATE_CHANGE_REASON_REFRESH, true);
639 } else {
640 // There is a small chance that the last "if" statement occurs before the (already started) ffrt task
641 // is actually trying to set DIM state.
642 // In that case we may still (not guaranteed) interrupt it.
643 ResetInactiveTimer(false);
644 }
645 } else {
646 POWER_HILOGD(FEATURE_ACTIVITY, "Ignore refresh activity, screen is off");
647 }
648 }
649
650 bool PowerStateMachine::CheckRefreshTime()
651 {
652 // The minimum refreshactivity interval is 100ms!!
653 int64_t now = GetTickCount();
654 if ((mDeviceState_.lastRefreshActivityTime + MIN_TIME_MS_BETWEEN_USERACTIVITIES) > now) {
655 return true;
656 }
657 mDeviceState_.lastRefreshActivityTime = now;
658 return false;
659 }
660
661 bool PowerStateMachine::OverrideScreenOffTimeInner(int64_t timeout)
662 {
663 if (!isScreenOffTimeOverride_) {
664 int64_t beforeOverrideTime = this->GetDisplayOffTime();
665 isScreenOffTimeOverride_ = true;
666 g_beforeOverrideTime = beforeOverrideTime;
667 }
668 this->SetDisplayOffTime(timeout, false);
669 POWER_HILOGD(COMP_SVC, "Override screenOffTime finish");
670 return true;
671 }
672
673 bool PowerStateMachine::RestoreScreenOffTimeInner()
674 {
675 if (!isScreenOffTimeOverride_) {
676 POWER_HILOGD(COMP_SVC, "RestoreScreenOffTime is not override, no need to restore");
677 return false;
678 }
679 this->SetDisplayOffTime(g_beforeOverrideTime, false);
680 isScreenOffTimeOverride_ = false;
681 POWER_HILOGD(COMP_SVC, "Restore screenOffTime finish");
682 return true;
683 }
684
685 bool PowerStateMachine::ForceSuspendDeviceInner(pid_t pid, int64_t callTimeMs)
686 {
687 SetState(
688 PowerState::INACTIVE, GetReasonBySuspendType(SuspendDeviceType::SUSPEND_DEVICE_REASON_FORCE_SUSPEND), true);
689 auto pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
690 auto suspendController = pms->GetSuspendController();
691 if (suspendController != nullptr) {
692 POWER_HILOGI(FEATURE_SUSPEND, "ForceSuspendDeviceInner StartSleepTimer start.");
693 suspendController->StartSleepTimer(
694 SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION,
695 static_cast<uint32_t>(SuspendAction::ACTION_FORCE_SUSPEND), 0);
696 }
697
698 POWER_HILOGI(FEATURE_SUSPEND, "Force suspend finish");
699 return true;
700 }
701
702 #ifdef POWER_MANAGER_POWER_ENABLE_S4
703 bool PowerStateMachine::PrepareHibernate(bool clearMemory)
704 {
705 auto pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
706 auto hibernateController = pms->GetHibernateController();
707 if (hibernateController == nullptr) {
708 POWER_HILOGE(FEATURE_SUSPEND, "hibernateController is nullptr.");
709 return false;
710 }
711 SystemSuspendController::GetInstance().Wakeup();
712 bool ret = true;
713 if (!SetState(PowerState::INACTIVE, StateChangeReason::STATE_CHANGE_REASON_SYSTEM, true)) {
714 POWER_HILOGE(FEATURE_POWER_STATE, "failed to set state to inactive.");
715 }
716
717 hibernateController->PreHibernate();
718 g_preHibernateStart = GetTickCount();
719 if (clearMemory) {
720 if (AccountSA::OsAccountManager::DeactivateAllOsAccounts() != ERR_OK) {
721 POWER_HILOGE(FEATURE_SUSPEND, "deactivate all os accounts failed.");
722 return false;
723 }
724 int32_t id;
725 if (AccountSA::OsAccountManager::GetDefaultActivatedOsAccount(id) != ERR_OK) {
726 POWER_HILOGE(FEATURE_SUSPEND, "get default activated os account failed.");
727 return false;
728 }
729 if (AccountSA::OsAccountManager::ActivateOsAccount(id) != ERR_OK) {
730 POWER_HILOGE(FEATURE_SUSPEND, "activate os account failed.");
731 return false;
732 }
733 }
734 if (clearMemory) {
735 if (!OHOS::system::SetParameter(POWERMGR_STOPSERVICE.c_str(), "true")) {
736 POWER_HILOGE(FEATURE_SUSPEND, "set parameter POWERMGR_STOPSERVICE true failed.");
737 return false;
738 }
739 }
740
741 if (!SetState(PowerState::HIBERNATE, StateChangeReason::STATE_CHANGE_REASON_SYSTEM, true)) {
742 POWER_HILOGE(FEATURE_POWER_STATE, "failed to set state to hibernate.");
743 ret = false;
744 }
745 return ret;
746 }
747 #endif
748
749 #ifdef POWER_MANAGER_POWER_ENABLE_S4
750 uint32_t PowerStateMachine::GetPreHibernateDelay()
751 {
752 int64_t preHibernateEnd = GetTickCount();
753 uint32_t preHibernateDelay = static_cast<uint32_t>(preHibernateEnd - g_preHibernateStart);
754 preHibernateDelay = preHibernateDelay > HIBERNATE_DELAY_MS ? 0 : HIBERNATE_DELAY_MS - preHibernateDelay;
755 POWER_HILOGI(FEATURE_SUSPEND, "preHibernateDelay = %{public}u", preHibernateDelay);
756 return preHibernateDelay;
757 }
758 #endif
759
760 #ifdef POWER_MANAGER_POWER_ENABLE_S4
761 bool PowerStateMachine::HibernateInner(bool clearMemory)
762 {
763 POWER_HILOGI(FEATURE_POWER_STATE, "HibernateInner begin.");
764 auto pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
765 auto hibernateController = pms->GetHibernateController();
766 if (hibernateController == nullptr) {
767 POWER_HILOGE(FEATURE_SUSPEND, "hibernateController is nullptr.");
768 return false;
769 }
770 if (hibernating_) {
771 POWER_HILOGE(FEATURE_SUSPEND, "the device is hibernating, please try again later.");
772 return false;
773 }
774 hibernating_ = true;
775 if (!PrepareHibernate(clearMemory) && clearMemory) {
776 POWER_HILOGE(FEATURE_SUSPEND, "prepare hibernate failed, shutdown begin.");
777 pms->ShutDownDevice("shutdown_by_user");
778 hibernating_ = false;
779 return true;
780 }
781
782 FFRTTask task = [hibernateController, this, clearMemory, pms]() {
783 bool success = hibernateController->Hibernate(clearMemory);
784 if (!success && clearMemory) {
785 POWER_HILOGE(FEATURE_SUSPEND, "hibernate failed, shutdown begin.");
786 pms->ShutDownDevice("shutdown_by_user");
787 hibernating_ = false;
788 return;
789 }
790 if (success) {
791 switchOpen_ = true;
792 }
793 hibernating_ = false;
794 if (!SetState(PowerState::AWAKE, StateChangeReason::STATE_CHANGE_REASON_SYSTEM, true)) {
795 POWER_HILOGE(FEATURE_POWER_STATE, "failed to set state to awake when hibernate.");
796 }
797 if (clearMemory) {
798 if (!OHOS::system::SetParameter(POWERMGR_STOPSERVICE.c_str(), "false")) {
799 POWER_HILOGE(FEATURE_SUSPEND, "set parameter POWERMGR_STOPSERVICE false failed.");
800 }
801 }
802 hibernateController->PostHibernate(success);
803 POWER_HILOGI(FEATURE_SUSPEND, "power mgr machine hibernate end.");
804 };
805 if (ffrtTimer_ == nullptr) {
806 POWER_HILOGE(FEATURE_SUSPEND, "ffrtTimer is null");
807 hibernating_ = false;
808 return false;
809 }
810 ffrtTimer_->SetTimer(TIMER_ID_HIBERNATE, task, GetPreHibernateDelay());
811 return true;
812 }
813 #endif
814
815 bool PowerStateMachine::IsScreenOn(bool needPrintLog)
816 {
817 #ifdef POWER_MANAGER_ENABLE_EXTERNAL_SCREEN_MANAGEMENT
818 bool isScreenOn {false};
819 // When there's external screen, the original way to get screen state is inaccurate,
820 // so use PowerState instead
821 if (GetExternalScreenNumber() > 0) {
822 PowerState powerState = GetState();
823 isScreenOn = (powerState == PowerState::AWAKE) || (powerState == PowerState::DIM);
824 } else {
825 DisplayState displayState = stateAction_->GetDisplayState();
826 isScreenOn = (displayState == DisplayState::DISPLAY_ON) || (displayState == DisplayState::DISPLAY_DIM);
827 }
828 #else
829 DisplayState state = stateAction_->GetDisplayState();
830 bool isScreenOn = (state == DisplayState::DISPLAY_ON) || (state == DisplayState::DISPLAY_DIM);
831 #endif
832
833 if (needPrintLog) {
834 POWER_HILOGD(FEATURE_POWER_STATE, "Current screen is %{public}s", isScreenOn ? "ON" : "OFF");
835 }
836 return isScreenOn;
837 }
838
839 bool PowerStateMachine::IsFoldScreenOn()
840 {
841 POWER_HILOGI(FEATURE_POWER_STATE,
842 "IsFoldScreenOn settingOnStateFlag_ is %{public}d and settingOffStateFlag_ is %{public}d",
843 settingOnStateFlag_.load(), settingOffStateFlag_.load());
844
845 if (settingOnStateFlag_ == true) {
846 POWER_HILOGI(FEATURE_POWER_STATE, "Current fold screen is going on");
847 return true;
848 }
849 if (settingOffStateFlag_ == true) {
850 POWER_HILOGI(FEATURE_POWER_STATE, "Current fold screen is going off");
851 return false;
852 }
853 DisplayState state = stateAction_->GetDisplayState();
854 if (state == DisplayState::DISPLAY_ON || state == DisplayState::DISPLAY_DIM) {
855 POWER_HILOGI(FEATURE_POWER_STATE, "Current fold screen is on or going on");
856 return true;
857 }
858 POWER_HILOGI(FEATURE_POWER_STATE, "Current fold screen state is off, state: %{public}u", state);
859 return false;
860 }
861
862 bool PowerStateMachine::IsCollaborationScreenOn()
863 {
864 return isAwakeNotified_.load(std::memory_order_relaxed);
865 }
866
867 void PowerStateMachine::ReceiveScreenEvent(bool isScreenOn)
868 {
869 POWER_HILOGD(FEATURE_POWER_STATE, "Enter");
870 std::lock_guard lock(mutex_);
871 auto prestate = mDeviceState_.screenState.state;
872 if (isScreenOn) {
873 mDeviceState_.screenState.lastOnTime = GetTickCount();
874 } else {
875 mDeviceState_.screenState.lastOffTime = GetTickCount();
876 }
877 if (prestate != mDeviceState_.screenState.state) {
878 NotifyPowerStateChanged(isScreenOn ? PowerState::AWAKE : PowerState::INACTIVE);
879 }
880 }
881
882 void PowerStateMachine::RegisterPowerStateCallback(const sptr<IPowerStateCallback>& callback, bool isSync)
883 {
884 std::lock_guard lock(mutex_);
885 RETURN_IF(callback == nullptr);
886 auto object = callback->AsObject();
887 RETURN_IF(object == nullptr);
888
889 bool result = false;
890 if (isSync) {
891 auto retIt = syncPowerStateListeners_.insert(callback);
892 result = retIt.second;
893 POWER_HILOGD(FEATURE_POWER_STATE, "sync listeners.size = %{public}d, insertOk = %{public}d",
894 static_cast<unsigned int>(syncPowerStateListeners_.size()), retIt.second);
895 } else {
896 auto retIt = asyncPowerStateListeners_.insert(callback);
897 result = retIt.second;
898 POWER_HILOGD(FEATURE_POWER_STATE, "async listeners.size = %{public}d, insertOk = %{public}d",
899 static_cast<unsigned int>(asyncPowerStateListeners_.size()), retIt.second);
900 }
901 if (result) {
902 object->AddDeathRecipient(powerStateCBDeathRecipient_);
903 }
904 }
905
906 void PowerStateMachine::UnRegisterPowerStateCallback(const sptr<IPowerStateCallback>& callback)
907 {
908 std::lock_guard lock(mutex_);
909 RETURN_IF(callback == nullptr);
910 auto object = callback->AsObject();
911 RETURN_IF(object == nullptr);
912 size_t eraseNum = 0;
913 if (syncPowerStateListeners_.find(callback) != syncPowerStateListeners_.end()) {
914 eraseNum = syncPowerStateListeners_.erase(callback);
915 if (eraseNum != 0) {
916 object->RemoveDeathRecipient(powerStateCBDeathRecipient_);
917 }
918 POWER_HILOGD(FEATURE_POWER_STATE, "sync listeners.size = %{public}d, eraseNum = %{public}zu",
919 static_cast<unsigned int>(syncPowerStateListeners_.size()), eraseNum);
920 } else {
921 eraseNum = asyncPowerStateListeners_.erase(callback);
922 if (eraseNum != 0) {
923 object->RemoveDeathRecipient(powerStateCBDeathRecipient_);
924 }
925 POWER_HILOGD(FEATURE_POWER_STATE, "async listeners.size = %{public}d, eraseNum = %{public}zu",
926 static_cast<unsigned int>(asyncPowerStateListeners_.size()), eraseNum);
927 }
928 }
929
930 void PowerStateMachine::EnableMock(IDeviceStateAction* mockAction)
931 {
932 std::lock_guard lock(mutex_);
933 displayOffTime_ = DEFAULT_DISPLAY_OFF_TIME_MS;
934 sleepTime_ = DEFAULT_SLEEP_TIME_MS;
935 ResetInactiveTimer();
936
937 std::unique_ptr<IDeviceStateAction> mock(mockAction);
938 if (stateAction_ != nullptr) {
939 stateAction_.reset();
940 }
941 stateAction_ = std::move(mock);
942 }
943
944 void PowerStateMachine::NotifyPowerStateChanged(PowerState state, StateChangeReason reason)
945 {
946 if (GetState() == PowerState::INACTIVE &&
947 !enabledScreenOffEvent_.load(std::memory_order_relaxed) &&
948 reason == StateChangeReason::STATE_CHANGE_REASON_TIMEOUT_NO_SCREEN_LOCK) {
949 POWER_HILOGI(FEATURE_POWER_STATE, "[UL_POWER] not notify inactive power state");
950 return;
951 }
952 POWER_HILOGD(
953 FEATURE_POWER_STATE, "state=%{public}u, listeners.size=%{public}zu", state, syncPowerStateListeners_.size());
954 #ifdef HAS_HIVIEWDFX_HISYSEVENT_PART
955 HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::POWER, "STATE", HiviewDFX::HiSysEvent::EventType::STATISTIC, "STATE",
956 static_cast<uint32_t>(state));
957 #endif
958 std::lock_guard lock(mutex_);
959 int64_t now = GetTickCount();
960 // Send Notification event
961 SendEventToPowerMgrNotify(state, now);
962
963 // Call back all native function
964 for (auto& listener : asyncPowerStateListeners_) {
965 listener->OnAsyncPowerStateChanged(state);
966 }
967 for (auto& listener : syncPowerStateListeners_) {
968 listener->OnPowerStateChanged(state);
969 }
970 }
971
972 void PowerStateMachine::SendEventToPowerMgrNotify(PowerState state, int64_t callTime)
973 {
974 auto pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
975 if (pms == nullptr) {
976 POWER_HILOGE(FEATURE_POWER_STATE, "Pms is nullptr");
977 return;
978 }
979 auto notify = pms->GetPowerMgrNotify();
980 if (notify == nullptr) {
981 POWER_HILOGE(FEATURE_POWER_STATE, "Notify is null");
982 return;
983 }
984
985 switch (state) {
986 case PowerState::AWAKE: {
987 notify->PublishScreenOnEvents(callTime);
988 isAwakeNotified_.store(true, std::memory_order_relaxed);
989 #ifdef POWER_MANAGER_ENABLE_FORCE_SLEEP_BROADCAST
990 auto suspendController = pms->GetSuspendController();
991 if (suspendController != nullptr && suspendController->GetForceSleepingFlag()) {
992 notify->PublishExitForceSleepEvents(callTime);
993 POWER_HILOGI(FEATURE_POWER_STATE, "Set flag of force sleeping to false");
994 suspendController->SetForceSleepingFlag(false);
995 }
996 #endif
997 break;
998 }
999 case PowerState::INACTIVE: {
1000 notify->PublishScreenOffEvents(callTime);
1001 isAwakeNotified_.store(false, std::memory_order_relaxed);
1002 break;
1003 }
1004 case PowerState::SLEEP: {
1005 #ifdef POWER_MANAGER_ENABLE_FORCE_SLEEP_BROADCAST
1006 auto suspendController = pms->GetSuspendController();
1007 if (suspendController != nullptr && suspendController->GetForceSleepingFlag()) {
1008 notify->PublishEnterForceSleepEvents(callTime);
1009 }
1010 break;
1011 #endif
1012 POWER_HILOGI(FEATURE_POWER_STATE, "No need to publish EnterForceSleepEvent, state:%{public}u", state);
1013 break;
1014 }
1015 default:
1016 POWER_HILOGI(FEATURE_POWER_STATE, "No need to publish event, state:%{public}u", state);
1017 }
1018 }
1019
1020 void PowerStateMachine::PowerStateCallbackDeathRecipient::OnRemoteDied(const wptr<IRemoteObject>& remote)
1021 {
1022 if (remote == nullptr || remote.promote() == nullptr) {
1023 return;
1024 }
1025 sptr<IPowerStateCallback> callback = iface_cast<IPowerStateCallback>(remote.promote());
1026 FFRTTask unRegFunc = [callback] {
1027 auto pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
1028 if (pms == nullptr) {
1029 POWER_HILOGE(FEATURE_POWER_STATE, "Pms is nullptr");
1030 return;
1031 }
1032 pms->UnRegisterPowerStateCallback(callback);
1033 };
1034 FFRTUtils::SubmitTask(unRegFunc);
1035 }
1036
1037 void PowerStateMachine::SetDelayTimer(int64_t delayTime, int32_t event)
1038 {
1039 if (!ffrtTimer_) {
1040 POWER_HILOGE(FEATURE_ACTIVITY, "Failed to set delay timer, the timer pointer is null");
1041 return;
1042 }
1043 POWER_HILOGD(FEATURE_ACTIVITY, "Set delay timer, delayTime=%{public}s, event=%{public}d",
1044 std::to_string(delayTime).c_str(), event);
1045
1046 switch (event) {
1047 case CHECK_USER_ACTIVITY_TIMEOUT_MSG: {
1048 FFRTTask task = [this] { this->HandleActivityTimeout(); };
1049 ffrtTimer_->SetTimer(TIMER_ID_USER_ACTIVITY_TIMEOUT, task, delayTime);
1050 break;
1051 }
1052 case CHECK_USER_ACTIVITY_OFF_TIMEOUT_MSG: {
1053 auto pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
1054 auto suspendController = pms->GetSuspendController();
1055 if (suspendController == nullptr) {
1056 POWER_HILOGW(FEATURE_ACTIVITY, "suspendController is nullptr");
1057 return;
1058 }
1059 suspendController->HandleEvent(delayTime);
1060 break;
1061 }
1062 case CHECK_PROXIMITY_SCREEN_OFF_MSG: {
1063 FFRTTask delayScreenOffTask = [this] {
1064 POWER_HILOGI(FEATURE_POWER_STATE, "proximity-screen-off timer task is triggered");
1065 proximityScreenOffTimerStarted_.store(false, std::memory_order_relaxed);
1066 auto pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
1067 auto suspendController = pms->GetSuspendController();
1068 if (suspendController == nullptr) {
1069 POWER_HILOGW(
1070 FEATURE_POWER_STATE, "suspendController is nullptr, exit proximity-screen-off timer task");
1071 return;
1072 }
1073 bool ret = SetState(PowerState::INACTIVE, StateChangeReason::STATE_CHANGE_REASON_PROXIMITY, true);
1074 if (ret) {
1075 suspendController->StartSleepTimer(SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION,
1076 static_cast<uint32_t>(SuspendAction::ACTION_AUTO_SUSPEND), 0);
1077 }
1078 };
1079 ffrtTimer_->SetTimer(TIMER_ID_PROXIMITY_SCREEN_OFF, delayScreenOffTask, delayTime);
1080 proximityScreenOffTimerStarted_.store(true, std::memory_order_relaxed);
1081 break;
1082 }
1083 default: {
1084 break;
1085 }
1086 }
1087 }
1088
1089 void PowerStateMachine::CancelDelayTimer(int32_t event)
1090 {
1091 if (!ffrtTimer_) {
1092 POWER_HILOGE(FEATURE_ACTIVITY, "Failed to cancel delay timer, the timer pointer is null");
1093 return;
1094 }
1095 POWER_HILOGD(FEATURE_ACTIVITY, "Cancel delay timer, event: %{public}d", event);
1096
1097 switch (event) {
1098 case CHECK_USER_ACTIVITY_TIMEOUT_MSG: {
1099 ffrtTimer_->CancelTimer(TIMER_ID_USER_ACTIVITY_TIMEOUT);
1100 break;
1101 }
1102 case CHECK_USER_ACTIVITY_OFF_TIMEOUT_MSG: {
1103 auto pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
1104 auto suspendController = pms->GetSuspendController();
1105 if (suspendController == nullptr) {
1106 POWER_HILOGW(FEATURE_ACTIVITY, "suspendController is nullptr");
1107 return;
1108 }
1109 suspendController->CancelEvent();
1110 break;
1111 }
1112 case CHECK_PRE_BRIGHT_AUTH_TIMEOUT_MSG: {
1113 ffrtTimer_->CancelTimer(TIMER_ID_PRE_BRIGHT_AUTH);
1114 break;
1115 }
1116 case CHECK_PROXIMITY_SCREEN_OFF_MSG: {
1117 ffrtTimer_->CancelTimer(TIMER_ID_PROXIMITY_SCREEN_OFF);
1118 proximityScreenOffTimerStarted_.store(false, std::memory_order_relaxed);
1119 break;
1120 }
1121 default: {
1122 break;
1123 }
1124 }
1125 }
1126
1127 void PowerStateMachine::ResetInactiveTimer(bool needPrintLog)
1128 {
1129 // change the flag to notify the thread which is setting DIM
1130 int64_t expectedFlag = static_cast<int64_t>(PowerState::DIM);
1131 settingStateFlag_.compare_exchange_strong(
1132 expectedFlag, static_cast<int64_t>(SettingStateFlag::StateFlag::SETTING_DIM_INTERRUPTED));
1133 CancelDelayTimer(PowerStateMachine::CHECK_USER_ACTIVITY_TIMEOUT_MSG);
1134 CancelDelayTimer(PowerStateMachine::CHECK_USER_ACTIVITY_OFF_TIMEOUT_MSG);
1135 if (this->GetDisplayOffTime() < 0) {
1136 if (needPrintLog) {
1137 POWER_HILOGI(FEATURE_ACTIVITY, "Auto display off is disabled");
1138 }
1139 return;
1140 }
1141
1142 int64_t displayOffTime = this->GetDisplayOffTime();
1143 ResetScreenOffPreTimeForSwing(displayOffTime);
1144 this->SetDelayTimer(
1145 displayOffTime - this->GetDimTime(displayOffTime), PowerStateMachine::CHECK_USER_ACTIVITY_TIMEOUT_MSG);
1146 if (needPrintLog) {
1147 POWER_HILOGI(FEATURE_ACTIVITY, "reset inactive timer: %{public}" PRId64, displayOffTime);
1148 }
1149 }
1150
1151 void PowerStateMachine::ResetScreenOffPreTimeForSwing(int64_t displayOffTime)
1152 {
1153 int64_t now = GetTickCount();
1154 int64_t nextTimeOut = now + displayOffTime - this->GetDimTime(displayOffTime);
1155 POWER_HILOGD(FEATURE_SCREEN_OFF_PRE,
1156 "now=%{public}lld,displayOffTime=%{public}lld,nextTimeOut=%{public}lld",
1157 static_cast<long long>(now), static_cast<long long>(displayOffTime), static_cast<long long>(nextTimeOut));
1158 auto pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
1159 auto screenOffPreController = pms->GetScreenOffPreController();
1160 if (screenOffPreController != nullptr && screenOffPreController->IsRegistered()) {
1161 screenOffPreController->SchedulEyeDetectTimeout(nextTimeOut, now);
1162 }
1163 }
1164
1165 void PowerStateMachine::ResetSleepTimer()
1166 {
1167 CancelDelayTimer(PowerStateMachine::CHECK_USER_ACTIVITY_TIMEOUT_MSG);
1168 CancelDelayTimer(PowerStateMachine::CHECK_USER_ACTIVITY_OFF_TIMEOUT_MSG);
1169 if (this->GetSleepTime() < 0) {
1170 POWER_HILOGD(FEATURE_ACTIVITY, "Auto sleep is disabled");
1171 return;
1172 }
1173 }
1174
1175 void PowerStateMachine::SetAutoSuspend(SuspendDeviceType type, uint32_t delay)
1176 {
1177 auto pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
1178 if (pms == nullptr) {
1179 POWER_HILOGE(FEATURE_SUSPEND, "Pms is nullptr");
1180 return;
1181 }
1182 auto suspendController = pms->GetSuspendController();
1183 if (suspendController == nullptr) {
1184 POWER_HILOGE(FEATURE_SUSPEND, "Suspend controller is nullptr");
1185 return;
1186 }
1187 suspendController->StartSleepTimer(type, static_cast<uint32_t>(SuspendAction::ACTION_AUTO_SUSPEND), delay);
1188 POWER_HILOGD(FEATURE_SUSPEND, "Set auto suspend finish");
1189 }
1190
1191 void PowerStateMachine::ShowCurrentScreenLocks()
1192 {
1193 auto pms = pms_.promote();
1194 if (pms == nullptr) {
1195 POWER_HILOGE(FEATURE_RUNNING_LOCK, "Pms is nullptr");
1196 return;
1197 }
1198 std::map<std::string, RunningLockInfo> screenOnLockLists;
1199 pms_->QueryRunningLockListsInner(screenOnLockLists);
1200 std::string message;
1201 uint32_t mapSize = screenOnLockLists.size();
1202 uint32_t counter = 0;
1203 for (auto it : screenOnLockLists) {
1204 counter++;
1205 message.append(std::to_string(counter)).append(". ")
1206 .append("bundleName=").append(it.second.bundleName)
1207 .append(" name=").append(it.second.name)
1208 .append(" pid=").append(std::to_string(it.second.pid))
1209 .append(". ");
1210 }
1211 if (counter == 0) {
1212 return;
1213 }
1214 POWER_HILOGI(FEATURE_RUNNING_LOCK, "%{public}d screen on locks as follows: %{public}s", mapSize, message.c_str());
1215 }
1216
1217 #ifdef HAS_SENSORS_SENSOR_PART
1218 bool PowerStateMachine::IsProximityClose()
1219 {
1220 auto pms = pms_.promote();
1221 if (pms == nullptr) {
1222 POWER_HILOGE(FEATURE_RUNNING_LOCK, "Pms is nullptr");
1223 return false;
1224 }
1225 auto runningLockMgr = pms->GetRunningLockMgr();
1226 if (runningLockMgr == nullptr) {
1227 POWER_HILOGE(FEATURE_RUNNING_LOCK, "RunningLockMgr is nullptr");
1228 return false;
1229 }
1230 return runningLockMgr->IsProximityClose();
1231 }
1232 #endif
1233
1234 void PowerStateMachine::HandleActivityTimeout()
1235 {
1236 POWER_HILOGD(FEATURE_ACTIVITY, "Enter, displayState = %{public}d", stateAction_->GetDisplayState());
1237 SetState(PowerState::DIM, StateChangeReason::STATE_CHANGE_REASON_TIMEOUT);
1238 }
1239
1240 void PowerStateMachine::HandleActivitySleepTimeout()
1241 {
1242 POWER_HILOGD(FEATURE_ACTIVITY, "Enter, displayState = %{public}d", stateAction_->GetDisplayState());
1243 if (!this->CheckRunningLock(PowerState::SLEEP)) {
1244 POWER_HILOGW(FEATURE_POWER_STATE, "RunningLock is blocking to transit to SLEEP");
1245 return;
1246 }
1247 DisplayState dispState = stateAction_->GetDisplayState();
1248 if (dispState == DisplayState::DISPLAY_OFF) {
1249 SetState(PowerState::SLEEP, StateChangeReason::STATE_CHANGE_REASON_TIMEOUT);
1250 } else {
1251 POWER_HILOGW(FEATURE_ACTIVITY, "Display is on, ignore activity sleep timeout, state = %{public}d", dispState);
1252 }
1253 }
1254
1255 void PowerStateMachine::HandleSystemWakeup()
1256 {
1257 POWER_HILOGD(FEATURE_WAKEUP, "Enter, displayState = %{public}d", stateAction_->GetDisplayState());
1258 if (IsScreenOn()) {
1259 SetState(PowerState::AWAKE, StateChangeReason::STATE_CHANGE_REASON_SYSTEM, true);
1260 } else {
1261 SetState(PowerState::INACTIVE, StateChangeReason::STATE_CHANGE_REASON_SYSTEM, true);
1262 }
1263 }
1264
1265 void PowerStateMachine::SetForceTimingOut(bool enabled)
1266 {
1267 bool isScreenOnLockActive = IsRunningLockEnabled(RunningLockType::RUNNINGLOCK_SCREEN);
1268 bool currentValue = forceTimingOut_.exchange(enabled);
1269 pid_t pid = IPCSkeleton::GetCallingPid();
1270 auto uid = IPCSkeleton::GetCallingUid();
1271 PowerState curState = GetState();
1272 POWER_HILOGI(FEATURE_RUNNING_LOCK,
1273 "SetForceTimingOut: %{public}s -> %{public}s, screenOnLockActive=%{public}s, PowerState=%{public}u, "
1274 "PID=%{public}d, UID=%{public}d",
1275 currentValue ? "TRUE" : "FALSE", enabled ? "TRUE" : "FALSE", isScreenOnLockActive ? "TRUE" : "FALSE", curState,
1276 pid, uid);
1277 if (currentValue == enabled || !isScreenOnLockActive || IsSettingState(PowerState::DIM)) {
1278 // no need to interact with screen state or timer
1279 return;
1280 }
1281 if (enabled) {
1282 // In case the PowerState is AWAKE, we need to reset the timer since there is no existing one.
1283 // Only reset the timer if no SetState operation is currently in progress, and if any,
1284 // make sure this ResetInactiveTimer operation does not interfere with it.
1285 // Because the goal here is to ensure that there exist some Timer, regardless who sets the timer.
1286 // I call it "weak" ResetInactiveTimer to distinguish it from the "strong" one invoked by RefreshActivity,
1287 // which (should) invalidates any time-out timer previously set.
1288 if (stateMutex_.try_lock()) {
1289 if (GetState() == PowerState::AWAKE) {
1290 ResetInactiveTimer();
1291 }
1292 stateMutex_.unlock();
1293 }
1294 } else {
1295 // SetForceTimingOut from TRUE to FALSE, with screen-on-lock active.
1296 // Need to exit DIM and/or reset(cancel) timer
1297 SetState(PowerState::AWAKE, StateChangeReason::STATE_CHANGE_REASON_REFRESH);
1298 }
1299 }
1300
1301 void PowerStateMachine::LockScreenAfterTimingOut(bool enabled, bool checkScreenOnLock, bool sendScreenOffEvent)
1302 {
1303 pid_t pid = IPCSkeleton::GetCallingPid();
1304 auto uid = IPCSkeleton::GetCallingUid();
1305 POWER_HILOGI(FEATURE_RUNNING_LOCK,
1306 "LockScreenAfterTimingOut: %{public}u, %{public}u, %{public}u, PID=%{public}d, UID=%{public}d",
1307 static_cast<uint32_t>(enabled), static_cast<uint32_t>(checkScreenOnLock),
1308 static_cast<uint32_t>(sendScreenOffEvent), pid, uid);
1309 enabledTimingOutLockScreen_.store(enabled, std::memory_order_relaxed);
1310 enabledTimingOutLockScreenCheckLock_.store(checkScreenOnLock, std::memory_order_relaxed);
1311 enabledScreenOffEvent_.store(sendScreenOffEvent, std::memory_order_relaxed);
1312 }
1313
1314 bool PowerStateMachine::CheckRunningLock(PowerState state)
1315 {
1316 POWER_HILOGD(FEATURE_RUNNING_LOCK, "Enter, state = %{public}u", state);
1317 auto pms = pms_.promote();
1318 if (pms == nullptr) {
1319 POWER_HILOGE(FEATURE_RUNNING_LOCK, "Pms is nullptr");
1320 return false;
1321 }
1322 auto runningLockMgr = pms->GetRunningLockMgr();
1323 if (runningLockMgr == nullptr) {
1324 POWER_HILOGE(FEATURE_RUNNING_LOCK, "RunningLockMgr is nullptr");
1325 return false;
1326 }
1327 if (state == PowerState::DIM) {
1328 // screen on lock need to block DIM state as well
1329 state = PowerState::INACTIVE;
1330 POWER_HILOGI(FEATURE_RUNNING_LOCK, "check Screen on Lock for DIM state");
1331 }
1332 auto iterator = lockMap_.find(state);
1333 if (iterator == lockMap_.end()) {
1334 POWER_HILOGI(FEATURE_RUNNING_LOCK, "No specific lock in lockMap_ for state: %{public}u", state);
1335 return true;
1336 }
1337
1338 std::shared_ptr<std::vector<RunningLockType>> pLock = iterator->second;
1339 for (std::vector<RunningLockType>::const_iterator iter = pLock->begin(); iter != pLock->end(); ++iter) {
1340 uint32_t count = runningLockMgr->GetValidRunningLockNum(*iter);
1341 if (count > 0) {
1342 POWER_HILOGD(FEATURE_POWER_STATE,
1343 "RunningLock %{public}s is locking (count=%{public}d), blocking %{public}s",
1344 PowerUtils::GetRunningLockTypeString(*iter).c_str(), count,
1345 PowerUtils::GetPowerStateString(state).c_str());
1346 return false;
1347 }
1348 }
1349
1350 POWER_HILOGD(FEATURE_RUNNING_LOCK, "No specific lock for state: %{public}u", state);
1351 return true;
1352 }
1353
1354 bool PowerStateMachine::IsRunningLockEnabled(RunningLockType type)
1355 {
1356 auto pms = pms_.promote();
1357 if (pms == nullptr) {
1358 POWER_HILOGE(FEATURE_POWER_STATE, "Pms is nullptr");
1359 return false;
1360 }
1361 auto runningLockMgr = pms->GetRunningLockMgr();
1362 if (runningLockMgr == nullptr) {
1363 POWER_HILOGE(FEATURE_POWER_STATE, "RunningLockMgr is nullptr");
1364 return false;
1365 }
1366 if (runningLockMgr->GetValidRunningLockNum(type) > 0) {
1367 return true;
1368 }
1369 return false;
1370 }
1371
1372 void PowerStateMachine::SetDisplayOffTime(int64_t time, bool needUpdateSetting)
1373 {
1374 POWER_HILOGI(FEATURE_POWER_STATE, "set display off time %{public}" PRId64 " -> %{public}" PRId64 "",
1375 displayOffTime_.load(), time);
1376 displayOffTime_ = time;
1377 if (currentState_ == PowerState::AWAKE) {
1378 if (isScreenOffTimeOverride_ == true) {
1379 ResetInactiveTimer(false);
1380 } else {
1381 ResetInactiveTimer();
1382 }
1383 }
1384 if (needUpdateSetting) {
1385 #ifdef POWER_MANAGER_ENABLE_CHARGING_TYPE_SETTING
1386 SettingHelper::SetSettingDisplayAcScreenOffTime(displayOffTime_);
1387 SettingHelper::SetSettingDisplayDcScreenOffTime(displayOffTime_);
1388 #else
1389 SettingHelper::SetSettingDisplayOffTime(displayOffTime_);
1390 #endif
1391 }
1392 }
1393
1394 void PowerStateMachine::DisplayOffTimeUpdateFunc()
1395 {
1396 auto pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
1397 if (pms == nullptr) {
1398 POWER_HILOGE(FEATURE_POWER_STATE, "get PowerMgrService fail");
1399 return;
1400 }
1401 auto stateMachine = pms->GetPowerStateMachine();
1402 if (stateMachine == nullptr) {
1403 POWER_HILOGE(FEATURE_POWER_STATE, "get PowerStateMachine fail");
1404 return;
1405 }
1406
1407 int64_t systemTime = stateMachine->GetDisplayOffTime();
1408 int64_t settingTime = pms->GetSettingDisplayOffTime(systemTime);
1409 if (settingTime == systemTime) {
1410 POWER_HILOGI(FEATURE_POWER_STATE, "setting display off time %{public}" PRId64 " already worked", settingTime);
1411 return;
1412 }
1413 POWER_HILOGI(FEATURE_POWER_STATE, "setting update display off time %{public}" PRId64 " -> %{public}" PRId64 "",
1414 systemTime, settingTime);
1415 g_beforeOverrideTime = settingTime;
1416 auto policy = DelayedSingleton<PowerModePolicy>::GetInstance();
1417 if (policy == nullptr) {
1418 POWER_HILOGE(FEATURE_POWER_STATE, "get PowerModePolicy fail");
1419 return;
1420 }
1421 policy->RemoveBackupMapSettingSwitch(PowerModePolicy::ServiceType::DISPLAY_OFFTIME);
1422 stateMachine->SetDisplayOffTime(settingTime, false);
1423 }
1424
1425 void PowerStateMachine::RegisterDisplayOffTimeObserver()
1426 {
1427 #ifdef POWER_MANAGER_ENABLE_CHARGING_TYPE_SETTING
1428 if (g_displayOffTimeAcObserver && g_displayOffTimeDcObserver) {
1429 #else
1430 if (g_displayOffTimeObserver) {
1431 #endif
1432 POWER_HILOGI(FEATURE_POWER_STATE, "setting display off time observer is already registered");
1433 return;
1434 }
1435 DisplayOffTimeUpdateFunc();
1436 SettingObserver::UpdateFunc updateFunc = [&](const std::string&) {
1437 PowerStateMachine::DisplayOffTimeUpdateFunc();
1438 };
1439 #ifdef POWER_MANAGER_ENABLE_CHARGING_TYPE_SETTING
1440 if (g_displayOffTimeAcObserver == nullptr) {
1441 g_displayOffTimeAcObserver = SettingHelper::RegisterSettingDisplayAcScreenOffTimeObserver(updateFunc);
1442 }
1443 if (g_displayOffTimeDcObserver == nullptr) {
1444 g_displayOffTimeDcObserver = SettingHelper::RegisterSettingDisplayDcScreenOffTimeObserver(updateFunc);
1445 }
1446 #else
1447 g_displayOffTimeObserver = SettingHelper::RegisterSettingDisplayOffTimeObserver(updateFunc);
1448 #endif
1449 }
1450
1451 void PowerStateMachine::UnregisterDisplayOffTimeObserver()
1452 {
1453 #ifdef POWER_MANAGER_ENABLE_CHARGING_TYPE_SETTING
1454 if (g_displayOffTimeAcObserver) {
1455 SettingHelper::UnregisterSettingObserver(g_displayOffTimeAcObserver);
1456 g_displayOffTimeAcObserver = nullptr;
1457 }
1458 if (g_displayOffTimeDcObserver) {
1459 SettingHelper::UnregisterSettingObserver(g_displayOffTimeDcObserver);
1460 g_displayOffTimeDcObserver = nullptr;
1461 }
1462 #else
1463 if (g_displayOffTimeObserver == nullptr) {
1464 POWER_HILOGD(FEATURE_POWER_STATE, "g_displayOffTimeObserver is nullptr, no need to unregister");
1465 return;
1466 }
1467 SettingHelper::UnregisterSettingObserver(g_displayOffTimeObserver);
1468 g_displayOffTimeObserver = nullptr;
1469 #endif
1470 }
1471
1472 void PowerStateMachine::SetSleepTime(int64_t time)
1473 {
1474 sleepTime_ = time;
1475 }
1476
1477 int64_t PowerStateMachine::GetDisplayOffTime()
1478 {
1479 return displayOffTime_;
1480 }
1481
1482 int64_t PowerStateMachine::GetDimTime(int64_t displayOffTime)
1483 {
1484 int64_t dimTime = displayOffTime / OFF_TIMEOUT_FACTOR;
1485 return std::clamp(dimTime, static_cast<int64_t>(0), MAX_DIM_TIME_MS);
1486 }
1487
1488 #ifdef POWER_MANAGER_ENABLE_EXTERNAL_SCREEN_MANAGEMENT
1489 int32_t PowerStateMachine::GetExternalScreenNumber() const
1490 {
1491 return externalScreenNumber_.load();
1492 }
1493
1494 void PowerStateMachine::IncreaseExternalScreenNumber()
1495 {
1496 ++externalScreenNumber_;
1497 }
1498
1499 void PowerStateMachine::DecreaseExternalScreenNumber()
1500 {
1501 int32_t curNum = externalScreenNumber_.load();
1502 if (curNum == 0) {
1503 POWER_HILOGW(COMP_SVC, "No external screen already");
1504 return;
1505 }
1506 --externalScreenNumber_;
1507 }
1508 #endif
1509
1510 bool PowerStateMachine::IsSettingState(PowerState state)
1511 {
1512 int64_t flag = settingStateFlag_.load();
1513 bool matched = flag == static_cast<int64_t>(state);
1514 if (matched) {
1515 return true;
1516 } else {
1517 return (
1518 state == PowerState::DIM && flag == static_cast<int64_t>(SettingStateFlag::StateFlag::FORCE_SETTING_DIM));
1519 }
1520 }
1521
1522 int64_t PowerStateMachine::GetSleepTime()
1523 {
1524 return sleepTime_;
1525 }
1526
1527 PowerStateMachine::ScreenChangeCheck::ScreenChangeCheck(std::shared_ptr<FFRTTimer> ffrtTimer,
1528 PowerState state, StateChangeReason reason): timer_(ffrtTimer), state_(state), reason_(reason)
1529 {
1530 // only check for screen on/off event
1531 if (state != PowerState::INACTIVE && state != PowerState::AWAKE) {
1532 return;
1533 }
1534
1535 if (!timer_) {
1536 POWER_HILOGE(FEATURE_POWER_STATE, "ScreenChangeCheck failed: invalid timer");
1537 return;
1538 }
1539
1540 pid_ = IPCSkeleton::GetCallingPid();
1541 uid_ = IPCSkeleton::GetCallingUid();
1542
1543 FFRTTask task = [this]() {
1544 Report("TIMEOUT");
1545 };
1546
1547 timer_->SetTimer(TIMER_ID_SCREEN_TIMEOUT_CHECK, task, SCREEN_CHANGE_TIMEOUT_MS);
1548 }
1549
1550 void PowerStateMachine::ScreenChangeCheck::Finish(TransitResult result)
1551 {
1552 if (!timer_) {
1553 return;
1554 }
1555 timer_->CancelTimer(TIMER_ID_SCREEN_TIMEOUT_CHECK);
1556
1557 bool transitSuccess = (result == TransitResult::SUCCESS) || (result == TransitResult::ALREADY_IN_STATE);
1558 bool skipReport = (result == TransitResult::LOCKING) || (result == TransitResult::FORBID_TRANSIT) ||
1559 !StateController::IsReallyFailed(reason_);
1560 if (transitSuccess || skipReport) {
1561 return;
1562 }
1563
1564 std::string msg = std::string("Transit failed with: ") + GetTransitResultString(result);
1565 }
1566
1567 void PowerStateMachine::ScreenChangeCheck::Report(const std::string &msg)
1568 {
1569 const char* eventName = (state_ == PowerState::INACTIVE) ? "SCREEN_OFF_TIMEOUT" : "SCREEN_ON_TIMEOUT";
1570 POWER_HILOGE(FEATURE_POWER_STATE, "event=%{public}s, reason=%{public}s, msg=%{public}s, pid=%{public}d,"
1571 " uid=%{public}d", eventName, PowerUtils::GetReasonTypeString(reason_).c_str(), msg.c_str(), pid_, uid_);
1572
1573 static int64_t lastReportTime = -1;
1574 int64_t now = GetTickCount();
1575 int64_t nextReportTime = lastReportTime + SCREEN_CHANGE_REPORT_INTERVAL_MS;
1576 if (nextReportTime > SCREEN_CHANGE_REPORT_INTERVAL_MS && now < nextReportTime) {
1577 POWER_HILOGD(FEATURE_POWER_STATE, "Will skip report for another %{public}s ms",
1578 std::to_string(nextReportTime - now).c_str());
1579 return;
1580 }
1581 lastReportTime = now;
1582 #ifdef HAS_HIVIEWDFX_HISYSEVENT_PART
1583 HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::POWER, eventName, HiviewDFX::HiSysEvent::EventType::FAULT,
1584 "PID", pid_, "UID", uid_, "PACKAGE_NAME", "", "PROCESS_NAME", "", "MSG", msg.c_str(),
1585 "REASON", PowerUtils::GetReasonTypeString(reason_).c_str());
1586 #endif
1587 }
1588
1589 std::shared_ptr<PowerStateMachine::StateController> PowerStateMachine::GetStateController(PowerState state)
1590 {
1591 auto iterator = controllerMap_.find(state);
1592 if (iterator == controllerMap_.end()) {
1593 return nullptr;
1594 }
1595 return iterator->second;
1596 }
1597
1598 bool PowerStateMachine::NeedShowScreenLocks(PowerState state)
1599 {
1600 return state == PowerState::AWAKE ||
1601 state == PowerState::INACTIVE || state == PowerState::DIM;
1602 }
1603
1604 void PowerStateMachine::UpdateSettingStateFlag(PowerState state, StateChangeReason reason)
1605 {
1606 if (reason == StateChangeReason::STATE_CHANGE_REASON_PRE_BRIGHT ||
1607 reason == StateChangeReason::STATE_CHANGE_REASON_PRE_BRIGHT_AUTH_FAIL_SCREEN_OFF) {
1608 settingOnStateFlag_ = false;
1609 settingOffStateFlag_ = true;
1610 return;
1611 }
1612 settingOnStateFlag_ = (state == PowerState::AWAKE);
1613 settingOffStateFlag_ = (state == PowerState::INACTIVE);
1614 }
1615
1616 void PowerStateMachine::RestoreSettingStateFlag()
1617 {
1618 settingOnStateFlag_ = false;
1619 settingOffStateFlag_ = false;
1620 }
1621
1622 void PowerStateMachine::HandleProximityScreenOffTimer(PowerState state, StateChangeReason reason)
1623 {
1624 if (!proximityScreenOffTimerStarted_.load()) {
1625 return;
1626 }
1627 if ((reason == StateChangeReason::STATE_CHANGE_REASON_DOUBLE_CLICK ||
1628 reason == StateChangeReason::STATE_CHANGE_REASON_PICKUP) &&
1629 IsProximityClose() && state == PowerState::AWAKE) {
1630 POWER_HILOGI(FEATURE_POWER_STATE, "Double-click or pickup is not allowed to cancel proximity-screen-off timer");
1631 return;
1632 }
1633 if (reason != StateChangeReason::STATE_CHANGE_REASON_PROXIMITY) {
1634 POWER_HILOGI(FEATURE_POWER_STATE, "Cancel proximity-screen-off timer, reason:%{public}s",
1635 PowerUtils::GetReasonTypeString(reason).c_str());
1636 CancelDelayTimer(PowerStateMachine::CHECK_PROXIMITY_SCREEN_OFF_MSG);
1637 return;
1638 }
1639 if (state == PowerState::AWAKE) {
1640 POWER_HILOGI(FEATURE_POWER_STATE, "Cancel proximity-screen-off timer, reason:%{public}s(away)",
1641 PowerUtils::GetReasonTypeString(reason).c_str());
1642 CancelDelayTimer(PowerStateMachine::CHECK_PROXIMITY_SCREEN_OFF_MSG);
1643 }
1644 }
1645
1646 bool PowerStateMachine::HandlePreBrightState(StateChangeReason reason)
1647 {
1648 bool ret = false;
1649 PowerStateMachine::PreBrightState curState = preBrightState_.load();
1650 if (reason == StateChangeReason::STATE_CHANGE_REASON_PRE_BRIGHT) {
1651 if (ffrtTimer_ != nullptr) {
1652 FFRTTask authFailTask = [this] {
1653 POWER_HILOGI(FEATURE_WAKEUP, "Auth result of PRE_BRIGHT isn't received within %{public}u ms",
1654 PRE_BRIGHT_AUTH_TIMER_DELAY_MS);
1655 const std::string detail = "pre_bright_auth_fail_screen_off";
1656 const std::string pkgName = "pre_bright_auth_time";
1657 HandlePreBrightWakeUp(GetTickCount(), WakeupDeviceType::WAKEUP_DEVICE_PRE_BRIGHT_AUTH_FAIL_SCREEN_OFF,
1658 detail, pkgName, true);
1659 };
1660 if (curState == PowerStateMachine::PRE_BRIGHT_STARTED) {
1661 POWER_HILOGD(FEATURE_WAKEUP, "Cancel pre-bright-auth timer, rason=%{public}s",
1662 PowerUtils::GetReasonTypeString(reason).c_str());
1663 CancelDelayTimer(PowerStateMachine::CHECK_PRE_BRIGHT_AUTH_TIMEOUT_MSG);
1664 }
1665 POWER_HILOGD(FEATURE_POWER_STATE, "Start pre-bright-auth timer");
1666 ffrtTimer_->SetTimer(TIMER_ID_PRE_BRIGHT_AUTH, authFailTask, PRE_BRIGHT_AUTH_TIMER_DELAY_MS);
1667 preBrightState_.store(PowerStateMachine::PRE_BRIGHT_STARTED, std::memory_order_relaxed);
1668 ret = true;
1669 }
1670 } else if (IsPreBrightAuthReason(reason)) {
1671 if (curState == PowerStateMachine::PRE_BRIGHT_STARTED) {
1672 preBrightState_.store(PowerStateMachine::PRE_BRIGHT_FINISHED, std::memory_order_relaxed);
1673 ret = true;
1674 }
1675 } else {
1676 if (curState == PowerStateMachine::PRE_BRIGHT_STARTED) {
1677 POWER_HILOGD(FEATURE_WAKEUP, "Cancel pre-bright-auth timer, rason=%{public}s",
1678 PowerUtils::GetReasonTypeString(reason).c_str());
1679 CancelDelayTimer(PowerStateMachine::CHECK_PRE_BRIGHT_AUTH_TIMEOUT_MSG);
1680 }
1681 preBrightState_.store(PowerStateMachine::PRE_BRIGHT_UNSTART, std::memory_order_relaxed);
1682 ret = true;
1683 }
1684 POWER_HILOGD(FEATURE_WAKEUP, "Pre bright state: %{public}u", static_cast<uint32_t>(preBrightState_.load()));
1685 return ret;
1686 }
1687
1688 bool PowerStateMachine::CheckFFRTTaskAvailability(PowerState state, StateChangeReason reason) const
1689 {
1690 if (!IsTimeoutReason(reason)) {
1691 return true;
1692 }
1693 void* curTask = ffrt_get_cur_task();
1694 if (curTask == nullptr) {
1695 // not actually an ffrt task;
1696 return true;
1697 }
1698 if (!ffrtTimer_) {
1699 POWER_HILOGE(FEATURE_POWER_STATE, "ffrtTimer_ is nullptr");
1700 return false;
1701 }
1702 const void* pendingTask = nullptr;
1703 switch (state) {
1704 case PowerState::DIM:
1705 pendingTask = ffrtTimer_->GetTaskHandlePtr(TIMER_ID_USER_ACTIVITY_TIMEOUT);
1706 break;
1707 case PowerState::INACTIVE:
1708 pendingTask = ffrtTimer_->GetTaskHandlePtr(TIMER_ID_USER_ACTIVITY_OFF);
1709 break;
1710 default:
1711 pendingTask = ffrtTimer_->GetTaskHandlePtr(TIMER_ID_SLEEP);
1712 break;
1713 }
1714 return curTask == pendingTask;
1715 }
1716
1717 bool PowerStateMachine::IsTimeoutReason(StateChangeReason reason) const
1718 {
1719 return reason == StateChangeReason::STATE_CHANGE_REASON_TIMEOUT_NO_SCREEN_LOCK ||
1720 reason == StateChangeReason::STATE_CHANGE_REASON_TIMEOUT;
1721 }
1722
1723 bool PowerStateMachine::SetState(PowerState state, StateChangeReason reason, bool force)
1724 {
1725 POWER_HILOGD(FEATURE_POWER_STATE, "state=%{public}s, reason=%{public}s, force=%{public}d",
1726 PowerUtils::GetPowerStateString(state).c_str(), PowerUtils::GetReasonTypeString(reason).c_str(), force);
1727 std::lock_guard<std::mutex> lock(stateMutex_);
1728 if (!CheckFFRTTaskAvailability(state, reason)) {
1729 POWER_HILOGI(FEATURE_POWER_STATE, "this timeout task is invalidated, directly return");
1730 return false;
1731 }
1732 ScreenChangeCheck timeoutCheck(ffrtTimer_, state, reason);
1733 SettingStateFlag flag(state, shared_from_this(), reason);
1734
1735 if (NeedShowScreenLocks(state)) {
1736 ShowCurrentScreenLocks();
1737 }
1738
1739 HandleProximityScreenOffTimer(state, reason);
1740 if (!HandlePreBrightState(reason)) {
1741 timeoutCheck.Finish(TransitResult::OTHER_ERR);
1742 return false;
1743 }
1744
1745 std::shared_ptr<StateController> pController = GetStateController(state);
1746 if (pController == nullptr) {
1747 POWER_HILOGW(FEATURE_POWER_STATE, "StateController is not init");
1748 timeoutCheck.Finish(TransitResult::OTHER_ERR);
1749 return false;
1750 }
1751 if (IsTimeoutReason(reason) && forceTimingOut_.load()) {
1752 force = true;
1753 }
1754 UpdateSettingStateFlag(state, reason);
1755 TransitResult ret = pController->TransitTo(reason, force);
1756 timeoutCheck.Finish(ret);
1757 POWER_HILOGI(FEATURE_POWER_STATE, "[UL_POWER] StateController::TransitTo %{public}s ret: %{public}d",
1758 PowerUtils::GetPowerStateString(state).c_str(), ret);
1759 RestoreSettingStateFlag();
1760 return (ret == TransitResult::SUCCESS || ret == TransitResult::ALREADY_IN_STATE);
1761 }
1762
1763 void PowerStateMachine::SetDisplaySuspend(bool enable)
1764 {
1765 POWER_HILOGD(FEATURE_POWER_STATE, "enable: %{public}d", enable);
1766 std::lock_guard<std::mutex> lock(stateMutex_);
1767 enableDisplaySuspend_ = enable;
1768 if (GetState() == PowerState::INACTIVE) {
1769 POWER_HILOGI(FEATURE_POWER_STATE, "Change display state");
1770 if (enable) {
1771 stateAction_->SetDisplayState(
1772 DisplayState::DISPLAY_SUSPEND, StateChangeReason::STATE_CHANGE_REASON_APPLICATION);
1773 } else {
1774 stateAction_->SetDisplayState(
1775 DisplayState::DISPLAY_OFF, StateChangeReason::STATE_CHANGE_REASON_APPLICATION);
1776 }
1777 }
1778 }
1779
1780 bool PowerStateMachine::TryToCancelScreenOff()
1781 {
1782 return stateAction_->TryToCancelScreenOff();
1783 }
1784
1785 void PowerStateMachine::BeginPowerkeyScreenOff()
1786 {
1787 stateAction_->BeginPowerkeyScreenOff();
1788 }
1789
1790 void PowerStateMachine::EndPowerkeyScreenOff()
1791 {
1792 stateAction_->EndPowerkeyScreenOff();
1793 }
1794
1795 StateChangeReason PowerStateMachine::GetReasonByUserActivity(UserActivityType type)
1796 {
1797 StateChangeReason ret = StateChangeReason::STATE_CHANGE_REASON_UNKNOWN;
1798 switch (type) {
1799 case UserActivityType::USER_ACTIVITY_TYPE_BUTTON:
1800 ret = StateChangeReason::STATE_CHANGE_REASON_HARD_KEY;
1801 break;
1802 case UserActivityType::USER_ACTIVITY_TYPE_TOUCH:
1803 ret = StateChangeReason::STATE_CHANGE_REASON_TOUCH;
1804 break;
1805 case UserActivityType::USER_ACTIVITY_TYPE_ACCESSIBILITY:
1806 ret = StateChangeReason::STATE_CHANGE_REASON_ACCESSIBILITY;
1807 break;
1808 case UserActivityType::USER_ACTIVITY_TYPE_SOFTWARE:
1809 ret = StateChangeReason::STATE_CHANGE_REASON_APPLICATION;
1810 break;
1811 case UserActivityType::USER_ACTIVITY_TYPE_ATTENTION: // fall through
1812 case UserActivityType::USER_ACTIVITY_TYPE_OTHER: // fall through
1813 default:
1814 break;
1815 }
1816 return ret;
1817 }
1818
1819 StateChangeReason PowerStateMachine::GetReasonByWakeType(WakeupDeviceType type)
1820 {
1821 POWER_HILOGD(FEATURE_WAKEUP, "WakeupDeviceType :%{public}u", type);
1822 StateChangeReason ret = StateChangeReason::STATE_CHANGE_REASON_UNKNOWN;
1823 switch (type) {
1824 case WakeupDeviceType::WAKEUP_DEVICE_POWER_BUTTON:
1825 ret = StateChangeReason::STATE_CHANGE_REASON_POWER_KEY;
1826 break;
1827 case WakeupDeviceType::WAKEUP_DEVICE_WAKE_KEY:
1828 ret = StateChangeReason::STATE_CHANGE_REASON_HARD_KEY;
1829 break;
1830 case WakeupDeviceType::WAKEUP_DEVICE_APPLICATION:
1831 ret = StateChangeReason::STATE_CHANGE_REASON_APPLICATION;
1832 break;
1833 case WakeupDeviceType::WAKEUP_DEVICE_PLUGGED_IN: // fall through
1834 case WakeupDeviceType::WAKEUP_DEVICE_HDMI:
1835 ret = StateChangeReason::STATE_CHANGE_REASON_CABLE;
1836 break;
1837 case WakeupDeviceType::WAKEUP_DEVICE_GESTURE:
1838 ret = StateChangeReason::STATE_CHANGE_REASON_TOUCH;
1839 break;
1840 case WakeupDeviceType::WAKEUP_DEVICE_CAMERA_LAUNCH:
1841 ret = StateChangeReason::STATE_CHANGE_REASON_CAMERA;
1842 break;
1843 case WakeupDeviceType::WAKEUP_DEVICE_WAKE_MOTION:
1844 ret = StateChangeReason::STATE_CHANGE_REASON_SENSOR;
1845 break;
1846 case WakeupDeviceType::WAKEUP_DEVICE_LID:
1847 ret = StateChangeReason::STATE_CHANGE_REASON_LID;
1848 break;
1849 case WakeupDeviceType::WAKEUP_DEVICE_DOUBLE_CLICK:
1850 ret = StateChangeReason::STATE_CHANGE_REASON_DOUBLE_CLICK;
1851 break;
1852 case WakeupDeviceType::WAKEUP_DEVICE_PEN:
1853 ret = StateChangeReason::STATE_CHANGE_REASON_PEN;
1854 break;
1855 case WakeupDeviceType::WAKEUP_DEVICE_KEYBOARD:
1856 ret = StateChangeReason::STATE_CHANGE_REASON_KEYBOARD;
1857 break;
1858 case WakeupDeviceType::WAKEUP_DEVICE_MOUSE:
1859 ret = StateChangeReason::STATE_CHANGE_REASON_MOUSE;
1860 break;
1861 case WakeupDeviceType::WAKEUP_DEVICE_SWITCH:
1862 ret = StateChangeReason::STATE_CHANGE_REASON_SWITCH;
1863 break;
1864 case WakeupDeviceType::WAKEUP_DEVICE_PRE_BRIGHT:
1865 ret = StateChangeReason::STATE_CHANGE_REASON_PRE_BRIGHT;
1866 break;
1867 case WakeupDeviceType::WAKEUP_DEVICE_PRE_BRIGHT_AUTH_SUCCESS:
1868 ret = StateChangeReason::STATE_CHANGE_REASON_PRE_BRIGHT_AUTH_SUCCESS;
1869 break;
1870 case WakeupDeviceType::WAKEUP_DEVICE_PRE_BRIGHT_AUTH_FAIL_SCREEN_ON:
1871 ret = StateChangeReason::STATE_CHANGE_REASON_PRE_BRIGHT_AUTH_FAIL_SCREEN_ON;
1872 break;
1873 case WakeupDeviceType::WAKEUP_DEVICE_PRE_BRIGHT_AUTH_FAIL_SCREEN_OFF:
1874 ret = StateChangeReason::STATE_CHANGE_REASON_PRE_BRIGHT_AUTH_FAIL_SCREEN_OFF;
1875 break;
1876 case WakeupDeviceType::WAKEUP_DEVICE_AOD_SLIDING:
1877 ret = StateChangeReason::STATE_CHANGE_REASON_AOD_SLIDING;
1878 break;
1879 case WakeupDeviceType::WAKEUP_DEVICE_INCOMING_CALL:
1880 ret = StateChangeReason::STATE_CHANGE_REASON_INCOMING_CALL;
1881 break;
1882 case WakeupDeviceType::WAKEUP_DEVICE_SHELL:
1883 ret = StateChangeReason::STATE_CHANGE_REASON_SHELL;
1884 break;
1885 case WakeupDeviceType::WAKEUP_DEVICE_PICKUP:
1886 ret = StateChangeReason::STATE_CHANGE_REASON_PICKUP;
1887 break;
1888 case WakeupDeviceType::WAKEUP_DEVICE_EXIT_SYSTEM_STR:
1889 ret = StateChangeReason::STATE_CHANGE_REASON_EXIT_SYSTEM_STR;
1890 break;
1891 case WakeupDeviceType::WAKEUP_DEVICE_UNKNOWN: // fall through
1892 default:
1893 break;
1894 }
1895 POWER_HILOGD(FEATURE_WAKEUP, "StateChangeReason: %{public}u", ret);
1896 return ret;
1897 }
1898
1899 StateChangeReason PowerStateMachine::GetReasonBySuspendType(SuspendDeviceType type)
1900 {
1901 POWER_HILOGD(FEATURE_SUSPEND, "SuspendDeviceType: %{public}u", type);
1902 StateChangeReason ret = StateChangeReason::STATE_CHANGE_REASON_UNKNOWN;
1903 switch (type) {
1904 case SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION:
1905 ret = StateChangeReason::STATE_CHANGE_REASON_APPLICATION;
1906 break;
1907 case SuspendDeviceType::SUSPEND_DEVICE_REASON_DEVICE_ADMIN:
1908 ret = StateChangeReason::STATE_CHANGE_REASON_REMOTE;
1909 break;
1910 case SuspendDeviceType::SUSPEND_DEVICE_REASON_TIMEOUT:
1911 ret = (enabledTimingOutLockScreen_.load() &&
1912 (!enabledTimingOutLockScreenCheckLock_.load() ||
1913 CheckRunningLock(PowerState::INACTIVE))) ?
1914 StateChangeReason::STATE_CHANGE_REASON_TIMEOUT :
1915 StateChangeReason::STATE_CHANGE_REASON_TIMEOUT_NO_SCREEN_LOCK;
1916 break;
1917 case SuspendDeviceType::SUSPEND_DEVICE_REASON_LID:
1918 ret = StateChangeReason::STATE_CHANGE_REASON_LID;
1919 break;
1920 case SuspendDeviceType::SUSPEND_DEVICE_REASON_SWITCH:
1921 ret = StateChangeReason::STATE_CHANGE_REASON_SWITCH;
1922 break;
1923 case SuspendDeviceType::SUSPEND_DEVICE_REASON_POWER_KEY: // fall through
1924 case SuspendDeviceType::SUSPEND_DEVICE_REASON_SLEEP_KEY:
1925 ret = StateChangeReason::STATE_CHANGE_REASON_HARD_KEY;
1926 break;
1927 case SuspendDeviceType::SUSPEND_DEVICE_REASON_HDMI:
1928 ret = StateChangeReason::STATE_CHANGE_REASON_CABLE;
1929 break;
1930 case SuspendDeviceType::SUSPEND_DEVICE_REASON_ACCESSIBILITY:
1931 ret = StateChangeReason::STATE_CHANGE_REASON_ACCESSIBILITY;
1932 break;
1933 case SuspendDeviceType::SUSPEND_DEVICE_REASON_FORCE_SUSPEND:
1934 ret = StateChangeReason::STATE_CHANGE_REASON_SYSTEM;
1935 break;
1936 default:
1937 break;
1938 }
1939 POWER_HILOGD(FEATURE_SUSPEND, "StateChangeReason: %{public}u", ret);
1940 return ret;
1941 }
1942
1943 void PowerStateMachine::AppendDumpInfo(std::string& result, std::string& reason, std::string& time)
1944 {
1945 result.append("POWER STATE DUMP:\n");
1946 result.append("Current State: ")
1947 .append(PowerUtils::GetPowerStateString(GetState()))
1948 .append(" Reason: ")
1949 .append(reason)
1950 .append(" Time: ")
1951 .append(time)
1952 .append("\n");
1953
1954 result.append("ScreenOffTime: Timeout=");
1955 if (isScreenOffTimeOverride_) {
1956 result.append((ToString(g_beforeOverrideTime)))
1957 .append("ms OverrideTimeout=")
1958 .append((ToString(GetDisplayOffTime())))
1959 .append("ms\n");
1960 } else {
1961 result.append((ToString(GetDisplayOffTime()))).append("ms\n");
1962 }
1963
1964 result.append("DUMP DETAILS:\n");
1965 result.append("Last Screen On: ").append(ToString(mDeviceState_.screenState.lastOnTime)).append("\n");
1966 result.append("Last Screen Off: ").append(ToString(mDeviceState_.screenState.lastOffTime)).append("\n");
1967 result.append("Last SuspendDevice: ").append(ToString(mDeviceState_.lastSuspendDeviceTime)).append("\n");
1968 result.append("Last WakeupDevice: ").append(ToString(mDeviceState_.lastWakeupDeviceTime)).append("\n");
1969 result.append("Last Refresh: ").append(ToString(mDeviceState_.lastRefreshActivityTime)).append("\n");
1970
1971 result.append("DUMP EACH STATES:\n");
1972 for (auto it = controllerMap_.begin(); it != controllerMap_.end(); it++) {
1973 result.append("State: ")
1974 .append(PowerUtils::GetPowerStateString(it->second->GetState()))
1975 .append(" Reason: ")
1976 .append(PowerUtils::GetReasonTypeString(it->second->lastReason_).c_str())
1977 .append(" Time: ")
1978 .append(ToString(it->second->lastTime_))
1979 .append("\n")
1980 .append(" Failure: ")
1981 .append(PowerUtils::GetReasonTypeString(it->second->failTrigger_).c_str())
1982 .append(" Reason: ")
1983 .append(it->second->failReason_)
1984 .append(" From: ")
1985 .append(PowerUtils::GetPowerStateString(it->second->failFrom_))
1986 .append(" Time: ")
1987 .append(ToString(it->second->failTime_))
1988 .append("\n\n");
1989 }
1990 }
1991
1992 void PowerStateMachine::DumpInfo(std::string& result)
1993 {
1994 std::string reason = "UNKNOWN";
1995 std::string time = "UNKNOWN";
1996 auto it = controllerMap_.find(GetState());
1997 if (it != controllerMap_.end() && it->second != nullptr) {
1998 reason = ToString(static_cast<uint32_t>(it->second->lastReason_));
1999 time = ToString(it->second->lastTime_);
2000 }
2001 AppendDumpInfo(result, reason, time);
2002 }
2003
2004 bool PowerStateMachine::StateController::NeedNotify(PowerState currentState)
2005 {
2006 if (currentState == GetState()) {
2007 return false;
2008 }
2009 if (currentState == PowerState::DIM && GetState() == PowerState::AWAKE) {
2010 return false;
2011 }
2012 return true;
2013 }
2014
2015 TransitResult PowerStateMachine::StateController::TransitTo(StateChangeReason reason, bool ignoreLock)
2016 {
2017 POWER_HILOGD(FEATURE_POWER_STATE, "Start");
2018 std::shared_ptr<PowerStateMachine> owner = owner_.lock();
2019 if (owner == nullptr) {
2020 POWER_HILOGW(FEATURE_POWER_STATE, "owner is nullptr");
2021 return TransitResult::OTHER_ERR;
2022 }
2023 POWER_HILOGI(FEATURE_POWER_STATE,
2024 "[UL_POWER] Transit from %{public}s to %{public}s for %{public}s ignoreLock=%{public}d",
2025 PowerUtils::GetPowerStateString(owner->currentState_).c_str(),
2026 PowerUtils::GetPowerStateString(this->state_).c_str(),
2027 PowerUtils::GetReasonTypeString(reason).c_str(), ignoreLock);
2028 MatchState(owner->currentState_, owner->stateAction_->GetDisplayState());
2029 if (!CheckState()) {
2030 POWER_HILOGD(FEATURE_POWER_STATE, "Already in state: %{public}d", owner->currentState_);
2031 RecordFailure(owner->currentState_, reason, TransitResult::ALREADY_IN_STATE);
2032 return TransitResult::ALREADY_IN_STATE;
2033 }
2034
2035 if (reason != StateChangeReason::STATE_CHANGE_REASON_INIT && !owner->CanTransitTo(state_, reason)) {
2036 POWER_HILOGD(FEATURE_POWER_STATE, "Block Transit from %{public}s to %{public}s",
2037 PowerUtils::GetPowerStateString(owner->currentState_).c_str(),
2038 PowerUtils::GetPowerStateString(state_).c_str());
2039 RecordFailure(owner->currentState_, reason, TransitResult::FORBID_TRANSIT);
2040 return TransitResult::FORBID_TRANSIT;
2041 }
2042
2043 if (!ignoreLock && !owner->CheckRunningLock(GetState())) {
2044 POWER_HILOGD(FEATURE_POWER_STATE, "Running lock block");
2045 RecordFailure(owner->currentState_, reason, TransitResult::LOCKING);
2046 return TransitResult::LOCKING;
2047 }
2048 TransitResult ret = action_(reason);
2049 if (ret == TransitResult::SUCCESS) {
2050 bool needNotify = NeedNotify(owner->currentState_);
2051 lastReason_ = reason;
2052 lastTime_ = GetTickCount();
2053 owner->currentState_ = GetState();
2054 if (needNotify) {
2055 owner->NotifyPowerStateChanged(owner->currentState_, reason);
2056 }
2057 } else if (IsReallyFailed(reason)) {
2058 RecordFailure(owner->currentState_, reason, ret);
2059 }
2060
2061 POWER_HILOGD(FEATURE_POWER_STATE, "Finish, result: %{public}d", ret);
2062 return ret;
2063 }
2064
2065 bool PowerStateMachine::StateController::CheckState()
2066 {
2067 std::shared_ptr<PowerStateMachine> owner = owner_.lock();
2068 if (owner == nullptr) {
2069 POWER_HILOGW(FEATURE_POWER_STATE, "Owner is nullptr");
2070 return false;
2071 }
2072 auto state = GetState();
2073 if (state == PowerState::DIM || state == PowerState::AWAKE) {
2074 return true;
2075 }
2076 POWER_HILOGD(FEATURE_POWER_STATE, "state: %{public}u, currentState_: %{public}u", state, owner->currentState_);
2077 return state != owner->currentState_;
2078 }
2079
2080 void PowerStateMachine::StateController::CorrectState(
2081 PowerState& currentState, PowerState correctState, DisplayState state)
2082 {
2083 std::string msg = "[UL_POWER] Correct power state errors from ";
2084 msg.append(PowerUtils::GetPowerStateString(currentState))
2085 .append(" to ")
2086 .append(PowerUtils::GetPowerStateString(correctState))
2087 .append(" due to current display state is ")
2088 .append(PowerUtils::GetDisplayStateString(state));
2089 POWER_HILOGW(FEATURE_POWER_STATE, "%{public}s", msg.c_str());
2090 #ifdef HAS_HIVIEWDFX_HISYSEVENT_PART
2091 HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::POWER, "STATE_CORRECTION", HiviewDFX::HiSysEvent::EventType::FAULT,
2092 "ERROR_STATE", static_cast<uint32_t>(currentState), "CORRECTION_STATE", static_cast<uint32_t>(correctState),
2093 "DISPLAY_STATE", static_cast<uint32_t>(state), "MSG", msg);
2094 #endif
2095 currentState = correctState;
2096 }
2097
2098 void PowerStateMachine::StateController::MatchState(PowerState& currentState, DisplayState state)
2099 {
2100 if (GetState() == PowerState::SLEEP || currentState == PowerState::SLEEP || GetState() == PowerState::HIBERNATE ||
2101 currentState == PowerState::HIBERNATE || GetState() == PowerState::SHUTDOWN ||
2102 currentState == PowerState::SHUTDOWN) {
2103 return;
2104 }
2105
2106 // Keep the state of display consistent with the state of power
2107 switch (state) {
2108 case DisplayState::DISPLAY_OFF:
2109 if (currentState == PowerState::AWAKE || currentState == PowerState::FREEZE) {
2110 CorrectState(currentState, PowerState::INACTIVE, state);
2111 }
2112 break;
2113 case DisplayState::DISPLAY_DIM:
2114 if (currentState == PowerState::INACTIVE || currentState == PowerState::STAND_BY ||
2115 currentState == PowerState::DOZE) {
2116 CorrectState(currentState, PowerState::DIM, state);
2117 }
2118 break;
2119 case DisplayState::DISPLAY_ON:
2120 if (currentState == PowerState::INACTIVE || currentState == PowerState::STAND_BY ||
2121 currentState == PowerState::DOZE) {
2122 CorrectState(currentState, PowerState::AWAKE, state);
2123 }
2124 break;
2125 case DisplayState::DISPLAY_SUSPEND:
2126 case DisplayState::DISPLAY_UNKNOWN:
2127 default:
2128 break;
2129 }
2130 }
2131
2132 void PowerStateMachine::Reset()
2133 {
2134 ffrtTimer_.reset();
2135 }
2136
2137 std::string PowerStateMachine::GetTransitResultString(TransitResult result)
2138 {
2139 switch (result) {
2140 case TransitResult::ALREADY_IN_STATE:
2141 return "Already in the state";
2142 case TransitResult::LOCKING:
2143 return "Blocked by running lock";
2144 case TransitResult::HDI_ERR:
2145 return "Power HDI error";
2146 case TransitResult::DISPLAY_ON_ERR:
2147 return "SetDisplayState(ON) error";
2148 case TransitResult::DISPLAY_OFF_ERR:
2149 return "SetDisplayState(OFF) error";
2150 case TransitResult::FORBID_TRANSIT:
2151 return "Forbid transit";
2152 case TransitResult::OTHER_ERR:
2153 return "Other error";
2154 default:
2155 break;
2156 }
2157 return "Unknown error";
2158 }
2159
2160 void PowerStateMachine::StateController::RecordFailure(
2161 PowerState from, StateChangeReason trigger, TransitResult failReason)
2162 {
2163 failFrom_ = from;
2164 failTrigger_ = trigger;
2165 failTime_ = GetTickCount();
2166 failReason_ = GetTransitResultString(failReason);
2167 std::string message = "State Transit Failed from ";
2168 message.append(PowerUtils::GetPowerStateString(failFrom_))
2169 .append(" to ")
2170 .append(PowerUtils::GetPowerStateString(GetState()))
2171 .append(" by ")
2172 .append(PowerUtils::GetReasonTypeString(failTrigger_).c_str())
2173 .append(" Reason:")
2174 .append(failReason_)
2175 .append(" Time:")
2176 .append(ToString(failTime_))
2177 .append("\n");
2178 #ifdef HAS_HIVIEWDFX_HISYSEVENT_PART
2179 const int logLevel = 2;
2180 const std::string tag = "TAG_POWER";
2181 HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::POWER, "SCREEN", HiviewDFX::HiSysEvent::EventType::FAULT,
2182 "LOG_LEVEL", logLevel, "TAG", tag, "MESSAGE", message);
2183 POWER_HILOGI(FEATURE_POWER_STATE, "RecordFailure: %{public}s", message.c_str());
2184 #endif
2185 }
2186
2187 bool PowerStateMachine::StateController::IsReallyFailed(StateChangeReason reason)
2188 {
2189 if (reason == StateChangeReason::STATE_CHANGE_REASON_PRE_BRIGHT ||
2190 reason == StateChangeReason::STATE_CHANGE_REASON_PRE_BRIGHT_AUTH_FAIL_SCREEN_OFF) {
2191 return false;
2192 }
2193 return true;
2194 }
2195 } // namespace PowerMgr
2196 } // namespace OHOS
2197