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