1 /*
2 * Copyright (c) 2025 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 <chrono>
17 #include <map>
18 #include <set>
19
20 #include "hgm_core.h"
21 #include "hgm_multi_app_strategy.h"
22 #include "hgm_pointer_manager.h"
23 #include "hgm_task_handle_thread.h"
24
25
26 namespace OHOS::Rosen {
27 namespace {
28 constexpr int32_t UP_TIMEOUT_MS = 3000;
29 constexpr int32_t RS_IDLE_TIMEOUT_MS = 1200;
30 }
31
HgmPointerManager()32 HgmPointerManager::HgmPointerManager() : HgmStateMachine<PointerState, PointerEvent>(PointerState::POINTER_IDLE_STATE),
33 activeTimeoutTimer_("up_timeout_timer", std::chrono::milliseconds(UP_TIMEOUT_MS), nullptr, [this] () {
34 OnEvent(PointerEvent::POINTER_ACTIVE_TIMEOUT_EVENT);
35 }),
__anonf92fcfc80302() 36 rsIdleTimeoutTimer_("rs_idle_timeout_timer", std::chrono::milliseconds(RS_IDLE_TIMEOUT_MS), nullptr, [this] () {
37 OnEvent(PointerEvent::POINTER_RS_IDLE_TIMEOUT_EVENT);
38 })
39 {
__anonf92fcfc80402(PointerEvent event) 40 RegisterEventCallback(PointerEvent::POINTER_ACTIVE_EVENT, [this] (PointerEvent event) {
41 ChangeState(PointerState::POINTER_ACTIVE_STATE);
42 });
__anonf92fcfc80502(PointerEvent event) 43 RegisterEventCallback(PointerEvent::POINTER_ACTIVE_TIMEOUT_EVENT, [this] (PointerEvent event) {
44 ChangeState(PointerState::POINTER_IDLE_STATE);
45 });
__anonf92fcfc80602(PointerEvent event) 46 RegisterEventCallback(PointerEvent::POINTER_RS_IDLE_TIMEOUT_EVENT, [this] (PointerEvent event) {
47 ChangeState(PointerState::POINTER_IDLE_STATE);
48 });
49
50 // register state callback
51 RegisterEnterStateCallback(PointerState::POINTER_ACTIVE_STATE,
__anonf92fcfc80702(PointerState lastState, PointerState newState) 52 [this] (PointerState lastState, PointerState newState) {
53 activeTimeoutTimer_.Start();
54 rsIdleTimeoutTimer_.Start();
55 pointerInfo_ = { GetPkgName(), newState, OLED_120_HZ };
56 Vote();
57 });
58 RegisterEnterStateCallback(PointerState::POINTER_IDLE_STATE,
__anonf92fcfc80802(PointerState lastState, PointerState newState) 59 [this] (PointerState lastState, PointerState newState) {
60 pointerInfo_ = { GetPkgName(), newState };
61 activeTimeoutTimer_.Stop();
62 rsIdleTimeoutTimer_.Stop();
63 Vote();
64 });
65 }
66
Vote()67 void HgmPointerManager::Vote()
68 {
69 auto frameRateMgr = HgmCore::Instance().GetFrameRateMgr();
70 if (frameRateMgr == nullptr) {
71 return;
72 }
73 HgmMultiAppStrategy& multiAppStrategy = frameRateMgr->GetMultiAppStrategy();
74 std::vector<std::string> pkgs = multiAppStrategy.GetPackages();
75 if (pointerInfo_.pkgName == "" && !pkgs.empty()) {
76 auto [focusPkgName, pid, appType] = multiAppStrategy.AnalyzePkgParam(pkgs.front());
77 pointerInfo_.pkgName = focusPkgName;
78 HGM_LOGD("auto change pointer pkgName to focusPkgName:%{public}s", focusPkgName.c_str());
79 }
80 UpdateStrategyByPointer();
81 }
82
UpdateStrategyByPointer()83 void HgmPointerManager::UpdateStrategyByPointer()
84 {
85 auto frameRateMgr = HgmCore::Instance().GetFrameRateMgr();
86 if (frameRateMgr == nullptr) {
87 return;
88 }
89 HgmMultiAppStrategy& multiAppStrategy = frameRateMgr->GetMultiAppStrategy();
90
91 PolicyConfigData::StrategyConfig settingStrategy;
92 if (multiAppStrategy.GetFocusAppStrategyConfig(settingStrategy) == EXEC_SUCCESS &&
93 pointerInfo_.pointerState == PointerState::POINTER_ACTIVE_STATE &&
94 settingStrategy.pointerMode == PointerModeType::POINTER_DISENABLED) {
95 return;
96 }
97
98 if (pointerInfo_.pointerState == PointerState::POINTER_IDLE_STATE) {
99 frameRateMgr->HandleRefreshRateEvent(DEFAULT_PID, {"VOTER_POINTER", false});
100 return;
101 }
102
103 if (multiAppStrategy.GetFocusAppStrategyConfig(settingStrategy) != EXEC_SUCCESS ||
104 settingStrategy.pointerMode == PointerModeType::POINTER_DISENABLED) {
105 frameRateMgr->HandleRefreshRateEvent(DEFAULT_PID, {"VOTER_POINTER", false});
106 return;
107 }
108 frameRateMgr->HandleRefreshRateEvent(DEFAULT_PID,
109 {"VOTER_POINTER", true, settingStrategy.down, settingStrategy.down});
110 }
111
HandlePointerEvent(PointerEvent event,const std::string & pkgName)112 void HgmPointerManager::HandlePointerEvent(PointerEvent event, const std::string& pkgName)
113 {
114 pkgName_ = pkgName;
115 OnEvent(event);
116 }
117
HandleTimerReset()118 void HgmPointerManager::HandleTimerReset()
119 {
120 activeTimeoutTimer_.Reset();
121 rsIdleTimeoutTimer_.Reset();
122 }
123
HandleRsFrame()124 void HgmPointerManager::HandleRsFrame()
125 {
126 rsIdleTimeoutTimer_.Reset();
127 }
128
State2String(State state) const129 std::string HgmPointerManager::State2String(State state) const
130 {
131 static std::map<PointerState, std::string> stateStringMap = {
132 { PointerState::POINTER_ACTIVE_STATE, "PointerActive" },
133 { PointerState::POINTER_IDLE_STATE, "PointerIdle" },
134 };
135 if (auto iter = stateStringMap.find(state); iter != stateStringMap.end()) {
136 return iter->second;
137 }
138 return std::to_string(state);
139 }
140
CheckChangeStateValid(PointerState lastState,PointerState newState)141 bool HgmPointerManager::CheckChangeStateValid(PointerState lastState, PointerState newState)
142 {
143 static std::map<PointerState, std::set<PointerState>> stateChangeMap = {
144 { PointerState::POINTER_ACTIVE_STATE, { PointerState::POINTER_IDLE_STATE } },
145 { PointerState::POINTER_IDLE_STATE, { PointerState::POINTER_ACTIVE_STATE } },
146 };
147 if (auto iter = stateChangeMap.find(lastState); iter != stateChangeMap.end()) {
148 return iter->second.find(newState) != iter->second.end();
149 }
150 return false;
151 }
152 } // OHOS::Rosen