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