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