1 /*
2 * Copyright (c) 2021 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 <cinttypes>
19
20 #include <datetime_ex.h>
21 #include <file_ex.h>
22 #include <hisysevent.h>
23 #include <pubdef.h>
24 #include <sys/eventfd.h>
25 #include <unistd.h>
26
27 #include "powerms_event_handler.h"
28 #include "power_mgr_client.h"
29 #include "power_mgr_factory.h"
30 #include "power_mgr_service.h"
31
32 namespace OHOS {
33 namespace PowerMgr {
PowerStateMachine(const wptr<PowerMgrService> & pms)34 PowerStateMachine::PowerStateMachine(const wptr<PowerMgrService>& pms)
35 : pms_(pms), currentState_(PowerState::UNKNOWN)
36 {
37 POWER_HILOGI(MODULE_SERVICE, "PowerStateMachine_currentState: func is Start.");
38 // NOTICE Need get screen state when device startup,
39 // rightnow we set screen is on as default
40 mDeviceState_.screenState.lastOnTime = GetTickCount();
41 mDeviceState_.screenState.lastOffTime = 0;
42 mDeviceState_.lastWakeupEventTime = 0;
43 mDeviceState_.lastRefreshActivityTime = 0;
44 mDeviceState_.lastWakeupDeviceTime = 0;
45 mDeviceState_.lastSuspendDeviceTime = 0;
46
47 // init lock map which will block state transit
48 std::vector<RunningLockType> awakeBlocker {};
49 std::vector<RunningLockType> inactiveBlocker {
50 RunningLockType::RUNNINGLOCK_SCREEN,
51 RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL
52 };
53 std::vector<RunningLockType> sleepBlocker {
54 RunningLockType::RUNNINGLOCK_BACKGROUND
55 };
56 lockMap_.emplace(PowerState::AWAKE,
57 std::make_shared<std::vector<RunningLockType>>(awakeBlocker));
58 lockMap_.emplace(PowerState::INACTIVE,
59 std::make_shared<std::vector<RunningLockType>>(inactiveBlocker));
60 lockMap_.emplace(PowerState::SLEEP,
61 std::make_shared<std::vector<RunningLockType>>(sleepBlocker));
62
63 POWER_HILOGI(MODULE_SERVICE, "PowerStateMachine_currentState: func is End.");
64 }
65
~PowerStateMachine()66 PowerStateMachine::~PowerStateMachine() {}
67
Init()68 bool PowerStateMachine::Init()
69 {
70 POWER_HILOGI(MODULE_SERVICE, "PowerStateMachine:: Init start");
71
72 stateAction_ = PowerMgrFactory::GetDeviceStateAction();
73 std::function<void(uint32_t)> callback = std::bind(&PowerStateMachine::ActionCallback,
74 this, std::placeholders::_1);
75 stateAction_->RegisterCallback(callback);
76 InitStateMap();
77
78 if (powerStateCBDeathRecipient_ == nullptr) {
79 powerStateCBDeathRecipient_ = new PowerStateCallbackDeathRecipient();
80 }
81
82 if (!powerMgrMonitor_.Start()) {
83 POWER_HILOGE(MODULE_SERVICE, "Failed to start monitor");
84 return false;
85 }
86
87 if (IsScreenOn()) {
88 SetState(PowerState::AWAKE, StateChangeReason::STATE_CHANGE_REASON_INIT, true);
89 } else {
90 SetState(PowerState::INACTIVE, StateChangeReason::STATE_CHANGE_REASON_INIT, true);
91 }
92 POWER_HILOGI(MODULE_SERVICE, "PowerStateMachine:: Init success!");
93 return true;
94 }
95
EmplaceAwake()96 void PowerStateMachine::EmplaceAwake()
97 {
98 controllerMap_.emplace(PowerState::AWAKE,
99 std::make_shared<StateController>(PowerState::AWAKE, shared_from_this(),
100 [this](StateChangeReason reason) {
101 mDeviceState_.screenState.lastOnTime = GetTickCount();
102 uint32_t ret = this->stateAction_->SetDisplayState(DisplayState::DISPLAY_ON, reason);
103 // Display power service maybe not ready when init
104 if (ret != ActionResult::SUCCESS
105 && reason != StateChangeReason::STATE_CHANGE_REASON_INIT) {
106 POWER_HILOGE(MODULE_SERVICE, "Failed to go to AWAKE, Display Err");
107 return TransitResult::DISPLAY_ON_ERR;
108 }
109 if (reason != StateChangeReason::STATE_CHANGE_REASON_INIT) {
110 ResetInactiveTimer();
111 } else {
112 // If boot complete is not received, set this timer to ensure display off works
113 // This timer will be cancelled when boot complete received.
114 POWER_HILOGE(MODULE_SERVICE, "set timer to ensure display off");
115 InitInactiveTimer();
116 }
117 return TransitResult::SUCCESS;
118 })
119 );
120 }
EmplaceInactive()121 void PowerStateMachine::EmplaceInactive()
122 {
123 controllerMap_.emplace(PowerState::INACTIVE,
124 std::make_shared<StateController>(PowerState::INACTIVE, shared_from_this(),
125 [this](StateChangeReason reason) {
126 POWER_HILOGI(MODULE_SERVICE, "StateController_INACTIVE: func is Start.");
127 mDeviceState_.screenState.lastOffTime = GetTickCount();
128 DisplayState state = DisplayState::DISPLAY_OFF;
129 if (enableDisplaySuspend_) {
130 POWER_HILOGI(MODULE_SERVICE, "display suspend enabled");
131 state = DisplayState::DISPLAY_SUSPEND;
132 }
133 uint32_t ret = this->stateAction_->SetDisplayState(state, reason);
134 // Display power service maybe not ready when init
135 if (ret != ActionResult::SUCCESS
136 && reason != StateChangeReason::STATE_CHANGE_REASON_INIT) {
137 POWER_HILOGE(MODULE_SERVICE, "Failed to go to INACTIVE, Display Err");
138 return TransitResult::DISPLAY_OFF_ERR;
139 }
140 ResetSleepTimer();
141 return TransitResult::SUCCESS;
142 })
143 );
144 }
EmplaceSleep()145 void PowerStateMachine::EmplaceSleep()
146 {
147 controllerMap_.emplace(PowerState::SLEEP,
148 std::make_shared<StateController>(PowerState::SLEEP, shared_from_this(),
149 [this](StateChangeReason reason) {
150 DisplayState state = DisplayState::DISPLAY_OFF;
151 if (enableDisplaySuspend_) {
152 POWER_HILOGI(MODULE_SERVICE, "display suspend enabled");
153 state = DisplayState::DISPLAY_SUSPEND;
154 }
155 uint32_t ret = this->stateAction_->GoToSleep(onSuspend, onWakeup, false);
156 if (ret != ActionResult::SUCCESS) {
157 POWER_HILOGE(MODULE_SERVICE, "Failed to go to SLEEP, Sleep Err");
158 return TransitResult::HDI_ERR;
159 }
160 return TransitResult::SUCCESS;
161 })
162 );
163 }
InitStateMap()164 void PowerStateMachine::InitStateMap()
165 {
166 EmplaceAwake();
167 EmplaceInactive();
168 EmplaceSleep();
169 }
170
ActionCallback(uint32_t event)171 void PowerStateMachine::ActionCallback(uint32_t event)
172 {
173 auto pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
174 if (pms == nullptr) {
175 return;
176 }
177 pms->NotifyDisplayActionDone(event);
178 }
179
onSuspend()180 void PowerStateMachine::onSuspend()
181 {
182 POWER_HILOGI(MODULE_SERVICE, "System is suspending");
183 }
184
onWakeup()185 void PowerStateMachine::onWakeup()
186 {
187 POWER_HILOGI(MODULE_SERVICE, "System is awake");
188 auto pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
189 if (pms == nullptr) {
190 return;
191 }
192 auto handler = pms->GetHandler();
193 if (handler == nullptr) {
194 POWER_HILOGE(MODULE_SERVICE, "SetDelayTimer handler is null");
195 return;
196 }
197 handler->SendEvent(PowermsEventHandler::SYSTEM_WAKE_UP_MSG, 0, 0);
198 }
199
SuspendDeviceInner(pid_t pid,int64_t callTimeMs,SuspendDeviceType type,bool suspendImmed,bool ignoreScreenState)200 void PowerStateMachine::SuspendDeviceInner(pid_t pid,
201 int64_t callTimeMs,
202 SuspendDeviceType type,
203 bool suspendImmed,
204 bool ignoreScreenState)
205 {
206 POWER_HILOGI(MODULE_SERVICE, "PID: %{public}d Try to Suspend Device!!", pid);
207 if (type > SuspendDeviceType::SUSPEND_DEVICE_REASON_MAX) {
208 POWER_HILOGE(MODULE_SERVICE, "Invalid type: %{public}d", type);
209 return;
210 }
211 // Check the screen state
212 if (!ignoreScreenState) {
213 if (stateAction_ != nullptr) {
214 stateAction_->Suspend(callTimeMs, type, suspendImmed ?
215 SUSPEND_DEVICE_IMMEDIATELY : SUSPEND_DEVICE_NEED_DOZE);
216 }
217 mDeviceState_.lastSuspendDeviceTime = callTimeMs;
218 POWER_HILOGD(MODULE_SERVICE, "Suspend Device Call Binder Success!!");
219 } else {
220 POWER_HILOGE(MODULE_SERVICE, "Suspend Device Failed, Screen State is ignored!");
221 }
222
223 SetState(PowerState::INACTIVE, GetReasionBySuspendType(type), true);
224 POWER_HILOGI(MODULE_SERVICE, "SuspendDeviceInner: fun is End!");
225 }
226
WakeupDeviceInner(pid_t pid,int64_t callTimeMs,WakeupDeviceType type,const std::string & details,const std::string & pkgName)227 void PowerStateMachine::WakeupDeviceInner(pid_t pid,
228 int64_t callTimeMs,
229 WakeupDeviceType type,
230 const std::string& details,
231 const std::string& pkgName)
232 {
233 POWER_HILOGI(MODULE_SERVICE, "PID: %{public}d Try to Wakeup Device!!", pid);
234 if (type > WakeupDeviceType::WAKEUP_DEVICE_MAX) {
235 POWER_HILOGE(MODULE_SERVICE, "Invalid type: %{public}d", type);
236 return;
237 }
238 // Call legacy wakeup, Check the screen state
239 if (stateAction_ != nullptr) {
240 stateAction_->Wakeup(callTimeMs, type, details, pkgName);
241 }
242 mDeviceState_.lastWakeupDeviceTime = callTimeMs;
243
244 ResetInactiveTimer();
245 SetState(PowerState::AWAKE, GetReasonByWakeType(type), true);
246
247 POWER_HILOGD(MODULE_SERVICE, "Wakeup Device Call");
248 }
249
RefreshActivityInner(pid_t pid,int64_t callTimeMs,UserActivityType type,bool needChangeBacklight)250 void PowerStateMachine::RefreshActivityInner(pid_t pid,
251 int64_t callTimeMs,
252 UserActivityType type,
253 bool needChangeBacklight)
254 {
255 POWER_HILOGI(MODULE_SERVICE, "PID: %{public}d Start to RefreshActivity!!", pid);
256 if (type > UserActivityType::USER_ACTIVITY_TYPE_MAX) {
257 POWER_HILOGE(MODULE_SERVICE, "Invalid type: %{public}d", type);
258 return;
259 }
260 // The minimum refreshactivity interval is 100ms!!
261 int64_t now = GetTickCount();
262 if ((mDeviceState_.lastRefreshActivityTime + MIN_TIME_MS_BETWEEN_USERACTIVITIES) > now) {
263 POWER_HILOGE(MODULE_SERVICE, "RefreshActivity Failed, refresh too fast!");
264 return;
265 }
266 mDeviceState_.lastRefreshActivityTime = now;
267 // Check the screen state
268 if (IsScreenOn()) {
269 if (stateAction_ != nullptr) {
270 stateAction_->RefreshActivity(callTimeMs, type, needChangeBacklight ?
271 REFRESH_ACTIVITY_NEED_CHANGE_LIGHTS : REFRESH_ACTIVITY_NO_CHANGE_LIGHTS);
272 mDeviceState_.screenState.lastOnTime = GetTickCount();
273 stateAction_->SetDisplayState(DisplayState::DISPLAY_ON, GetReasonByUserActivity(type));
274 }
275 // reset timer
276 ResetInactiveTimer();
277 POWER_HILOGD(MODULE_SERVICE, "Refresh Activity Call Binder Success!!");
278 } else {
279 POWER_HILOGE(MODULE_SERVICE, "RefreshActivity Failed, Screen is Off!");
280 }
281 POWER_HILOGI(MODULE_SERVICE, "RefreshActivityInner: fun is End!");
282 }
283
ForceSuspendDeviceInner(pid_t pid,int64_t callTimeMs)284 bool PowerStateMachine::ForceSuspendDeviceInner(pid_t pid, int64_t callTimeMs)
285 {
286 POWER_HILOGI(MODULE_SERVICE, "ForceSuspendDeviceInner: fun is Start!");
287 if (stateAction_ != nullptr) {
288 currentState_ = PowerState::SLEEP;
289 stateAction_->GoToSleep(onSuspend, onWakeup, true);
290 }
291
292 POWER_HILOGI(MODULE_SERVICE, "ForceSuspendDeviceInner: fun is End!");
293 return true;
294 }
295
IsScreenOn()296 bool PowerStateMachine::IsScreenOn()
297 {
298 DisplayState state = stateAction_->GetDisplayState();
299 if (state == DisplayState::DISPLAY_ON ||
300 state == DisplayState::DISPLAY_DIM) {
301 POWER_HILOGI(MODULE_SERVICE, "Current Screen State: On!");
302 return true;
303 }
304 POWER_HILOGI(MODULE_SERVICE, "Current Screen State: Off!");
305 return false;
306 }
307
ReceiveScreenEvent(bool isScreenOn)308 void PowerStateMachine::ReceiveScreenEvent(bool isScreenOn)
309 {
310 POWER_HILOGI(MODULE_SERVICE, "ReceiveScreenEvent: fun is Start!");
311 std::lock_guard lock(mutex_);
312 auto prestate = mDeviceState_.screenState.state;
313 if (isScreenOn) {
314 mDeviceState_.screenState.lastOnTime = GetTickCount();
315 } else {
316 mDeviceState_.screenState.lastOffTime = GetTickCount();
317 }
318 if (prestate != mDeviceState_.screenState.state) {
319 NotifyPowerStateChanged(isScreenOn ? PowerState::AWAKE : PowerState::INACTIVE);
320 }
321 }
322
RegisterPowerStateCallback(const sptr<IPowerStateCallback> & callback)323 void PowerStateMachine::RegisterPowerStateCallback(const sptr<IPowerStateCallback>& callback)
324 {
325 POWER_HILOGI(MODULE_SERVICE, "RegisterPowerStateCallback: fun is Start!");
326 std::lock_guard lock(mutex_);
327 RETURN_IF(callback == nullptr);
328 auto object = callback->AsObject();
329 RETURN_IF(object == nullptr);
330 auto retIt = powerStateListeners_.insert(callback);
331 if (retIt.second) {
332 object->AddDeathRecipient(powerStateCBDeathRecipient_);
333 }
334 POWER_HILOGI(MODULE_SERVICE,
335 "%{public}s, object = %{public}p, callback = %{public}p, listeners.size = %{public}d,"
336 " insertOk = %{public}d",
337 __func__,
338 object.GetRefPtr(),
339 callback.GetRefPtr(),
340 static_cast<unsigned int>(powerStateListeners_.size()),
341 retIt.second);
342 }
343
UnRegisterPowerStateCallback(const sptr<IPowerStateCallback> & callback)344 void PowerStateMachine::UnRegisterPowerStateCallback(const sptr<IPowerStateCallback>& callback)
345 {
346 POWER_HILOGI(MODULE_SERVICE, "UnRegisterPowerStateCallback: fun is Start!");
347 std::lock_guard lock(mutex_);
348 RETURN_IF(callback == nullptr);
349 auto object = callback->AsObject();
350 RETURN_IF(object == nullptr);
351 size_t eraseNum = powerStateListeners_.erase(callback);
352 if (eraseNum != 0) {
353 object->RemoveDeathRecipient(powerStateCBDeathRecipient_);
354 }
355 POWER_HILOGI(MODULE_SERVICE,
356 "%{public}s, object = %{public}p, callback = %{public}p, listeners.size = %{public}d,"
357 " eraseNum = %zu",
358 __func__,
359 object.GetRefPtr(),
360 callback.GetRefPtr(),
361 static_cast<unsigned int>(powerStateListeners_.size()),
362 eraseNum);
363 }
364
GetReasonTypeString(StateChangeReason type)365 static const std::string GetReasonTypeString(StateChangeReason type)
366 {
367 switch (type) {
368 case StateChangeReason::STATE_CHANGE_REASON_INIT:
369 return std::string("INIT");
370 case StateChangeReason::STATE_CHANGE_REASON_TIMEOUT:
371 return std::string("TIMEOUT");
372 case StateChangeReason::STATE_CHANGE_REASON_RUNNING_LOCK:
373 return std::string("RUNNING_LOCK");
374 case StateChangeReason::STATE_CHANGE_REASON_BATTERY:
375 return std::string("BATTERY");
376 case StateChangeReason::STATE_CHANGE_REASON_THERMAL:
377 return std::string("THERMAL");
378 case StateChangeReason::STATE_CHANGE_REASON_WORK:
379 return std::string("WORK");
380 case StateChangeReason::STATE_CHANGE_REASON_SYSTEM:
381 return std::string("SYSTEM");
382 case StateChangeReason::STATE_CHANGE_REASON_APPLICATION:
383 return std::string("APPLICATION");
384 case StateChangeReason::STATE_CHANGE_REASON_SETTINGS:
385 return std::string("SETTINGS");
386 case StateChangeReason::STATE_CHANGE_REASON_HARD_KEY:
387 return std::string("HARD_KEY");
388 case StateChangeReason::STATE_CHANGE_REASON_TOUCH:
389 return std::string("TOUCH");
390 case StateChangeReason::STATE_CHANGE_REASON_CABLE:
391 return std::string("CABLE");
392 case StateChangeReason::STATE_CHANGE_REASON_SENSOR:
393 return std::string("SENSOR");
394 case StateChangeReason::STATE_CHANGE_REASON_LID:
395 return std::string("LID");
396 case StateChangeReason::STATE_CHANGE_REASON_CAMERA:
397 return std::string("CAMERA");
398 case StateChangeReason::STATE_CHANGE_REASON_ACCESSIBILITY:
399 return std::string("ACCESS");
400 case StateChangeReason::STATE_CHANGE_REASON_POWER_KEY:
401 return std::string("POWER_KEY");
402 case StateChangeReason::STATE_CHANGE_REASON_KEYBOARD:
403 return std::string("KEYBOARD");
404 case StateChangeReason::STATE_CHANGE_REASON_MOUSE:
405 return std::string("MOUSE");
406 case StateChangeReason::STATE_CHANGE_REASON_REMOTE:
407 return std::string("REMOTE");
408 case StateChangeReason::STATE_CHANGE_REASON_UNKNOWN:
409 return std::string("UNKNOWN");
410 default:
411 break;
412 }
413
414 return std::string("UNKNOWN");
415 }
416
GetPowerStateString(PowerState state)417 static const std::string GetPowerStateString(PowerState state)
418 {
419 switch (state) {
420 case PowerState::AWAKE:
421 return std::string("AWAKE");
422 case PowerState::INACTIVE:
423 return std::string("INACTIVE");
424 case PowerState::SLEEP:
425 return std::string("SLEEP");
426 case PowerState::UNKNOWN:
427 return std::string("UNKNOWN");
428 default:
429 break;
430 }
431
432 return std::string("UNKNOWN");
433 }
434
GetRunningLockTypeString(RunningLockType type)435 static const std::string GetRunningLockTypeString(RunningLockType type)
436 {
437 switch (type) {
438 case RunningLockType::RUNNINGLOCK_SCREEN:
439 return std::string("SCREEN");
440 case RunningLockType::RUNNINGLOCK_BACKGROUND:
441 return std::string("BACKGROUND");
442 case RunningLockType::RUNNINGLOCK_PROXIMITY_SCREEN_CONTROL:
443 return std::string("PROXIMITY_SCREEN_CONTROL");
444 case RunningLockType::RUNNINGLOCK_BUTT:
445 return std::string("BUTT");
446 default:
447 break;
448 }
449
450 return std::string("UNKNOWN");
451 }
452
EnableMock(IDeviceStateAction * mockAction)453 void PowerStateMachine::EnableMock(IDeviceStateAction* mockAction)
454 {
455 POWER_HILOGI(MODULE_SERVICE, "enableMock: fun is Start!");
456 std::lock_guard lock(mutex_);
457 // reset to awake state when mock and default off/sleep time
458 currentState_ = PowerState::AWAKE;
459 displayOffTime_ = DEFAULT_DISPLAY_OFF_TIME;
460 sleepTime_ = DEFAULT_SLEEP_TIME;
461 ResetInactiveTimer();
462
463 std::unique_ptr<IDeviceStateAction> mock(mockAction);
464 stateAction_.reset();
465 stateAction_ = std::move(mock);
466 }
467
NotifyPowerStateChanged(PowerState state)468 void PowerStateMachine::NotifyPowerStateChanged(PowerState state)
469 {
470 POWER_HILOGI(MODULE_SERVICE,
471 "%{public}s state = %u, listeners.size = %{public}d",
472 __func__,
473 static_cast<uint32_t>(state),
474 static_cast<unsigned int>(powerStateListeners_.size()));
475 std::lock_guard lock(mutex_);
476 int64_t now = GetTickCount();
477 // Send Notification event
478 SendEventToPowerMgrNotify(state, now);
479
480 // Call back all native function
481 for (auto& listener : powerStateListeners_) {
482 listener->OnPowerStateChanged(state);
483 }
484 }
485
SendEventToPowerMgrNotify(PowerState state,int64_t callTime)486 void PowerStateMachine::SendEventToPowerMgrNotify(PowerState state, int64_t callTime)
487 {
488 POWER_HILOGD(MODULE_SERVICE, "SendEventToPowerMgrNotify: fun is Start!");
489 auto pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
490 if (pms == nullptr) {
491 POWER_HILOGE(MODULE_SERVICE, "SendEventToPowerMgrNotify pms is Null, Fail!!");
492 return;
493 }
494 auto notify = pms->GetPowerMgrNotify();
495 if (notify == nullptr) {
496 POWER_HILOGE(MODULE_SERVICE, "SendEventToPowerMgrNotify notify is Null, Fail!!");
497 return;
498 }
499 if (state == PowerState::AWAKE) {
500 notify->PublishScreenOnEvents(callTime);
501 } else if (state == PowerState::INACTIVE) {
502 notify->PublishScreenOffEvents(callTime);
503 } else {
504 POWER_HILOGI(MODULE_SERVICE, "No need to publish event, state:%{public}d", state);
505 }
506 POWER_HILOGD(MODULE_SERVICE, "SendEventToPowerMgrNotify: fun is End!");
507 }
508
509 const std::string TASK_UNREG_POWER_STATE_CALLBACK = "PowerState_UnRegPowerStateCB";
510
OnRemoteDied(const wptr<IRemoteObject> & remote)511 void PowerStateMachine::PowerStateCallbackDeathRecipient::OnRemoteDied(
512 const wptr<IRemoteObject>& remote)
513 {
514 POWER_HILOGD(MODULE_SERVICE, "OnRemoteDied: fun is Start!");
515 if (remote == nullptr || remote.promote() == nullptr) {
516 return;
517 }
518 POWER_HILOGI(MODULE_SERVICE, "PowerStateMachine::%{public}s remote = %p", __func__,
519 remote.promote().GetRefPtr());
520 auto pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
521 if (pms == nullptr) {
522 return;
523 }
524 auto handler = pms->GetHandler();
525 if (handler == nullptr) {
526 return;
527 }
528 sptr<IPowerStateCallback> callback = iface_cast<IPowerStateCallback>(remote.promote());
529 std::function<void()> unRegFunc =
530 std::bind(&PowerMgrService::UnRegisterPowerStateCallback, pms, callback);
531 handler->PostTask(unRegFunc, TASK_UNREG_POWER_STATE_CALLBACK);
532 POWER_HILOGD(MODULE_SERVICE, "OnRemoteDied: fun is End!");
533 }
534
SetDelayTimer(int64_t delayTime,int32_t event)535 void PowerStateMachine::SetDelayTimer(int64_t delayTime, int32_t event)
536 {
537 POWER_HILOGD(MODULE_SERVICE, "SetDelayTimer: fun is Start!");
538 auto pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
539 if (pms == nullptr) {
540 return;
541 }
542 auto handler = pms->GetHandler();
543 if (handler == nullptr) {
544 POWER_HILOGE(MODULE_SERVICE, "SetDelayTimer handler is null");
545 return;
546 }
547 handler->SendEvent(event, 0, delayTime);
548 POWER_HILOGD(MODULE_SERVICE, "SetDelayTimer: fun is End!");
549 }
550
CancelDelayTimer(int32_t event)551 void PowerStateMachine::CancelDelayTimer(int32_t event)
552 {
553 POWER_HILOGD(MODULE_SERVICE, "CancelDelayTimer (%{public}d): fun is Start!", event);
554 auto pms = DelayedSpSingleton<PowerMgrService>::GetInstance();
555 if (pms == nullptr) {
556 return;
557 }
558 auto handler = pms->GetHandler();
559 if (handler == nullptr) {
560 POWER_HILOGE(MODULE_SERVICE, "CancelDelayTimer handler is null");
561 return;
562 }
563 handler->RemoveEvent(event);
564 POWER_HILOGD(MODULE_SERVICE, "CancelDelayTimer: fun is End!");
565 }
566
ResetInactiveTimer()567 void PowerStateMachine::ResetInactiveTimer()
568 {
569 POWER_HILOGD(MODULE_SERVICE, "ResetInactiveTimer: fun is Start!");
570 CancelDelayTimer(PowermsEventHandler::CHECK_USER_ACTIVITY_TIMEOUT_MSG);
571 CancelDelayTimer(PowermsEventHandler::CHECK_USER_ACTIVITY_OFF_TIMEOUT_MSG);
572 CancelDelayTimer(PowermsEventHandler::CHECK_USER_ACTIVITY_SLEEP_TIMEOUT_MSG);
573 if (this->GetDisplayOffTime() < 0) {
574 POWER_HILOGI(MODULE_SERVICE, "Display Auto OFF is disabled");
575 return;
576 }
577
578 if (this->CheckRunningLock(PowerState::INACTIVE)) {
579 const uint32_t TWO = 2;
580 const uint32_t THREE = 3;
581 this->SetDelayTimer(this->GetDisplayOffTime() * TWO / THREE,
582 PowermsEventHandler::CHECK_USER_ACTIVITY_TIMEOUT_MSG);
583 }
584 POWER_HILOGD(MODULE_SERVICE, "ResetInactiveTimer: fun is End!");
585 }
586
ResetSleepTimer()587 void PowerStateMachine::ResetSleepTimer()
588 {
589 POWER_HILOGD(MODULE_SERVICE, "ResetSleepTimer: fun is Start!");
590 CancelDelayTimer(PowermsEventHandler::CHECK_USER_ACTIVITY_TIMEOUT_MSG);
591 CancelDelayTimer(PowermsEventHandler::CHECK_USER_ACTIVITY_OFF_TIMEOUT_MSG);
592 CancelDelayTimer(PowermsEventHandler::CHECK_USER_ACTIVITY_SLEEP_TIMEOUT_MSG);
593 if (this->GetSleepTime() < 0) {
594 POWER_HILOGI(MODULE_SERVICE, "Auto Sleep is disabled");
595 return;
596 }
597
598 if (this->CheckRunningLock(PowerState::SLEEP)) {
599 this->SetDelayTimer(this->GetSleepTime(),
600 PowermsEventHandler::CHECK_USER_ACTIVITY_SLEEP_TIMEOUT_MSG);
601 }
602 POWER_HILOGD(MODULE_SERVICE, "ResetSleepTimer: fun is End!");
603 }
604
InitInactiveTimer()605 void PowerStateMachine::InitInactiveTimer()
606 {
607 POWER_HILOGD(MODULE_SERVICE, "InitInactiveTimer: fun is Start!");
608 CancelDelayTimer(PowermsEventHandler::CHECK_USER_ACTIVITY_TIMEOUT_MSG);
609 CancelDelayTimer(PowermsEventHandler::CHECK_USER_ACTIVITY_OFF_TIMEOUT_MSG);
610 CancelDelayTimer(PowermsEventHandler::CHECK_USER_ACTIVITY_SLEEP_TIMEOUT_MSG);
611 if (this->GetDisplayOffTime() < 0) {
612 POWER_HILOGI(MODULE_SERVICE, "Display Auto OFF is disabled");
613 return;
614 }
615
616 if (this->CheckRunningLock(PowerState::INACTIVE)) {
617 const uint32_t TWO = 2;
618 const uint32_t THREE = 3;
619 uint64_t offTime = this->GetDisplayOffTime() * TWO / THREE;
620 this->SetDelayTimer(this->initTime_ + offTime,
621 PowermsEventHandler::CHECK_USER_ACTIVITY_TIMEOUT_MSG);
622 }
623 POWER_HILOGD(MODULE_SERVICE, "ResetInactiveTimer: fun is End!");
624 }
625
HandleDelayTimer(int32_t event)626 void PowerStateMachine::HandleDelayTimer(int32_t event)
627 {
628 POWER_HILOGD(MODULE_SERVICE, "handle delay timer: (%{public}d)", event);
629 switch (event) {
630 case PowermsEventHandler::CHECK_USER_ACTIVITY_TIMEOUT_MSG:
631 HandleActivityTimeout();
632 break;
633 case PowermsEventHandler::CHECK_USER_ACTIVITY_OFF_TIMEOUT_MSG:
634 HandleActivityOffTimeout();
635 break;
636 case PowermsEventHandler::CHECK_USER_ACTIVITY_SLEEP_TIMEOUT_MSG:
637 HandleActivitySleepTimeout();
638 break;
639 case PowermsEventHandler::SYSTEM_WAKE_UP_MSG:
640 HandleSystemWakeup();
641 break;
642 default:
643 break;
644 }
645 POWER_HILOGD(MODULE_SERVICE, "ResetSleepTimer: fun is End!");
646 }
647
HandleActivityTimeout()648 void PowerStateMachine::HandleActivityTimeout()
649 {
650 POWER_HILOGI(MODULE_SERVICE, "HandleActivityTimeout (%{public}d)",
651 stateAction_->GetDisplayState());
652 DisplayState dispState = stateAction_->GetDisplayState();
653 const uint32_t THREE = 3;
654 if (!this->CheckRunningLock(PowerState::INACTIVE)) {
655 POWER_HILOGW(MODULE_SERVICE, "RunningLock is blocking to transit to INACTIVE");
656 return;
657 }
658 if (dispState == DisplayState::DISPLAY_ON) {
659 stateAction_->SetDisplayState(DisplayState::DISPLAY_DIM,
660 StateChangeReason::STATE_CHANGE_REASON_TIMEOUT);
661 if (this->GetDisplayOffTime() < 0) {
662 POWER_HILOGI(MODULE_SERVICE, "Display Auto OFF is disabled");
663 return;
664 } else {
665 SetDelayTimer(GetDisplayOffTime() / THREE,
666 PowermsEventHandler::CHECK_USER_ACTIVITY_OFF_TIMEOUT_MSG);
667 }
668 } else {
669 POWER_HILOGW(MODULE_SERVICE,
670 "HandleActivityTimeout when display: %{public}d", dispState);
671 HandleActivityOffTimeout();
672 }
673 POWER_HILOGI(MODULE_SERVICE, "HandleActivityTimeout: fun is End!");
674 }
675
HandleActivityOffTimeout()676 void PowerStateMachine::HandleActivityOffTimeout()
677 {
678 POWER_HILOGI(MODULE_SERVICE, "HandleActivityOffTimeout (%{public}d)",
679 stateAction_->GetDisplayState());
680 if (!this->CheckRunningLock(PowerState::INACTIVE)) {
681 POWER_HILOGW(MODULE_SERVICE, "RunningLock is blocking to transit to INACTIVE");
682 return;
683 }
684 DisplayState dispState = stateAction_->GetDisplayState();
685 // Also transit state when ON if system not support DIM
686 if (dispState == DisplayState::DISPLAY_ON
687 || dispState == DisplayState::DISPLAY_DIM) {
688 SetState(PowerState::INACTIVE, StateChangeReason::STATE_CHANGE_REASON_TIMEOUT);
689 } else {
690 POWER_HILOGW(MODULE_SERVICE,
691 "HandleActivityOffTimeout when display: %{public}d", dispState);
692 }
693 POWER_HILOGI(MODULE_SERVICE, "HandleActivityOffTimeOut: fun is End!");
694 }
695
HandleActivitySleepTimeout()696 void PowerStateMachine::HandleActivitySleepTimeout()
697 {
698 POWER_HILOGI(MODULE_SERVICE, "HandleActivitySleepTimeout (%{public}d)",
699 stateAction_->GetDisplayState());
700 if (!this->CheckRunningLock(PowerState::SLEEP)) {
701 POWER_HILOGW(MODULE_SERVICE, "RunningLock is blocking to transit to SLEEP");
702 return;
703 }
704 DisplayState dispState = stateAction_->GetDisplayState();
705 if (dispState == DisplayState::DISPLAY_OFF) {
706 SetState(PowerState::SLEEP, StateChangeReason::STATE_CHANGE_REASON_TIMEOUT);
707 } else {
708 POWER_HILOGW(MODULE_SERVICE,
709 "HandleActivitySleepTimeout when display: %{public}d", dispState);
710 }
711 POWER_HILOGI(MODULE_SERVICE, "HandleActivitySleepTimeout: fun is End!");
712 }
713
HandleSystemWakeup()714 void PowerStateMachine::HandleSystemWakeup()
715 {
716 POWER_HILOGI(MODULE_SERVICE, "HandleSystemWakeup (%{public}d)",
717 stateAction_->GetDisplayState());
718 if (IsScreenOn()) {
719 SetState(PowerState::AWAKE, StateChangeReason::STATE_CHANGE_REASON_SYSTEM, true);
720 } else {
721 SetState(PowerState::INACTIVE, StateChangeReason::STATE_CHANGE_REASON_SYSTEM, true);
722 }
723 }
724
CheckRunningLock(PowerState state)725 bool PowerStateMachine::CheckRunningLock(PowerState state)
726 {
727 POWER_HILOGI(MODULE_SERVICE, "CheckRunningLock: fun is Start!");
728 auto pms = pms_.promote();
729 if (pms == nullptr) {
730 POWER_HILOGE(MODULE_SERVICE, "CheckRunningLock: promote failed!");
731 return false;
732 }
733 auto runningLockMgr = pms->GetRunningLockMgr();
734 if (runningLockMgr == nullptr) {
735 POWER_HILOGE(MODULE_SERVICE, "CheckRunningLock: GetRunningLockMgr failed!");
736 return false;
737 }
738 auto iterator = lockMap_.find(state);
739 if (iterator == lockMap_.end()) {
740 POWER_HILOGE(MODULE_SERVICE, "CheckRunningLock: map find failed!");
741 return false;
742 }
743
744 std::shared_ptr<std::vector<RunningLockType>> pLock = iterator->second;
745 for (std::vector<RunningLockType>::const_iterator iter = pLock->begin();
746 iter != pLock->end(); ++iter) {
747 uint32_t count = runningLockMgr->GetValidRunningLockNum(*iter);
748 if (count > 0) {
749 POWER_HILOGE(MODULE_SERVICE,
750 "RunningLock %{public}s is locking (count=%{public}d), blocking %{public}s",
751 GetRunningLockTypeString(*iter).c_str(),
752 count,
753 GetPowerStateString(state).c_str());
754 return false;
755 }
756 }
757
758 POWER_HILOGI(MODULE_SERVICE, "No RunningLock block for state (%{public}d)", state);
759 return true;
760 }
761
SetDisplayOffTime(int64_t time)762 void PowerStateMachine::SetDisplayOffTime(int64_t time)
763 {
764 displayOffTime_ = time;
765 if (currentState_ == PowerState::AWAKE) {
766 ResetInactiveTimer();
767 }
768 }
769
SetSleepTime(int64_t time)770 void PowerStateMachine::SetSleepTime(int64_t time)
771 {
772 sleepTime_ = time;
773 if (currentState_ == PowerState::INACTIVE) {
774 ResetSleepTimer();
775 }
776 }
777
GetDisplayOffTime()778 int64_t PowerStateMachine::GetDisplayOffTime()
779 {
780 return displayOffTime_;
781 }
782
GetSleepTime()783 int64_t PowerStateMachine::GetSleepTime()
784 {
785 return sleepTime_;
786 }
787
SetState(PowerState state,StateChangeReason reason,bool force)788 bool PowerStateMachine::SetState(PowerState state, StateChangeReason reason, bool force)
789 {
790 POWER_HILOGI(MODULE_SERVICE,
791 "SetState state=%{public}d, reason=%{public}d, force=%{public}d",
792 state, reason, force);
793 auto iterator = controllerMap_.find(state);
794 if (iterator == controllerMap_.end()) {
795 return false;
796 }
797 std::shared_ptr<StateController> pController = iterator->second;
798 if (pController == nullptr) {
799 POWER_HILOGE(MODULE_SERVICE, "AWAKE State not initiated");
800 return false;
801 }
802 TransitResult ret = pController->TransitTo(reason, true);
803 POWER_HILOGI(MODULE_SERVICE, "SetState: fun is End!");
804 return (ret == TransitResult::SUCCESS || ret == TransitResult::ALREADY_IN_STATE);
805 }
806
SetDisplaySuspend(bool enable)807 void PowerStateMachine::SetDisplaySuspend(bool enable)
808 {
809 POWER_HILOGI(MODULE_SERVICE, "SetDisplaySuspend:%{public}d", enable);
810 enableDisplaySuspend_ = enable;
811 if (GetState() == PowerState::INACTIVE) {
812 POWER_HILOGI(MODULE_SERVICE, "Change display state");
813 if (enable) {
814 stateAction_->SetDisplayState(DisplayState::DISPLAY_SUSPEND,
815 StateChangeReason::STATE_CHANGE_REASON_APPLICATION);
816 } else {
817 stateAction_->SetDisplayState(DisplayState::DISPLAY_OFF,
818 StateChangeReason::STATE_CHANGE_REASON_APPLICATION);
819 }
820 }
821 }
822
GetReasonByUserActivity(UserActivityType type)823 StateChangeReason PowerStateMachine::GetReasonByUserActivity(UserActivityType type)
824 {
825 POWER_HILOGI(MODULE_SERVICE, "GetReasonByUserActivity Start:%{public}d", type);
826 StateChangeReason ret = StateChangeReason::STATE_CHANGE_REASON_UNKNOWN;
827 switch (type) {
828 case UserActivityType::USER_ACTIVITY_TYPE_BUTTON:
829 ret = StateChangeReason::STATE_CHANGE_REASON_HARD_KEY;
830 break;
831 case UserActivityType::USER_ACTIVITY_TYPE_TOUCH:
832 ret = StateChangeReason::STATE_CHANGE_REASON_TOUCH;
833 break;
834 case UserActivityType::USER_ACTIVITY_TYPE_ACCESSIBILITY:
835 ret = StateChangeReason::STATE_CHANGE_REASON_ACCESSIBILITY;
836 break;
837 case UserActivityType::USER_ACTIVITY_TYPE_SOFTWARE:
838 ret = StateChangeReason::STATE_CHANGE_REASON_APPLICATION;
839 break;
840 case UserActivityType::USER_ACTIVITY_TYPE_ATTENTION: // fail through
841 case UserActivityType::USER_ACTIVITY_TYPE_OTHER: // fail through
842 default:
843 break;
844 }
845 POWER_HILOGI(MODULE_SERVICE, "GetReasonByUserActivity: fun is End!");
846 return ret;
847 }
848
GetReasonByWakeType(WakeupDeviceType type)849 StateChangeReason PowerStateMachine::GetReasonByWakeType(WakeupDeviceType type)
850 {
851 POWER_HILOGI(MODULE_SERVICE, "GetReasonByWakeType Start:%{public}d", type);
852 StateChangeReason ret = StateChangeReason::STATE_CHANGE_REASON_UNKNOWN;
853 switch (type) {
854 case WakeupDeviceType::WAKEUP_DEVICE_POWER_BUTTON:
855 ret = StateChangeReason::STATE_CHANGE_REASON_POWER_KEY;
856 break;
857 case WakeupDeviceType::WAKEUP_DEVICE_WAKE_KEY:
858 ret = StateChangeReason::STATE_CHANGE_REASON_HARD_KEY;
859 break;
860 case WakeupDeviceType::WAKEUP_DEVICE_APPLICATION:
861 ret = StateChangeReason::STATE_CHANGE_REASON_APPLICATION;
862 break;
863 case WakeupDeviceType::WAKEUP_DEVICE_PLUGGED_IN: // fall through
864 case WakeupDeviceType::WAKEUP_DEVICE_HDMI:
865 ret = StateChangeReason::STATE_CHANGE_REASON_CABLE;
866 break;
867 case WakeupDeviceType::WAKEUP_DEVICE_GESTURE:
868 ret = StateChangeReason::STATE_CHANGE_REASON_TOUCH;
869 break;
870 case WakeupDeviceType::WAKEUP_DEVICE_CAMERA_LAUNCH:
871 ret = StateChangeReason::STATE_CHANGE_REASON_CAMERA;
872 break;
873 case WakeupDeviceType::WAKEUP_DEVICE_WAKE_MOTION:
874 ret = StateChangeReason::STATE_CHANGE_REASON_SENSOR;
875 break;
876 case WakeupDeviceType::WAKEUP_DEVICE_LID:
877 ret = StateChangeReason::STATE_CHANGE_REASON_LID;
878 break;
879 case WakeupDeviceType::WAKEUP_DEVICE_DOUBLE_CLICK:
880 ret = StateChangeReason::STATE_CHANGE_REASON_DOUBLE_CLICK;
881 break;
882 case WakeupDeviceType::WAKEUP_DEVICE_KEYBOARD:
883 ret = StateChangeReason::STATE_CHANGE_REASON_KEYBOARD;
884 break;
885 case WakeupDeviceType::WAKEUP_DEVICE_MOUSE:
886 ret = StateChangeReason::STATE_CHANGE_REASON_MOUSE;
887 break;
888 case WakeupDeviceType::WAKEUP_DEVICE_UNKNOWN: // fail through
889 default:
890 break;
891 }
892 POWER_HILOGI(MODULE_SERVICE, "GetReasonByWakeType: fun is End!");
893 return ret;
894 }
895
GetReasionBySuspendType(SuspendDeviceType type)896 StateChangeReason PowerStateMachine::GetReasionBySuspendType(SuspendDeviceType type)
897 {
898 POWER_HILOGI(MODULE_SERVICE, "GetReasionBySuspendType Start:%{public}d", type);
899 StateChangeReason ret = StateChangeReason::STATE_CHANGE_REASON_UNKNOWN;
900 switch (type) {
901 case SuspendDeviceType::SUSPEND_DEVICE_REASON_APPLICATION:
902 ret = StateChangeReason::STATE_CHANGE_REASON_APPLICATION;
903 break;
904 case SuspendDeviceType::SUSPEND_DEVICE_REASON_DEVICE_ADMIN:
905 ret = StateChangeReason::STATE_CHANGE_REASON_REMOTE;
906 break;
907 case SuspendDeviceType::SUSPEND_DEVICE_REASON_TIMEOUT:
908 ret = StateChangeReason::STATE_CHANGE_REASON_TIMEOUT;
909 break;
910 case SuspendDeviceType::SUSPEND_DEVICE_REASON_LID_SWITCH:
911 ret = StateChangeReason::STATE_CHANGE_REASON_LID;
912 break;
913 case SuspendDeviceType::SUSPEND_DEVICE_REASON_POWER_BUTTON: // fall through
914 case SuspendDeviceType::SUSPEND_DEVICE_REASON_SLEEP_BUTTON:
915 ret = StateChangeReason::STATE_CHANGE_REASON_HARD_KEY;
916 break;
917 case SuspendDeviceType::SUSPEND_DEVICE_REASON_HDMI:
918 ret = StateChangeReason::STATE_CHANGE_REASON_CABLE;
919 break;
920 case SuspendDeviceType::SUSPEND_DEVICE_REASON_ACCESSIBILITY:
921 ret = StateChangeReason::STATE_CHANGE_REASON_ACCESSIBILITY;
922 break;
923 case SuspendDeviceType::SUSPEND_DEVICE_REASON_FORCE_SUSPEND:
924 ret = StateChangeReason::STATE_CHANGE_REASON_SYSTEM;
925 break;
926 default:
927 break;
928 }
929 POWER_HILOGI(MODULE_SERVICE, "GetReasionBySuspendType: fun is End!");
930 return ret;
931 }
932
DumpInfo(std::string & result)933 void PowerStateMachine::DumpInfo(std::string& result)
934 {
935 result.append("POWER MANAGER DUMP (hidumper -PowerStateMachine):\n");
936 result.append("Current State: ")
937 .append(GetPowerStateString(GetState()))
938 .append(" Reasion: ")
939 .append(ToString(static_cast<uint32_t>(
940 controllerMap_.find(GetState())->second->lastReason_)))
941 .append(" Time: ")
942 .append(ToString(controllerMap_.find(GetState())->second->lastTime_))
943 .append("\n");
944
945 result.append("DUMP DETAILS:\n");
946 result.append("Last Screen On: ")
947 .append(ToString(mDeviceState_.screenState.lastOnTime))
948 .append("\n");
949 result.append("Last Screen Off: ")
950 .append(ToString(mDeviceState_.screenState.lastOffTime))
951 .append("\n");
952 result.append("Last SuspendDevice: ")
953 .append(ToString(mDeviceState_.lastSuspendDeviceTime))
954 .append("\n");
955 result.append("Last WakeupDevice: ")
956 .append(ToString(mDeviceState_.lastWakeupDeviceTime))
957 .append("\n");
958 result.append("Last Refresh: ")
959 .append(ToString(mDeviceState_.lastRefreshActivityTime))
960 .append("\n");
961
962 result.append("DUMP EACH STATES:\n");
963 for (auto it = controllerMap_.begin(); it != controllerMap_.end(); it++) {
964 result.append("State: ")
965 .append(GetPowerStateString(it->second->GetState()))
966 .append(" Reason:")
967 .append(GetReasonTypeString(it->second->lastReason_).c_str())
968 .append(" Time:")
969 .append(ToString(it->second->lastTime_))
970 .append("\n")
971 .append(" Failure: ")
972 .append(GetReasonTypeString(it->second->failTrigger_).c_str())
973 .append(" Reason:")
974 .append(it->second->failReasion_)
975 .append(" From:")
976 .append(GetPowerStateString(it->second->failFrom_))
977 .append(" Time:")
978 .append(ToString(it->second->failTime_))
979 .append("\n\n");
980 }
981 }
982
TransitTo(StateChangeReason reason,bool ignoreLock)983 TransitResult PowerStateMachine::StateController::TransitTo(
984 StateChangeReason reason,
985 bool ignoreLock)
986 {
987 POWER_HILOGI(MODULE_SERVICE, "TransitTo start");
988 std::shared_ptr<PowerStateMachine> owner = owner_.lock();
989 if (owner == nullptr) {
990 POWER_HILOGE(MODULE_SERVICE, "TransitTo: no owner");
991 return TransitResult::OTHER_ERR;
992 }
993 POWER_HILOGI(MODULE_SERVICE,
994 "Transit from %{public}s to %{public}s for %{public}s ignoreLock=%{public}d",
995 GetPowerStateString(owner->currentState_).c_str(),
996 GetPowerStateString(this->state_).c_str(),
997 GetReasonTypeString(reason).c_str(),
998 ignoreLock);
999 TransitResult ret = TransitResult::OTHER_ERR;
1000 if (!CheckState()) {
1001 POWER_HILOGE(MODULE_SERVICE, "TransitTo: already in %{public}d",
1002 owner->currentState_);
1003 RecordFailure(owner->currentState_, reason, TransitResult::ALREADY_IN_STATE);
1004 return TransitResult::ALREADY_IN_STATE;
1005 }
1006 if (!ignoreLock && !owner->CheckRunningLock(GetState())) {
1007 POWER_HILOGE(MODULE_SERVICE, "TransitTo: running lock block");
1008 RecordFailure(owner->currentState_, reason, TransitResult::LOCKING);
1009 return TransitResult::LOCKING;
1010 }
1011 ret = action_(reason);
1012 if (ret == TransitResult::SUCCESS) {
1013 lastReason_ = reason;
1014 lastTime_ = GetTickCount();
1015 owner->currentState_ = GetState();
1016 owner->NotifyPowerStateChanged(owner->currentState_);
1017 } else {
1018 RecordFailure(owner->currentState_, reason, ret);
1019 }
1020
1021 POWER_HILOGI(MODULE_SERVICE, "Transit End, result=%{public}d", ret);
1022 return ret;
1023 }
1024
CheckState()1025 bool PowerStateMachine::StateController::CheckState()
1026 {
1027 POWER_HILOGI(MODULE_SERVICE, "CheckState: fun is Start!");
1028 std::shared_ptr<PowerStateMachine> owner = owner_.lock();
1029 if (owner == nullptr) {
1030 return false;
1031 }
1032 POWER_HILOGI(MODULE_SERVICE, "CheckState: fun is End!");
1033 return !(GetState() == owner->currentState_);
1034 }
1035
RecordFailure(PowerState from,StateChangeReason trigger,TransitResult failReason)1036 void PowerStateMachine::StateController::RecordFailure(PowerState from,
1037 StateChangeReason trigger, TransitResult failReason)
1038 {
1039 failFrom_ = from;
1040 failTrigger_ = trigger;
1041 failTime_ = GetTickCount();
1042 switch (failReason) {
1043 case TransitResult::ALREADY_IN_STATE:
1044 failReasion_ = "Already in the state";
1045 break;
1046 case TransitResult::LOCKING:
1047 failReasion_ = "Blocked by running lock";
1048 break;
1049 case TransitResult::HDI_ERR:
1050 failReasion_ = "Power HDI error";
1051 break;
1052 case TransitResult::DISPLAY_ON_ERR:
1053 failReasion_ = "SetDisplayState(ON) error";
1054 break;
1055 case TransitResult::DISPLAY_OFF_ERR:
1056 failReasion_ = "SetDisplayState(OFF) error";
1057 break;
1058 case TransitResult::OTHER_ERR:
1059 default:
1060 failReasion_ = "Unknown Error";
1061 break;
1062 }
1063 std::string message = "State Transit Failed from ";
1064 message.append(GetPowerStateString(failFrom_))
1065 .append(" to ")
1066 .append(GetPowerStateString(GetState()))
1067 .append(" by ")
1068 .append(GetReasonTypeString(failTrigger_).c_str())
1069 .append(" Reason:")
1070 .append(failReasion_)
1071 .append(" Time:")
1072 .append(ToString(failTime_))
1073 .append("\n");
1074 const int logLevel = 2;
1075 const std::string tag = "TAG_POWER";
1076 HiviewDFX::HiSysEvent::Write(HiviewDFX::HiSysEvent::Domain::POWERMGR, "POWER_SCREEN",
1077 HiviewDFX::HiSysEvent::EventType::FAULT,
1078 "LOG_LEVEL",
1079 logLevel,
1080 "TAG",
1081 tag,
1082 "MESSAGE",
1083 message);
1084 POWER_HILOGI(MODULE_SERVICE, "RecordFailure: %{public}s", message.c_str());
1085 }
1086 } // namespace PowerMgr
1087 } // namespace OHOS
1088