From 0ab006a962c8369f7bf7d4beb3e95d71c06f6a1e Mon Sep 17 00:00:00 2001 From: wangyantian Date: Tue, 30 Jul 2024 11:53:40 +0800 Subject: [PATCH] fix: Power down the screen if pre bright auth isn't sent Signed-off-by: wangyantian --- services/native/include/power_state_machine.h | 23 +++-- services/native/src/power_state_machine.cpp | 96 +++++++++++++++++-- utils/ffrt/include/ffrt_utils.h | 1 + 3 files changed, 106 insertions(+), 14 deletions(-) diff --git a/services/native/include/power_state_machine.h b/services/native/include/power_state_machine.h index 49832ceb..3581f065 100644 --- a/services/native/include/power_state_machine.h +++ b/services/native/include/power_state_machine.h @@ -75,6 +75,7 @@ public: enum { CHECK_USER_ACTIVITY_TIMEOUT_MSG = 0, CHECK_USER_ACTIVITY_OFF_TIMEOUT_MSG, + CHECK_PRE_BRIGHT_AUTH_TIMEOUT_MSG, }; static void onSuspend(); @@ -86,8 +87,8 @@ public: pid_t pid, int64_t callTimeMs, SuspendDeviceType type, bool suspendImmed, bool ignoreScreenState = false); void WakeupDeviceInner( pid_t pid, int64_t callTimeMs, WakeupDeviceType type, const std::string& details, const std::string& pkgName); - void HandlePreBrightWakeUp( - int64_t callTimeMs, WakeupDeviceType type, const std::string& details, const std::string& pkgName); + void HandlePreBrightWakeUp(int64_t callTimeMs, WakeupDeviceType type, const std::string& details, + const std::string& pkgName, bool timeoutTriggered = false); void RefreshActivityInner(pid_t pid, int64_t callTimeMs, UserActivityType type, bool needChangeBacklight); bool CheckRefreshTime(); bool OverrideScreenOffTimeInner(int64_t timeout); @@ -184,7 +185,12 @@ public: bool IsSettingState(PowerState state); private: - static std::string GetTransitResultString(TransitResult result); + enum PreBrightState : uint32_t { + PRE_BRIGHT_UNSTART = 0, + PRE_BRIGHT_STARTED, + PRE_BRIGHT_FINISHED, + }; + class SettingStateFlag { public: SettingStateFlag(PowerState state, std::shared_ptr owner, StateChangeReason reason) @@ -255,7 +261,6 @@ private: } }; - std::shared_ptr ffrtTimer_ {nullptr}; class ScreenChangeCheck { public: ScreenChangeCheck(std::shared_ptr ffrtTimer, PowerState state, StateChangeReason reason); @@ -269,6 +274,7 @@ private: StateChangeReason reason_; }; + static std::string GetTransitResultString(TransitResult result); void UpdateSettingStateFlag(const PowerState state, const StateChangeReason reason); void RestoreSettingStateFlag(const PowerState state, const StateChangeReason reason); void InitStateMap(); @@ -293,6 +299,10 @@ private: std::shared_ptr GetStateController(PowerState state); void ResetScreenOffPreTimeForSwing(int64_t displayOffTime); void ShowCurrentScreenLocks(); + bool HandlePreBrightState(StateChangeReason reason); + bool IsPreBrightAuthReason(StateChangeReason reason); + bool IsPreBrightWakeUp(WakeupDeviceType type); + bool NeedShowScreenLocks(PowerState state); #ifdef POWER_MANAGER_POWER_ENABLE_S4 bool PrepareHibernate(bool clearMemory); #endif @@ -300,6 +310,7 @@ private: bool IsProximityClose(); #endif + std::shared_ptr ffrtTimer_ {nullptr}; const wptr pms_; PowerState currentState_; std::map>> lockMap_; @@ -312,13 +323,10 @@ private: std::set, classcomp> powerStateListeners_; std::shared_ptr stateAction_; -private: std::atomic displayOffTime_ {DEFAULT_DISPLAY_OFF_TIME}; int64_t sleepTime_ {DEFAULT_SLEEP_TIME}; bool enableDisplaySuspend_ {false}; bool isScreenOffTimeOverride_ {false}; - bool IsPreBrightWakeUp(WakeupDeviceType type); - bool NeedShowScreenLocks(PowerState state); std::unordered_map> forbidMap_; std::atomic switchOpen_ {true}; #ifdef POWER_MANAGER_POWER_ENABLE_S4 @@ -331,6 +339,7 @@ private: std::atomic settingStateFlag_ {-1}; std::atomic settingOnStateFlag_ {false}; std::atomic settingOffStateFlag_ {false}; + std::atomic preBrightState_ {PRE_BRIGHT_UNSTART}; }; } // namespace PowerMgr } // namespace OHOS diff --git a/services/native/src/power_state_machine.cpp b/services/native/src/power_state_machine.cpp index 8eb46168..c3eeed87 100644 --- a/services/native/src/power_state_machine.cpp +++ b/services/native/src/power_state_machine.cpp @@ -41,7 +41,8 @@ static int64_t g_beforeOverrideTime {-1}; constexpr int32_t DISPLAY_OFF = 0; constexpr int32_t DISPLAY_ON = 2; const std::string POWERMGR_STOPSERVICE = "persist.powermgr.stopservice"; -constexpr int32_t HIBERNATE_DELAY_MS = 5000; +constexpr uint32_t HIBERNATE_DELAY_MS = 5000; +constexpr uint32_t PRE_BRIGHT_AUTH_TIMER_DELAY_MS = 3000; } PowerStateMachine::PowerStateMachine(const wptr& pms) : pms_(pms), currentState_(PowerState::UNKNOWN) { @@ -188,7 +189,9 @@ void PowerStateMachine::EmplaceAwake() POWER_HILOGE(FEATURE_POWER_STATE, "Failed to go to AWAKE, display error, ret: %{public}u", ret); return TransitResult::DISPLAY_ON_ERR; } - ResetInactiveTimer(); + if (reason != StateChangeReason::STATE_CHANGE_REASON_PRE_BRIGHT) { + ResetInactiveTimer(); + } SystemSuspendController::GetInstance().DisallowAutoSleep(); SystemSuspendController::GetInstance().Wakeup(); return TransitResult::SUCCESS; @@ -395,6 +398,25 @@ WakeupDeviceType PowerStateMachine::ParseWakeupDeviceType(const std::string& det return parsedType; } +bool PowerStateMachine::IsPreBrightAuthReason(StateChangeReason reason) +{ + bool ret = false; + switch (reason) { + case StateChangeReason::STATE_CHANGE_REASON_PRE_BRIGHT_AUTH_SUCCESS: + ret = true; + break; + case StateChangeReason::STATE_CHANGE_REASON_PRE_BRIGHT_AUTH_FAIL_SCREEN_ON: + ret = true; + break; + case StateChangeReason::STATE_CHANGE_REASON_PRE_BRIGHT_AUTH_FAIL_SCREEN_OFF: + ret = true; + break; + default: + break; + } + return ret; +} + bool PowerStateMachine::IsPreBrightWakeUp(WakeupDeviceType type) { bool ret = false; @@ -417,11 +439,11 @@ bool PowerStateMachine::IsPreBrightWakeUp(WakeupDeviceType type) return ret; } -void PowerStateMachine::HandlePreBrightWakeUp( - int64_t callTimeMs, WakeupDeviceType type, const std::string& details, const std::string& pkgName) +void PowerStateMachine::HandlePreBrightWakeUp(int64_t callTimeMs, WakeupDeviceType type, const std::string& details, + const std::string& pkgName, bool timeoutTriggered) { POWER_HILOGD(FEATURE_WAKEUP, "This wakeup event is trigged by %{public}s.", details.c_str()); - + auto pms = DelayedSpSingleton::GetInstance(); auto suspendController = pms->GetSuspendController(); if (suspendController != nullptr) { @@ -434,11 +456,18 @@ void PowerStateMachine::HandlePreBrightWakeUp( } mDeviceState_.lastWakeupDeviceTime = callTimeMs; - SetState(PowerState::AWAKE, GetReasonByWakeType(type), true); + StateChangeReason reason = GetReasonByWakeType(type); + if (!timeoutTriggered && IsPreBrightAuthReason(reason)) { + POWER_HILOGD(FEATURE_WAKEUP, "Cancel pre-bright-auth timer, rason=%{public}s", + PowerUtils::GetReasonTypeString(reason).c_str()); + CancelDelayTimer(PowerStateMachine::CHECK_PRE_BRIGHT_AUTH_TIMEOUT_MSG); + } + SetState(PowerState::AWAKE, reason, true); switch (type) { - case WakeupDeviceType::WAKEUP_DEVICE_PRE_BRIGHT: + case WakeupDeviceType::WAKEUP_DEVICE_PRE_BRIGHT: { break; + } case WakeupDeviceType::WAKEUP_DEVICE_PRE_BRIGHT_AUTH_SUCCESS: // fall through case WakeupDeviceType::WAKEUP_DEVICE_PRE_BRIGHT_AUTH_FAIL_SCREEN_ON: if (suspendController != nullptr) { @@ -888,6 +917,13 @@ void PowerStateMachine::CancelDelayTimer(int32_t event) suspendController->CancelEvent(); break; } + case CHECK_PRE_BRIGHT_AUTH_TIMEOUT_MSG: { + if (!ffrtTimer_) { + return; + } + ffrtTimer_->CancelTimer(TIMER_ID_PRE_BRIGHT_AUTH); + break; + } default: { break; } @@ -1313,6 +1349,48 @@ void PowerStateMachine::RestoreSettingStateFlag(const PowerState state, const St settingOffStateFlag_ = false; } +bool PowerStateMachine::HandlePreBrightState(StateChangeReason reason) +{ + bool ret = false; + PowerStateMachine::PreBrightState curState = preBrightState_.load(); + if (reason == StateChangeReason::STATE_CHANGE_REASON_PRE_BRIGHT) { + if (ffrtTimer_ != nullptr) { + FFRTTask authFailTask = [this] { + POWER_HILOGI(FEATURE_WAKEUP, "Auth result of PRE_BRIGHT isn't received within %{public}u ms", + PRE_BRIGHT_AUTH_TIMER_DELAY_MS); + const std::string detail = "pre_bright_auth_fail_screen_off"; + const std::string pkgName = "pre_bright_auth_time"; + HandlePreBrightWakeUp(GetTickCount(), WakeupDeviceType::WAKEUP_DEVICE_PRE_BRIGHT_AUTH_FAIL_SCREEN_OFF, + detail, pkgName, true); + }; + if (curState == PowerStateMachine::PRE_BRIGHT_STARTED) { + POWER_HILOGD(FEATURE_WAKEUP, "Cancel pre-bright-auth timer, rason=%{public}s", + PowerUtils::GetReasonTypeString(reason).c_str()); + CancelDelayTimer(PowerStateMachine::CHECK_PRE_BRIGHT_AUTH_TIMEOUT_MSG); + } + POWER_HILOGD(FEATURE_POWER_STATE, "Start pre-bright-auth timer"); + ffrtTimer_->SetTimer(TIMER_ID_PRE_BRIGHT_AUTH, authFailTask, PRE_BRIGHT_AUTH_TIMER_DELAY_MS); + preBrightState_.store(PowerStateMachine::PRE_BRIGHT_STARTED, std::memory_order_relaxed); + ret = true; + } + } else if (IsPreBrightAuthReason(reason)) { + if (curState == PowerStateMachine::PRE_BRIGHT_STARTED) { + preBrightState_.store(PowerStateMachine::PRE_BRIGHT_FINISHED, std::memory_order_relaxed); + ret = true; + } + } else { + if (curState == PowerStateMachine::PRE_BRIGHT_STARTED) { + POWER_HILOGD(FEATURE_WAKEUP, "Cancel pre-bright-auth timer, rason=%{public}s", + PowerUtils::GetReasonTypeString(reason).c_str()); + CancelDelayTimer(PowerStateMachine::CHECK_PRE_BRIGHT_AUTH_TIMEOUT_MSG); + } + preBrightState_.store(PowerStateMachine::PRE_BRIGHT_UNSTART, std::memory_order_relaxed); + ret = true; + } + POWER_HILOGD(FEATURE_WAKEUP, "Pre bright state: %{public}u", static_cast(preBrightState_.load())); + return ret; +} + bool PowerStateMachine::SetState(PowerState state, StateChangeReason reason, bool force) { POWER_HILOGD(FEATURE_POWER_STATE, "state=%{public}s, reason=%{public}s, force=%{public}d", @@ -1325,6 +1403,10 @@ bool PowerStateMachine::SetState(PowerState state, StateChangeReason reason, boo ShowCurrentScreenLocks(); } + if (!HandlePreBrightState(reason)) { + return false; + } + std::shared_ptr pController = GetStateController(state); if (pController == nullptr) { POWER_HILOGW(FEATURE_POWER_STATE, "StateController is not init"); diff --git a/utils/ffrt/include/ffrt_utils.h b/utils/ffrt/include/ffrt_utils.h index a078305d..5d6f4626 100644 --- a/utils/ffrt/include/ffrt_utils.h +++ b/utils/ffrt/include/ffrt_utils.h @@ -129,6 +129,7 @@ enum FFRTTimerId { TIMER_ID_USER_ACTIVITY_OFF, TIMER_ID_USER_ACTIVITY_TIMEOUT, TIMER_ID_SCREEN_TIMEOUT_CHECK, + TIMER_ID_PRE_BRIGHT_AUTH, }; class FFRTMutexMap { -- Gitee