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