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