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