1 /*
2 * Copyright (c) 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 <gtest/gtest.h>
17 #include <test_header.h>
18 #include <climits>
19
20 #include "hgm_core.h"
21 #include "hgm_frame_rate_manager.h"
22 #include "hgm_config_callback_manager.h"
23 #include "hgm_idle_detector.h"
24 #include "pipeline/rs_surface_render_node.h"
25 #include "common/rs_common_def.h"
26
27 using namespace testing;
28 using namespace testing::ext;
29
30 namespace OHOS {
31 namespace Rosen {
32 namespace {
33 const std::string otherSurface = "Other_SF";
34 const std::string settingStrategyName = "99";
35 const int32_t HGM_REFRESHRATE_MODE_HIGH = 2;
36 constexpr uint64_t currTime = 200000000;
37 constexpr uint64_t lastTime = 100000000;
38 constexpr pid_t appPid = 0;
39 constexpr pid_t pid = 1;
40 constexpr uint32_t touchCount = 1;
41 constexpr uint32_t delay_60Ms = 60;
42 constexpr uint32_t delay_110Ms = 110;
43 constexpr int32_t OLED_72_HZ = 72;
44 constexpr int32_t OLED_50_HZ = 50;
45 constexpr int32_t OLED_80_HZ = 80;
46 ScreenSize screenSize = {720, 1080, 685, 1218}; // width, height, phyWidth, phyHeight
47 constexpr int32_t internalScreenId = 5;
48 constexpr int32_t externalScreenId = 0;
49 constexpr int32_t frameRateLinkerId1 = 1;
50 constexpr int32_t frameRateLinkerId2 = 2;
51 constexpr int32_t errorVelocity = -1;
52 constexpr int32_t strategy3 = 3;
53 const std::string testScene = "TestScene";
54 const GraphicIRect rectF {
55 .x = 0,
56 .y = 0,
57 .w = 2232,
58 .h = 1008,
59 };
60 const GraphicIRect rectM {
61 .x = 0,
62 .y = 1136,
63 .w = 2232,
64 .h = 2048,
65 };
66 const GraphicIRect rectG {
67 .x = 0,
68 .y = 0,
69 .w = 2232,
70 .h = 3184,
71 };
72 const GraphicIRect rectNeg {
73 .x = -1,
74 .y = -1,
75 .w = -1,
76 .h = -1,
77 };
78 const GraphicIRect rectMax {
79 .x = INT_MAX,
80 .y = INT_MAX,
81 .w = INT_MAX,
82 .h = INT_MAX,
83 };
84 }
85 class HgmFrameRateMgrTest : public testing::Test {
86 public:
87 static void SetUpTestCase();
88 static void TearDownTestCase();
89 void SetUp();
90 void TearDown();
91 void InitHgmFrameRateManager(HgmFrameRateManager &frameRateMgr);
92 };
93
SetUpTestCase()94 void HgmFrameRateMgrTest::SetUpTestCase() {}
TearDownTestCase()95 void HgmFrameRateMgrTest::TearDownTestCase() {}
SetUp()96 void HgmFrameRateMgrTest::SetUp() {}
TearDown()97 void HgmFrameRateMgrTest::TearDown() {}
98
99 class CustomHgmCallback : public IRemoteStub<RSIHgmConfigChangeCallback> {
100 public:
CustomHgmCallback()101 explicit CustomHgmCallback() {}
~CustomHgmCallback()102 ~CustomHgmCallback() override {};
103
OnHgmConfigChanged(std::shared_ptr<RSHgmConfigData> configData)104 void OnHgmConfigChanged(std::shared_ptr<RSHgmConfigData> configData) override {}
OnHgmRefreshRateModeChanged(int32_t refreshRateModeName)105 void OnHgmRefreshRateModeChanged(int32_t refreshRateModeName) override {}
OnHgmRefreshRateUpdate(int32_t refreshRateUpdate)106 void OnHgmRefreshRateUpdate(int32_t refreshRateUpdate) override {}
107 };
108
109 /**
110 * @tc.name: MergeRangeByPriority
111 * @tc.desc: Verify the result of MergeRangeByPriority function
112 * @tc.type: FUNC
113 * @tc.require:
114 */
115 HWTEST_F(HgmFrameRateMgrTest, MergeRangeByPriority, Function | SmallTest | Level1)
116 {
117 VoteRange voteRange0 = { OLED_40_HZ, OLED_120_HZ };
118 VoteRange voteRange1 = { OLED_30_HZ, OLED_40_HZ };
119 VoteRange voteRange2 = { OLED_60_HZ, OLED_90_HZ };
120 VoteRange voteRange3 = { OLED_120_HZ, OLED_144_HZ };
121 VoteRange voteRange4 = { OLED_30_HZ, OLED_144_HZ };
122 VoteRange voteRangeRes;
123
124 voteRangeRes = voteRange0;
125 HgmFrameRateManager::MergeRangeByPriority(voteRangeRes, voteRange1);
126 ASSERT_EQ(voteRangeRes.first, OledRefreshRate::OLED_40_HZ);
127 ASSERT_EQ(voteRangeRes.second, OledRefreshRate::OLED_40_HZ);
128
129 voteRangeRes = voteRange0;
130 HgmFrameRateManager::MergeRangeByPriority(voteRangeRes, voteRange2);
131 ASSERT_EQ(voteRangeRes.first, OledRefreshRate::OLED_60_HZ);
132 ASSERT_EQ(voteRangeRes.second, OledRefreshRate::OLED_90_HZ);
133
134 voteRangeRes = voteRange0;
135 HgmFrameRateManager::MergeRangeByPriority(voteRangeRes, voteRange3);
136 ASSERT_EQ(voteRangeRes.first, OledRefreshRate::OLED_120_HZ);
137 ASSERT_EQ(voteRangeRes.second, OledRefreshRate::OLED_120_HZ);
138
139 voteRangeRes = voteRange0;
140 HgmFrameRateManager::MergeRangeByPriority(voteRangeRes, voteRange4);
141 ASSERT_EQ(voteRangeRes.first, OledRefreshRate::OLED_40_HZ);
142 ASSERT_EQ(voteRangeRes.second, OledRefreshRate::OLED_120_HZ);
143 }
144
InitHgmFrameRateManager(HgmFrameRateManager & frameRateMgr)145 void HgmFrameRateMgrTest::InitHgmFrameRateManager(HgmFrameRateManager &frameRateMgr)
146 {
147 int64_t offset = 0;
148 auto vsyncGenerator = CreateVSyncGenerator();
149 sptr<Rosen::VSyncController> rsController = new VSyncController(vsyncGenerator, offset);
150 sptr<Rosen::VSyncController> appController = new VSyncController(vsyncGenerator, offset);
151 frameRateMgr.Init(nullptr, nullptr, nullptr);
152 frameRateMgr.Init(rsController, appController, vsyncGenerator);
153
154 auto strategyConfigs = frameRateMgr.multiAppStrategy_.GetStrategyConfigs();
155 auto screenSetting = frameRateMgr.multiAppStrategy_.GetScreenSetting();
156 frameRateMgr.HandleAppStrategyConfigEvent(DEFAULT_PID, "", {});
157 strategyConfigs[settingStrategyName] = { .min = OLED_NULL_HZ, .max = OLED_120_HZ, .down = OLED_144_HZ,
158 .dynamicMode = DynamicModeType::TOUCH_ENABLED, .pointerMode = PointerModeType::POINTER_ENABLED,
159 .isFactor = true };
160 screenSetting.strategy = settingStrategyName;
161 frameRateMgr.multiAppStrategy_.SetStrategyConfigs(strategyConfigs);
162 frameRateMgr.multiAppStrategy_.SetScreenSetting(screenSetting);
163 frameRateMgr.ReportHiSysEvent({ .extInfo = "ON" });
164 }
165
166 /**
167 * @tc.name: HandleGameNodeTest
168 * @tc.desc: Verify the result of HandleGameNodeTest function
169 * @tc.type: FUNC
170 * @tc.require:
171 */
172 HWTEST_F(HgmFrameRateMgrTest, HandleGameNodeTest, Function | SmallTest | Level1)
173 {
174 HgmFrameRateManager frameRateMgr;
175 frameRateMgr.curGameNodeName_ = "gameNode";
176 RSRenderNodeMap nodeMap;
177 RSSurfaceRenderNodeConfig config;
178
179 PART("HandleGameNodeTest") {
180 STEP("1. Test empty surfaceMap") {
181 frameRateMgr.HandleGameNode(nodeMap);
182 ASSERT_EQ(frameRateMgr.isGameNodeOnTree_.load(), false);
183 }
184 STEP("2. Test with a normal surfaceNode on tree") {
185 config.id = 1;
186 config.name = "normalNode";
187 auto normalNode = std::make_shared<RSSurfaceRenderNode>(config);
188 normalNode->SetIsOnTheTree(true);
189 nodeMap.RegisterRenderNode(normalNode);
190 frameRateMgr.HandleGameNode(nodeMap);
191 ASSERT_EQ(frameRateMgr.isGameNodeOnTree_.load(), false);
192 }
193 STEP("3. Test with a game surfaceNode not on tree") {
194 config.id = 2;
195 config.name = "gameNode";
196 auto gameNode1 = std::make_shared<RSSurfaceRenderNode>(config);
197 gameNode1->SetIsOnTheTree(false);
198 nodeMap.RegisterRenderNode(gameNode1);
199 frameRateMgr.HandleGameNode(nodeMap);
200 ASSERT_EQ(frameRateMgr.isGameNodeOnTree_.load(), false);
201 }
202 STEP("4. Test with a game surfaceNode on tree") {
203 config.id = 3;
204 config.name = "gameNode";
205 auto gameNode2 = std::make_shared<RSSurfaceRenderNode>(config);
206 gameNode2->SetIsOnTheTree(true);
207 nodeMap.RegisterRenderNode(gameNode2);
208 frameRateMgr.HandleGameNode(nodeMap);
209 ASSERT_EQ(frameRateMgr.isGameNodeOnTree_.load(), true);
210 }
211 }
212 sleep(1);
213 }
214
215 /**
216 * @tc.name: HgmUiFrameworkDirtyNodeTest
217 * @tc.desc: Verify the result of HgmUiFrameworkDirtyNodeTest function
218 * @tc.type: FUNC
219 * @tc.require:
220 */
221 HWTEST_F(HgmFrameRateMgrTest, HgmUiFrameworkDirtyNodeTest, Function | SmallTest | Level1)
222 {
223 HgmFrameRateManager frameRateMgr;
224 std::vector<std::weak_ptr<RSRenderNode>> uiFwkDirtyNodes;
225 PART("HgmUiFrameworkDirtyNodeTest") {
226 STEP("1. Test empty uiFwkDirtyNodes") {
227 ASSERT_EQ(uiFwkDirtyNodes.size(), 0);
228 frameRateMgr.UpdateUIFrameworkDirtyNodes(uiFwkDirtyNodes, 0);
229 frameRateMgr.voterTouchEffective_ = true;
230 {
231 std::shared_ptr<RSRenderNode> renderNode1 = std::make_shared<RSRenderNode>(0);
232 uiFwkDirtyNodes.emplace_back(renderNode1);
233 ASSERT_EQ(uiFwkDirtyNodes.size(), 1);
234 }
235 frameRateMgr.UpdateUIFrameworkDirtyNodes(uiFwkDirtyNodes, 0);
236 ASSERT_EQ(uiFwkDirtyNodes.size(), 0);
237 }
238 STEP("2. Test uiFwkDirtyNodes with a clean renderNode") {
239 std::shared_ptr<RSRenderNode> renderNode2 = std::make_shared<RSRenderNode>(0);
240 uiFwkDirtyNodes.emplace_back(renderNode2);
241 ASSERT_EQ(uiFwkDirtyNodes.size(), 1);
242 ASSERT_EQ(renderNode2->IsDirty(), false);
243 frameRateMgr.UpdateUIFrameworkDirtyNodes(uiFwkDirtyNodes, 0);
244 ASSERT_EQ(uiFwkDirtyNodes.size(), 1);
245 }
246 STEP("3. Test uiFwkDirtyNodes with a dirty renderNode") {
247 std::shared_ptr<RSRenderNode> renderNode3 = std::make_shared<RSRenderNode>(0);
248 uiFwkDirtyNodes.emplace_back(renderNode3);
249 ASSERT_EQ(uiFwkDirtyNodes.size(), 2);
250
251 frameRateMgr.UpdateUIFrameworkDirtyNodes(uiFwkDirtyNodes, 0);
252 ASSERT_EQ(uiFwkDirtyNodes.size(), 1);
253
254 renderNode3->SetDirty();
255 ASSERT_EQ(renderNode3->IsDirty(), true);
256 frameRateMgr.UpdateUIFrameworkDirtyNodes(uiFwkDirtyNodes, 0);
257 ASSERT_EQ(uiFwkDirtyNodes.size(), 1);
258 }
259 STEP("4. other branch") {
260 frameRateMgr.surfaceData_.emplace_back(std::tuple<std::string, pid_t, UIFWKType>());
261 frameRateMgr.UpdateUIFrameworkDirtyNodes(uiFwkDirtyNodes, 0);
262 frameRateMgr.voterGamesEffective_ = true;
263 frameRateMgr.UpdateUIFrameworkDirtyNodes(uiFwkDirtyNodes, 0);
264 frameRateMgr.voterTouchEffective_ = false;
265 frameRateMgr.UpdateUIFrameworkDirtyNodes(uiFwkDirtyNodes, 0);
266 }
267 }
268 sleep(1);
269 }
270
271 /**
272 * @tc.name: ProcessPendingRefreshRate
273 * @tc.desc: Verify the result of ProcessPendingRefreshRate function
274 * @tc.type: FUNC
275 * @tc.require:
276 */
277 HWTEST_F(HgmFrameRateMgrTest, ProcessPendingRefreshRate, Function | SmallTest | Level1)
278 {
279 HgmFrameRateManager frameRateMgr;
280 std::vector<std::weak_ptr<RSRenderNode>> uiFwkDirtyNodes;
281 bool disableSafeVote = true;
282 frameRateMgr.multiAppStrategy_.SetDisableSafeVoteValue(disableSafeVote);
283
284 frameRateMgr.UpdateUIFrameworkDirtyNodes(uiFwkDirtyNodes, 0);
285 FrameRateLinkerMap appFrameRateLinkers;
286 const std::map<uint64_t, int> vRatesMap;
287 frameRateMgr.UniProcessDataForLtpo(currTime, frameRateMgr.rsFrameRateLinker_,
288 appFrameRateLinkers, vRatesMap);
289 auto& hgmCore = HgmCore::Instance();
290 hgmCore.ltpoEnabled_ = false;
291 FrameRateLinkerId id;
292 frameRateMgr.rsFrameRateLinker_ = std::make_shared<RSRenderFrameRateLinker>(id);
293 frameRateMgr.UpdateSoftVSync(true);
294 int64_t vsyncid = 0;
295 uint32_t rsRate = 0;
296 bool isUiDvsyncOn = false;
297 frameRateMgr.pendingRefreshRate_ = nullptr;
298 frameRateMgr.ProcessPendingRefreshRate(currTime, vsyncid, rsRate, isUiDvsyncOn);
299 frameRateMgr.lastPendingConstraintRelativeTime_ = currTime;
300 frameRateMgr.ProcessPendingRefreshRate(currTime, vsyncid, rsRate, isUiDvsyncOn);
301 ASSERT_EQ(HgmCore::Instance().pendingConstraintRelativeTime_,
302 frameRateMgr.lastPendingConstraintRelativeTime_);
303 frameRateMgr.HandleThermalFrameRate(true);
304 }
305
306 /**
307 * @tc.name: HgmConfigCallbackManagerTest
308 * @tc.desc: Verify the result of HgmConfigCallbackManagerTest function
309 * @tc.type: FUNC
310 * @tc.require:
311 */
312 HWTEST_F(HgmFrameRateMgrTest, HgmConfigCallbackManagerTest, Function | SmallTest | Level1)
313 {
314 sptr<HgmConfigCallbackManager> hccMgr = HgmConfigCallbackManager::GetInstance();
315 PART("HgmConfigCallbackManagerTest") {
316 STEP("1. Callback is nullptr") {
317 sptr<CustomHgmCallback> cb1 = new CustomHgmCallback();
318 hccMgr->RegisterHgmRefreshRateModeChangeCallback(0, nullptr);
319 hccMgr->RegisterHgmRefreshRateModeChangeCallback(1, cb1);
320 }
321 STEP("2. Test SyncHgmConfigChangeCallback without callback") {
322 std::unordered_map<pid_t, sptr<RSIHgmConfigChangeCallback>> emptyCallback;
323 std::swap(hccMgr->animDynamicCfgCallbacks_, emptyCallback);
324 ASSERT_EQ(hccMgr->animDynamicCfgCallbacks_.empty(), true);
325 hccMgr->SyncHgmConfigChangeCallback();
326 }
327 STEP("3. Test SyncCallback function with callback") {
328 sptr<CustomHgmCallback> cb = new CustomHgmCallback();
329 hccMgr->animDynamicCfgCallbacks_[0] = cb;
330 hccMgr->refreshRateModeCallbacks_[0] = cb;
331 hccMgr->SyncHgmConfigChangeCallback();
332 hccMgr->SyncRefreshRateModeChangeCallback(0);
333 hccMgr->RegisterHgmConfigChangeCallback(0, nullptr);
334 hccMgr->RegisterHgmConfigChangeCallback(pid, cb);
335 hccMgr->RegisterHgmRefreshRateUpdateCallback(0, nullptr);
336 hccMgr->RegisterHgmRefreshRateUpdateCallback(pid, cb);
337 hccMgr->refreshRateUpdateCallbacks_.try_emplace(0, cb);
338 hccMgr->RegisterHgmRefreshRateUpdateCallback(0, nullptr);
339 hccMgr->RegisterHgmRefreshRateUpdateCallback(pid, cb);
340 hccMgr->SyncHgmConfigChangeCallback();
341 hccMgr->SyncRefreshRateModeChangeCallback(0);
342 hccMgr->refreshRateUpdateCallbacks_ = {
343 {0, nullptr},
344 };
345 hccMgr->SyncRefreshRateUpdateCallback(OLED_60_HZ);
346 ASSERT_EQ(hccMgr->animDynamicCfgCallbacks_.empty(), false);
347 hccMgr->UnRegisterHgmConfigChangeCallback(pid);
348 hccMgr->animDynamicCfgCallbacks_.try_emplace(0, cb);
349 hccMgr->SyncHgmConfigChangeCallback();
350 hccMgr->refreshRateUpdateCallbacks_.try_emplace(0, cb);
351 hccMgr->SyncRefreshRateUpdateCallback(OLED_60_HZ);
352 }
353 }
354 }
355
356 /**
357 * @tc.name: HgmSetPointerActiveFPS
358 * @tc.desc: Verify the result of HgmSetPointerActiveFPS function
359 * @tc.type: FUNC
360 * @tc.require:
361 */
362 HWTEST_F(HgmFrameRateMgrTest, HgmSetPointerActiveFPS, Function | SmallTest | Level1)
363 {
364 HgmFrameRateManager frameRateMgr;
365 constexpr uint32_t delay_1100Ms = 1100;
366 constexpr uint32_t delay_1300Ms = 1300;
367 InitHgmFrameRateManager(frameRateMgr);
368 frameRateMgr.HandleTouchEvent(appPid, TouchStatus::TOUCH_BUTTON_DOWN, touchCount);
369 std::this_thread::sleep_for(std::chrono::milliseconds(delay_110Ms));
370 ASSERT_EQ(frameRateMgr.pointerManager_.GetState(), PointerState::POINTER_ACTIVE_STATE);
371
372 frameRateMgr.HandleTouchEvent(appPid, TouchStatus::TOUCH_MOVE, touchCount);
373 std::this_thread::sleep_for(std::chrono::milliseconds(delay_110Ms));
374 ASSERT_EQ(frameRateMgr.pointerManager_.GetState(), PointerState::POINTER_ACTIVE_STATE);
375
376 frameRateMgr.HandleTouchEvent(appPid, TouchStatus::TOUCH_BUTTON_UP, touchCount);
377 std::this_thread::sleep_for(std::chrono::milliseconds(delay_110Ms));
378 ASSERT_EQ(frameRateMgr.pointerManager_.GetState(), PointerState::POINTER_ACTIVE_STATE);
379
380 frameRateMgr.HandleTouchEvent(appPid, TouchStatus::TOUCH_MOVE, touchCount);
381 std::this_thread::sleep_for(std::chrono::milliseconds(delay_1100Ms));
382 ASSERT_EQ(frameRateMgr.pointerManager_.GetState(), PointerState::POINTER_ACTIVE_STATE);
383
384 std::this_thread::sleep_for(std::chrono::milliseconds(delay_1300Ms));
385 ASSERT_EQ(frameRateMgr.pointerManager_.GetState(), PointerState::POINTER_IDLE_STATE);
386
387 frameRateMgr.pointerManager_.ChangeState(PointerState::POINTER_IDLE_STATE);
388 sleep(1); // wait for handler task finished
389 }
390
391 /**
392 * @tc.name: MultiThread001
393 * @tc.desc: Verify the result of MultiThread001 function
394 * @tc.type: FUNC
395 * @tc.require:
396 */
397 HWTEST_F(HgmFrameRateMgrTest, MultiThread001, Function | SmallTest | Level1)
398 {
399 int64_t offset = 0;
400 int32_t testThreadNum = 100;
401 int32_t touchCnt = 1;
402 std::string pkg0 = "com.pkg.other:0:-1";
403 std::string pkg1 = "com.ss.hm.ugc.aweme:1001:10067";
404 std::string pkg2 = "com.wedobest.fivechess.harm:1002:10110";
405
406 HgmFrameRateManager frameRateMgr;
407 auto vsyncGenerator = CreateVSyncGenerator();
408 sptr<Rosen::VSyncController> rsController = new VSyncController(vsyncGenerator, offset);
409 ASSERT_NE(rsController, nullptr);
410 sptr<Rosen::VSyncController> appController = new VSyncController(vsyncGenerator, offset);
411 ASSERT_NE(appController, nullptr);
412 frameRateMgr.Init(rsController, appController, vsyncGenerator);
__anon1896067b0202(bool idleTimerExpired, bool forceUpdate) 413 frameRateMgr.forceUpdateCallback_ = [](bool idleTimerExpired, bool forceUpdate) { return; };
414
415 ASSERT_NE(vsyncGenerator, nullptr);
416 ASSERT_NE(rsController, nullptr);
417 ASSERT_NE(appController, nullptr);
__anon1896067b0302() 418 HgmTaskHandleThread::Instance().PostTask([&]() {
419 for (int i = 0; i < testThreadNum; i++) {
420 // HandleLightFactorStatus
421 frameRateMgr.HandleLightFactorStatus(i, LightFactorStatus::NORMAL_LOW);
422 frameRateMgr.HandleLightFactorStatus(i, LightFactorStatus::NORMAL_HIGH);
423
424 // HandlePackageEvent
425 frameRateMgr.HandlePackageEvent(i, {pkg0});
426 ASSERT_NE(frameRateMgr.multiAppStrategy_.HandlePkgsEvent({pkg0}), EXEC_SUCCESS);
427 frameRateMgr.HandlePackageEvent(i, {pkg1});
428 ASSERT_NE(frameRateMgr.multiAppStrategy_.HandlePkgsEvent({pkg1}), EXEC_SUCCESS);
429 frameRateMgr.HandlePackageEvent(i, {pkg2});
430 ASSERT_NE(frameRateMgr.multiAppStrategy_.HandlePkgsEvent({pkg2}), EXEC_SUCCESS);
431 frameRateMgr.HandlePackageEvent(i, {pkg0, pkg1});
432 ASSERT_NE(frameRateMgr.multiAppStrategy_.HandlePkgsEvent({pkg0, pkg1}), EXEC_SUCCESS);
433
434 // HandleRefreshRateEvent
435 frameRateMgr.HandleRefreshRateEvent(i, {});
436
437 // HandleTouchEvent
438 frameRateMgr.HandleTouchEvent(i, TouchStatus::TOUCH_DOWN, touchCnt);
439 frameRateMgr.HandleTouchEvent(i, TouchStatus::TOUCH_UP, touchCnt);
440
441 // HandleRefreshRateMode
442 // param -1、0、1、2、3：refresh rate mode
443 frameRateMgr.HandleRefreshRateMode(-1);
444 frameRateMgr.HandleRefreshRateMode(0);
445 frameRateMgr.HandleRefreshRateMode(1);
446 frameRateMgr.HandleRefreshRateMode(2);
447 frameRateMgr.HandleRefreshRateMode(3);
448
449 // HandleScreenPowerStatus
450 frameRateMgr.HandleScreenPowerStatus(i, ScreenPowerStatus::POWER_STATUS_ON);
451 frameRateMgr.HandleScreenPowerStatus(i, ScreenPowerStatus::POWER_STATUS_OFF);
452
453 // HandleScreenRectFrameRate
454 frameRateMgr.HandleScreenRectFrameRate(i, rectF);
455 frameRateMgr.HandleScreenRectFrameRate(i, rectM);
456 frameRateMgr.HandleScreenRectFrameRate(i, rectG);
457 frameRateMgr.HandleScreenRectFrameRate(i, rectNeg);
458 frameRateMgr.HandleScreenRectFrameRate(i, rectMax);
459 }
460 });
461 sleep(2); // wait for handler task finished
462 }
463
464 /**
465 * @tc.name: UpdateGuaranteedPlanVoteTest
466 * @tc.desc: Verify the result of UpdateGuaranteedPlanVote
467 * @tc.type: FUNC
468 * @tc.require:
469 */
470 HWTEST_F(HgmFrameRateMgrTest, UpdateGuaranteedPlanVoteTest, Function | SmallTest | Level1)
471 {
472 std::unique_ptr<HgmFrameRateManager> mgr = std::make_unique<HgmFrameRateManager>();
473
474 mgr->idleDetector_.SetAppSupportedState(false);
475 mgr->UpdateGuaranteedPlanVote(currTime);
476
477 mgr->idleDetector_.SetAppSupportedState(true);
478 mgr->UpdateGuaranteedPlanVote(currTime);
479
480 mgr->HandleTouchEvent(appPid, TouchStatus::TOUCH_DOWN, touchCount);
481 mgr->HandleTouchEvent(appPid, TouchStatus::TOUCH_UP, touchCount);
482 std::this_thread::sleep_for(std::chrono::milliseconds(delay_110Ms));
483 mgr->UpdateGuaranteedPlanVote(currTime);
484
485 mgr->idleDetector_.bufferFpsMap_["AceAnimato"] = 90;
486 mgr->HandleTouchEvent(appPid, TouchStatus::TOUCH_DOWN, touchCount);
487 mgr->HandleTouchEvent(appPid, TouchStatus::TOUCH_UP, touchCount);
488 std::this_thread::sleep_for(std::chrono::milliseconds(delay_110Ms));
489 mgr->UpdateGuaranteedPlanVote(currTime);
490
491 mgr->idleDetector_.SetAceAnimatorIdleState(false);
492 mgr->HandleTouchEvent(appPid, TouchStatus::TOUCH_DOWN, touchCount);
493 mgr->HandleTouchEvent(appPid, TouchStatus::TOUCH_UP, touchCount);
494 std::this_thread::sleep_for(std::chrono::milliseconds(delay_110Ms));
495 mgr->UpdateGuaranteedPlanVote(currTime);
496 EXPECT_FALSE(mgr->idleDetector_.GetAceAnimatorIdleState());
497 }
498
499 /**
500 * @tc.name: CleanPidCallbackTest
501 * @tc.desc: Verify the result of CleanPidCallbackTest
502 * @tc.type: FUNC
503 * @tc.require:
504 */
505 HWTEST_F(HgmFrameRateMgrTest, CleanPidCallbackTest, Function | SmallTest | Level2)
506 {
507 std::unique_ptr<HgmFrameRateManager> mgr = std::make_unique<HgmFrameRateManager>();
508 int32_t defaultPid = 0;
509 int32_t gamePid = 10024;
510 uint32_t undefinedCallbackType = 0xff;
511 std::string defaultScreenStrategyId = "LTPO-DEFAULT";
512 std::string invalidScreenStrategyId = "DEFAULT-INVALID";
513 auto &hgm = HgmCore::Instance();
514
515 mgr->CleanVote(defaultPid);
516 mgr->cleanPidCallback_[gamePid].insert(CleanPidCallbackType::LIGHT_FACTOR);
517 mgr->cleanPidCallback_[gamePid].insert(CleanPidCallbackType::PACKAGE_EVENT);
518 mgr->cleanPidCallback_[gamePid].insert(CleanPidCallbackType::TOUCH_EVENT);
519 mgr->cleanPidCallback_[gamePid].insert(CleanPidCallbackType::GAMES);
520 mgr->cleanPidCallback_[gamePid].insert(static_cast<CleanPidCallbackType>(undefinedCallbackType));
521 mgr->CleanVote(gamePid);
522 mgr->pidRecord_.emplace(defaultPid);
523 mgr->CleanVote(gamePid);
524
525 ASSERT_EQ(mgr->sceneStack_.empty(), true);
526 mgr->sceneStack_.push_back(std::make_pair("sceneName", 0));
527 ASSERT_EQ(mgr->sceneStack_.empty(), false);
528
529 std::string savedScreenStrategyId = mgr->curScreenStrategyId_;
530 ASSERT_EQ(savedScreenStrategyId, defaultScreenStrategyId);
531 mgr->curScreenStrategyId_ = invalidScreenStrategyId;
532 mgr->UpdateVoteRule();
533 if (hgm.mPolicyConfigData_ == nullptr) {
534 return;
535 }
536 EXPECT_NE(hgm.mPolicyConfigData_, nullptr);
537 std::shared_ptr<PolicyConfigData> cachedPolicyConfigData = nullptr;
538 std::swap(hgm.mPolicyConfigData_, cachedPolicyConfigData);
539 EXPECT_EQ(hgm.mPolicyConfigData_, nullptr);
540 mgr->UpdateVoteRule();
541 mgr->curScreenStrategyId_ = savedScreenStrategyId;
542 std::swap(hgm.mPolicyConfigData_, cachedPolicyConfigData);
543 EXPECT_NE(hgm.mPolicyConfigData_, nullptr);
544 auto frameRateMgr = hgm.GetFrameRateMgr();
545 auto screenSetting = frameRateMgr->multiAppStrategy_.GetScreenSetting();
546 screenSetting.sceneList.insert(make_pair(testScene, PolicyConfigData::SceneConfig{"1", "1"}));
547 screenSetting.gameSceneList.insert(make_pair(testScene, "1"));
548 screenSetting.ancoSceneList.insert(make_pair(testScene, PolicyConfigData::SceneConfig{"1", "1"}));
549 frameRateMgr->multiAppStrategy_.SetScreenSetting(screenSetting);
550 EventInfo eventInfo2 = { .eventName = "VOTER_SCENE", .eventStatus = true, .description = testScene };
551 frameRateMgr->HandleRefreshRateEvent(0, eventInfo2);
552 frameRateMgr->UpdateVoteRule();
553 sleep(1);
554 }
555
556 /**
557 * @tc.name: HandleEventTest
558 * @tc.desc: Verify the result of HandleEventTest
559 * @tc.type: FUNC
560 * @tc.require:
561 */
562 HWTEST_F(HgmFrameRateMgrTest, HandleEventTest, Function | SmallTest | Level2)
563 {
564 std::string pkg0 = "com.pkg.other:0:-1";
565 std::string pkg1 = "com.pkg.other:1:-1";
566
567 std::unique_ptr<HgmFrameRateManager> mgr = std::make_unique<HgmFrameRateManager>();
568 auto &hgm = HgmCore::Instance();
569 mgr->DeliverRefreshRateVote({"VOTER_GAMES", 120, 90, 0}, true);
570
571 mgr->GetExpectedFrameRate(static_cast<RSPropertyUnit>(0xff), 100.f, 0, 0);
572 if (hgm.mPolicyConfigData_ == nullptr) {
573 return;
574 }
575 EXPECT_NE(hgm.mPolicyConfigData_, nullptr);
576 std::shared_ptr<PolicyConfigData> cachedPolicyConfigData = nullptr;
577 std::swap(hgm.mPolicyConfigData_, cachedPolicyConfigData);
578 EXPECT_EQ(hgm.mPolicyConfigData_, nullptr);
579 ASSERT_EQ(nullptr, hgm.GetPolicyConfigData());
580 mgr->GetPreferredFps("translate", 100.f, 0.f, 0.f);
581
582 EventInfo eventInfo = { .eventName = "VOTER_GAMES", .eventStatus = false,
583 .description = pkg0,
584 };
585 mgr->HandleRefreshRateEvent(0, eventInfo);
586 mgr->HandleGamesEvent(0, eventInfo);
587 eventInfo.eventStatus = true;
588 mgr->HandleGamesEvent(0, eventInfo);
589 eventInfo.description = pkg1;
590 mgr->HandleGamesEvent(0, eventInfo);
591 mgr->HandleGamesEvent(1, eventInfo);
592 mgr->HandleIdleEvent(true);
593 mgr->HandleIdleEvent(false);
594 auto screenSetting = mgr->multiAppStrategy_.GetScreenSetting();
595 screenSetting.sceneList.insert(make_pair(testScene, PolicyConfigData::SceneConfig{"1", "1"}));
596 screenSetting.gameSceneList.insert(make_pair(testScene, "1"));
597 screenSetting.ancoSceneList.insert(make_pair(testScene, PolicyConfigData::SceneConfig{"1", "1"}));
598 mgr->multiAppStrategy_.SetScreenSetting(screenSetting);
599 EventInfo eventInfo2 = { .eventName = "VOTER_SCENE", .eventStatus = true, .description = testScene };
600 mgr->HandleRefreshRateEvent(0, eventInfo2);
601 eventInfo2.eventStatus = false;
602 mgr->HandleRefreshRateEvent(0, eventInfo2);
603
604 std::swap(hgm.mPolicyConfigData_, cachedPolicyConfigData);
605 EXPECT_NE(hgm.mPolicyConfigData_, nullptr);
606 eventInfo2.eventName = "VOTER_VIDEO_CALL";
607 mgr->HandleRefreshRateEvent(0, eventInfo2);
608 eventInfo2.eventName = "VOTER_VIRTUALDISPLAY";
609 mgr->HandleRefreshRateEvent(0, eventInfo2);
610 eventInfo2.eventName = "VOTER_MULTISELFOWNEDSCREEN";
611 mgr->HandleRefreshRateEvent(0, eventInfo2);
612 }
613
614
615 /**
616 * @tc.name: GetDrawingFrameRateTest
617 * @tc.desc: Verify the result of GetDrawingFrameRateTest
618 * @tc.type: FUNC
619 * @tc.require:
620 */
621 HWTEST_F(HgmFrameRateMgrTest, GetDrawingFrameRateTest, Function | SmallTest | Level2)
622 {
623 std::unique_ptr<HgmFrameRateManager> mgr = std::make_unique<HgmFrameRateManager>();
624 uint32_t refreshRate_60 = 60;
625 uint32_t refreshRate_120 = 120;
626 FrameRateRange dynamic_120(0, 120, 120);
627 EXPECT_EQ(dynamic_120.IsDynamic(), true);
628 FrameRateRange static_120(120, 120, 120);
629 EXPECT_EQ(static_120.IsDynamic(), false);
630 auto &hgmCore = HgmCore::Instance();
631 HgmFrameRateManager frameRateMgr;
632 hgmCore.adaptiveSync_ = ADAPTIVE_SYNC_ENABLED;
633 frameRateMgr.isAdaptive_.store(true);
634 frameRateMgr.ProcessAdaptiveSync("VOTER_GAMES");
635 frameRateMgr.ProcessAdaptiveSync("VOTER_SCENE");
636 frameRateMgr.isAdaptive_.store(false);
637 frameRateMgr.ProcessAdaptiveSync("VOTER_GAMES");
638 EXPECT_EQ(mgr->GetDrawingFrameRate(refreshRate_60, dynamic_120), 60);
639 EXPECT_EQ(mgr->GetDrawingFrameRate(refreshRate_60, static_120), 60);
640 EXPECT_EQ(mgr->GetDrawingFrameRate(refreshRate_120, dynamic_120), 120);
641 EXPECT_EQ(mgr->GetDrawingFrameRate(refreshRate_120, static_120), 120);
642 }
643
644
645 /**
646 * @tc.name: ProcessRefreshRateVoteTest
647 * @tc.desc: Verify the result of ProcessRefreshRateVoteTest
648 * @tc.type: FUNC
649 * @tc.require:
650 */
651 HWTEST_F(HgmFrameRateMgrTest, ProcessRefreshRateVoteTest, Function | SmallTest | Level2)
652 {
653 HgmFrameRateManager frameRateMgr;
654 VoteInfo resultVoteInfo;
655 VoteRange voteRange = { OLED_MIN_HZ, OLED_MAX_HZ };
656 bool voterGamesEffective = false;
657 auto voterIter = std::find(frameRateMgr.voters_.begin(), frameRateMgr.voters_.end(), "VOTER_GAMES");
658 frameRateMgr.ProcessRefreshRateVote(voterIter, resultVoteInfo, voteRange, voterGamesEffective);
659 frameRateMgr.DeliverRefreshRateVote({"VOTER_GAMES", OLED_120_HZ, OLED_90_HZ, OLED_NULL_HZ}, true);
660 frameRateMgr.DeliverRefreshRateVote({"VOTER_THERMAL", OLED_120_HZ, OLED_90_HZ, OLED_NULL_HZ}, true);
661 frameRateMgr.DeliverRefreshRateVote({"VOTER_MULTISELFOWNEDSCREEN", OLED_120_HZ, OLED_90_HZ, OLED_NULL_HZ}, true);
662 auto screenSetting = frameRateMgr.multiAppStrategy_.GetScreenSetting();
663 screenSetting.sceneList.insert(make_pair(testScene, PolicyConfigData::SceneConfig{"1", "1"}));
664 screenSetting.gameSceneList.insert(make_pair(testScene, "1"));
665 screenSetting.ancoSceneList.insert(make_pair(testScene, PolicyConfigData::SceneConfig{"1", "1"}));
666 frameRateMgr.multiAppStrategy_.SetScreenSetting(screenSetting);
667 EventInfo eventInfo2 = { .eventName = "VOTER_SCENE", .eventStatus = true, .description = testScene };
668 frameRateMgr.HandleRefreshRateEvent(0, eventInfo2);
669 frameRateMgr.DeliverRefreshRateVote({"VOTER_ANCO", OLED_120_HZ, OLED_90_HZ, OLED_60_HZ}, true);
670 auto resVoteInfo = frameRateMgr.ProcessRefreshRateVote();
671 EXPECT_EQ(resVoteInfo.min, OLED_MIN_HZ);
672 frameRateMgr.ancoScenes_.emplace("VOTER_ANCO");
673 resVoteInfo = frameRateMgr.ProcessRefreshRateVote();
674 EXPECT_EQ(resVoteInfo.min, OLED_MIN_HZ);
675 }
676
677 /**
678 * @tc.name: ProcessRefreshRateVoteTest2
679 * @tc.desc: Verify the result of ProcessRefreshRateVote when idle 30 enabled
680 * @tc.type: FUNC
681 * @tc.require:
682 */
683 HWTEST_F(HgmFrameRateMgrTest, ProcessRefreshRateVoteTest2, Function | SmallTest | Level2)
684 {
685 HgmFrameRateManager frameRateMgr;
686 VoteInfo resultVoteInfo;
687 VoteRange voteRange = { OLED_MIN_HZ, OLED_MAX_HZ };
688 frameRateMgr.DeliverRefreshRateVote({"VOTER_PACKAGES", OLED_60_HZ, OLED_120_HZ, 0}, true);
689 frameRateMgr.DeliverRefreshRateVote({"VOTER_LTPO", OLED_120_HZ, OLED_120_HZ, 0}, true);
690 frameRateMgr.DeliverRefreshRateVote({"VOTER_IDLE", OLED_30_HZ, OLED_30_HZ, 0}, true);
691 auto resVoteInfo = frameRateMgr.ProcessRefreshRateVote();
692 EXPECT_EQ(resVoteInfo.min, OLED_120_HZ);
693 frameRateMgr.DeliverRefreshRateVote({"VOTER_LTPO", OLED_120_HZ, OLED_120_HZ, 0}, false);
694 frameRateMgr.DeliverRefreshRateVote({"VOTER_LTPO", OLED_60_HZ, OLED_60_HZ, 0}, true);
695 resVoteInfo = frameRateMgr.ProcessRefreshRateVote();
696 EXPECT_EQ(resVoteInfo.min, OLED_60_HZ);
697 EXPECT_EQ(resVoteInfo.max, OLED_60_HZ);
698 frameRateMgr.DeliverRefreshRateVote({"VOTER_LTPO", OLED_60_HZ, OLED_60_HZ, 0}, false);
699 resVoteInfo = frameRateMgr.ProcessRefreshRateVote();
700 EXPECT_EQ(resVoteInfo.min, OLED_60_HZ);
701 EXPECT_EQ(resVoteInfo.max, OLED_60_HZ);
702 frameRateMgr.DeliverRefreshRateVote({"VOTER_PACKAGES", OLED_60_HZ, OLED_120_HZ, 0}, false);
703 frameRateMgr.DeliverRefreshRateVote({"VOTER_PACKAGES", OLED_30_HZ, OLED_120_HZ, 0}, true);
704 resVoteInfo = frameRateMgr.ProcessRefreshRateVote();
705 EXPECT_EQ(resVoteInfo.max, OLED_30_HZ);
706 sleep(1); // wait for handler task finished
707 }
708
709 /**
710 * @tc.name: SetAceAnimatorVoteTest
711 * @tc.desc: Verify the result of SetAceAnimatorVoteTest
712 * @tc.type: FUNC
713 * @tc.require:
714 */
715 HWTEST_F(HgmFrameRateMgrTest, SetAceAnimatorVoteTest, Function | SmallTest | Level2)
716 {
717 HgmFrameRateManager frameRateMgr;
718 frameRateMgr.SetAceAnimatorVote(nullptr);
719 std::shared_ptr<RSRenderFrameRateLinker> linker = std::make_shared<RSRenderFrameRateLinker>();
720 ASSERT_NE(linker, nullptr);
721 frameRateMgr.SetAceAnimatorVote(linker);
722 linker->SetAnimatorExpectedFrameRate(OLED_60_HZ);
723 frameRateMgr.SetAceAnimatorVote(linker);
724 }
725
726 /**
727 * @tc.name: HgmSimpleTimerTest
728 * @tc.desc: Verify the result of HgmSimpleTimerTest
729 * @tc.type: FUNC
730 * @tc.require:
731 */
732 HWTEST_F(HgmFrameRateMgrTest, HgmSimpleTimerTest, Function | SmallTest | Level2)
733 {
734 auto timer = HgmSimpleTimer("HgmSimpleTimer", std::chrono::milliseconds(delay_60Ms), nullptr, nullptr);
735 ASSERT_NE(timer.handler_, nullptr);
736 ASSERT_EQ(timer.name_, "HgmSimpleTimer");
737 ASSERT_EQ(timer.interval_, std::chrono::milliseconds(delay_60Ms));
738 ASSERT_EQ(timer.startCallback_, nullptr);
739 ASSERT_EQ(timer.expiredCallback_, nullptr);
740 timer.Start();
741 timer.Reset();
742 timer.Stop();
743 sleep(1); // wait for timer stop
744 }
745
746 /**
747 * @tc.name: FrameRateReportTest
748 * @tc.desc: Verify the result of FrameRateReportTest
749 * @tc.type: FUNC
750 * @tc.require:
751 */
752 HWTEST_F(HgmFrameRateMgrTest, FrameRateReportTest, Function | SmallTest | Level2)
753 {
754 HgmFrameRateManager mgr;
755 mgr.FrameRateReport();
756 mgr.curRefreshRateMode_ = HGM_REFRESHRATE_MODE_HIGH;
757 mgr.FrameRateReport();
758 EXPECT_EQ(mgr.schedulePreferredFpsChange_, false);
759 mgr.schedulePreferredFps_ = OLED_60_HZ;
760 mgr.currRefreshRate_ = OLED_60_HZ;
761 mgr.FrameRateReport();
762 mgr.curRefreshRateMode_ = 0;
763 mgr.schedulePreferredFps_ = 0;
764 mgr.schedulePreferredFpsChange_ = true;
765 mgr.FrameRateReport();
766 EXPECT_EQ(mgr.schedulePreferredFpsChange_, false);
767 }
768
769 /**
770 * @tc.name: CollectFrameRateChange
771 * @tc.desc: Verify the result of CollectFrameRateChange
772 * @tc.type: FUNC
773 * @tc.require:
774 */
775 HWTEST_F(HgmFrameRateMgrTest, CollectFrameRateChange, Function | SmallTest | Level2)
776 {
777 HgmFrameRateManager mgr;
778 InitHgmFrameRateManager(mgr);
779 FrameRateRange finalRange = {OLED_60_HZ, OLED_120_HZ, OLED_60_HZ};
780 FrameRateRange appExpectedRange = {OLED_60_HZ, OLED_120_HZ, OLED_72_HZ};
781 std::shared_ptr<RSRenderFrameRateLinker> rsFrameRateLinker = std::make_shared<RSRenderFrameRateLinker>();
782 std::shared_ptr<RSRenderFrameRateLinker> appFrameRateLinker = std::make_shared<RSRenderFrameRateLinker>();
783 appFrameRateLinker->SetExpectedRange(appExpectedRange);
784
785 FrameRateLinkerMap appFrameRateLinkers = {
786 {frameRateLinkerId1, nullptr},
787 {frameRateLinkerId2, appFrameRateLinker}
788 };
789 EXPECT_EQ(mgr.CollectFrameRateChange(finalRange, rsFrameRateLinker, appFrameRateLinkers), false);
790 mgr.controller_ = nullptr;
791 EXPECT_EQ(mgr.CollectFrameRateChange(finalRange, rsFrameRateLinker, appFrameRateLinkers), false);
792 }
793
794 /**
795 * @tc.name: CollectVRateChange
796 * @tc.desc: Verify the result of CollectVRateChange
797 * @tc.type: FUNC
798 * @tc.require:
799 */
800 HWTEST_F(HgmFrameRateMgrTest, CollectVRateChange, Function | SmallTest | Level2)
801 {
802 HgmFrameRateManager mgr;
803 InitHgmFrameRateManager(mgr);
804 FrameRateRange finalRange = {OLED_60_HZ, OLED_120_HZ, OLED_60_HZ};
805 mgr.vRatesMap_ = {
806 {0, 0},
807 {1, 1},
808 {2, 2}
809 };
810 uint64_t linkerId = 2;
811 mgr.CollectVRateChange(linkerId, finalRange);
812 EXPECT_EQ(finalRange.min_, OLED_60_HZ);
813 EXPECT_EQ(finalRange.max_, OLED_120_HZ);
814 EXPECT_EQ(finalRange.preferred_, OLED_60_HZ);
815
816 linkerId = 0;
817 mgr.CollectVRateChange(linkerId, finalRange);
818 EXPECT_EQ(finalRange.min_, OLED_60_HZ);
819 EXPECT_EQ(finalRange.max_, OLED_120_HZ);
820 EXPECT_EQ(finalRange.preferred_, OLED_60_HZ);
821
822 linkerId = 1;
823 mgr.CollectVRateChange(linkerId, finalRange);
824 EXPECT_EQ(finalRange.min_, OLED_60_HZ);
825 EXPECT_EQ(finalRange.max_, OLED_120_HZ);
826 EXPECT_EQ(finalRange.preferred_, OLED_60_HZ);
827
828 linkerId = 2;
829 mgr.CollectVRateChange(linkerId, finalRange);
830 EXPECT_EQ(finalRange.min_, OLED_60_HZ);
831 EXPECT_EQ(finalRange.max_, OLED_120_HZ);
832 EXPECT_EQ(finalRange.preferred_, OLED_60_HZ);
833
834 finalRange.preferred_ = 0;
835 mgr.controllerRate_ = 0;
836 mgr.CollectVRateChange(linkerId, finalRange);
837 EXPECT_EQ(finalRange.min_, OLED_NULL_HZ);
838 EXPECT_EQ(finalRange.max_, OLED_144_HZ);
839 EXPECT_EQ(finalRange.preferred_, 1);
840
841 finalRange.preferred_ = 0;
842 mgr.controllerRate_ = 100;
843 mgr.CollectVRateChange(linkerId, finalRange);
844 EXPECT_EQ(finalRange.min_, OLED_NULL_HZ);
845 EXPECT_EQ(finalRange.max_, OLED_144_HZ);
846 EXPECT_EQ(finalRange.preferred_, 50);
847 }
848
849 /**
850 * @tc.name: HandleFrameRateChangeForLTPO
851 * @tc.desc: Verify the result of HandleFrameRateChangeForLTPO
852 * @tc.type: FUNC
853 * @tc.require:
854 */
855 HWTEST_F(HgmFrameRateMgrTest, HandleFrameRateChangeForLTPO, Function | SmallTest | Level2)
856 {
857 auto &hgmCore = HgmCore::Instance();
858 auto frameRateMgr = hgmCore.GetFrameRateMgr();
859 hgmCore.SetPendingScreenRefreshRate(OLED_30_HZ);
860 frameRateMgr->currRefreshRate_ = OLED_120_HZ;
861 hgmCore.lowRateToHighQuickSwitch_.store(false);
862 frameRateMgr->HandleFrameRateChangeForLTPO(0, false);
863 hgmCore.lowRateToHighQuickSwitch_.store(true);
864 frameRateMgr->HandleFrameRateChangeForLTPO(0, false);
865 frameRateMgr->forceUpdateCallback_ = nullptr;
866 frameRateMgr->HandleFrameRateChangeForLTPO(0, false);
__anon1896067b0402(bool idleTimerExpired, bool forceUpdate) 867 frameRateMgr->forceUpdateCallback_ = [](bool idleTimerExpired, bool forceUpdate) { return; };
868 frameRateMgr->HandleFrameRateChangeForLTPO(0, false);
869 EXPECT_EQ(frameRateMgr->GetPreferredFps("translate", errorVelocity, 0, 0), 0);
870 hgmCore.lowRateToHighQuickSwitch_.store(true);
871 VSyncController* rsController;
872 VSyncController* appController;
873 VSyncGenerator* vsyncGenerator;
874 frameRateMgr->controller_ = std::make_shared<HgmVSyncGeneratorController>(rsController,
875 appController, vsyncGenerator);
876 frameRateMgr->HandleFrameRateChangeForLTPO(0, false);
877 }
878
879 /**
880 * @tc.name: GetLowBrightVec
881 * @tc.desc: Verify the result of GetLowBrightVec
882 * @tc.type: FUNC
883 * @tc.require:
884 */
885 HWTEST_F(HgmFrameRateMgrTest, GetLowBrightVec, Function | SmallTest | Level2)
886 {
887 HgmFrameRateManager mgr;
888 std::shared_ptr<PolicyConfigData> configData = std::make_shared<PolicyConfigData>();
889
890 std::vector<std::string> screenConfigs = {"LTPO-DEFAULT", "LTPO-internal", "LTPO-external"};
891 for (const auto& screenConfig : screenConfigs) {
892 auto iter = configData->supportedModeConfigs_.find(screenConfig);
893 if (iter == configData-> supportedModeConfigs_.end()) {
894 continue;
895 }
896
897 auto& supportedModeConfig = iter->second;
898 auto vec = supportedModeConfig.find("LowBright");
899
900 if (vec == supportedModeConfig.end()) {
901 continue;
902 }
903
904 supportedModeConfig["LowBright"].clear();
905 mgr.GetLowBrightVec(configData);
906 ASSERT_EQ(mgr.isAmbientEffect_, false);
907 ASSERT_TRUE(mgr.lowBrightVec_.empty());
908
909 std::vector<uint32_t> expectedLowBrightVec = {30, 60, 90};
910 supportedModeConfig["LowBright"] = expectedLowBrightVec;
911 mgr.GetLowBrightVec(configData);
912 ASSERT_EQ(mgr.isAmbientEffect_, true);
913 ASSERT_EQ(mgr.lowBrightVec_, expectedLowBrightVec);
914 }
915 }
916
917 /**
918 * @tc.name: GetStylusVec
919 * @tc.desc: Verify the result of GetStylusVec
920 * @tc.type: FUNC
921 * @tc.require:
922 */
923 HWTEST_F(HgmFrameRateMgrTest, GetStylusVec, Function | SmallTest | Level2)
924 {
925 HgmFrameRateManager mgr;
926 std::shared_ptr<PolicyConfigData> configData = std::make_shared<PolicyConfigData>();
927
928 std::vector<std::string> screenConfigs = {"LTPO-DEFAULT", "LTPS-DEFAULT"};
929 for (const auto& screenConfig : screenConfigs) {
930 auto iter = configData->supportedModeConfigs_.find(screenConfig);
931 if (iter == configData-> supportedModeConfigs_.end()) {
932 continue;
933 }
934
935 auto& supportedModeConfig = iter->second;
936 auto it = supportedModeConfig.find("StylusPen");
937 if (it == supportedModeConfig.end()) {
938 continue;
939 }
940
941 supportedModeConfig["StylusPen"].clear();
942 mgr.GetStylusVec(configData);
943 ASSERT_TRUE(mgr.stylusVec_.empty());
944
945 std::vector<uint32_t> expectedVec = {OLED_60_HZ, OLED_120_HZ};
946 supportedModeConfig["StylusPen"] = expectedVec;
947 mgr.GetStylusVec(configData);
948 ASSERT_EQ(mgr.stylusVec_, expectedVec);
949 }
950 }
951
952 /**
953 * @tc.name: GetDrawingFrameRate
954 * @tc.desc: Verify the result of GetDrawingFrameRate
955 * @tc.type: FUNC
956 * @tc.require:
957 */
958 HWTEST_F(HgmFrameRateMgrTest, GetDrawingFrameRate, Function | SmallTest | Level2)
959 {
960 std::vector<std::pair<std::pair<uint32_t, FrameRateRange>, uint32_t>> inputAndOutput = {
961 {{0, {0, 120, 60}}, 0},
962 {{60, {0, 120, 0}}, 0},
963 {{60, {0, 90, 120}}, 60},
964 {{60, {0, 120, 120}}, 60},
965 {{90, {0, 120, 30}}, 30},
966 {{80, {0, 120, 30}}, 40},
967 {{70, {0, 120, 30}}, 35},
968 {{60, {0, 120, 30}}, 30},
969 {{50, {0, 120, 30}}, 50}
970 };
971
972 for (const auto& [input, output] : inputAndOutput) {
973 EXPECT_EQ(HgmFrameRateManager::GetDrawingFrameRate(input.first, input.second), output);
974 }
975 }
976
977 /**
978 * @tc.name: HandleScreenPowerStatus
979 * @tc.desc: Verify the result of HandleScreenPowerStatus
980 * @tc.type: FUNC
981 * @tc.require:
982 */
983 HWTEST_F(HgmFrameRateMgrTest, HandleScreenPowerStatus, Function | SmallTest | Level1)
984 {
985 ScreenId extraScreenId = 1;
986 auto &hgmCore = HgmCore::Instance();
987 auto frameRateMgr = hgmCore.GetFrameRateMgr();
988 auto configData = hgmCore.GetPolicyConfigData();
989 if (configData == nullptr || frameRateMgr == nullptr) {
990 return;
991 }
992 // init
993 configData->screenStrategyConfigs_["screen0_LTPS"] = "LTPS-DEFAULT";
994 configData->screenStrategyConfigs_["screen0_LTPO"] = "LTPO-DEFAULT";
995 configData->screenStrategyConfigs_["screen5_LTPS"] = "LTPS-DEFAULT";
996 configData->screenStrategyConfigs_["screen5_LTPO"] = "LTPO-DEFAULT";
997 EXPECT_EQ(hgmCore.AddScreen(externalScreenId, 0, screenSize), EXEC_SUCCESS);
998 EXPECT_EQ(hgmCore.AddScreen(internalScreenId, 0, screenSize), EXEC_SUCCESS);
999
1000 // fold -> expand -> fold
1001 frameRateMgr->HandleScreenPowerStatus(internalScreenId, ScreenPowerStatus::POWER_STATUS_SUSPEND);
1002 frameRateMgr->HandleScreenPowerStatus(externalScreenId, ScreenPowerStatus::POWER_STATUS_ON);
1003 EXPECT_EQ(frameRateMgr->curScreenId_, externalScreenId);
1004 EXPECT_EQ(hgmCore.AddScreen(extraScreenId, 0, screenSize), EXEC_SUCCESS);
1005 EXPECT_EQ(frameRateMgr->curScreenId_, externalScreenId);
1006 EXPECT_EQ(hgmCore.RemoveScreen(extraScreenId), EXEC_SUCCESS);
1007 EXPECT_EQ(frameRateMgr->curScreenId_, externalScreenId);
1008
1009 EXPECT_EQ(hgmCore.AddScreen(extraScreenId, 0, screenSize), EXEC_SUCCESS);
1010 frameRateMgr->HandleScreenPowerStatus(externalScreenId, ScreenPowerStatus::POWER_STATUS_SUSPEND);
1011 frameRateMgr->HandleScreenPowerStatus(internalScreenId, ScreenPowerStatus::POWER_STATUS_ON);
1012 EXPECT_EQ(frameRateMgr->curScreenId_, internalScreenId);
1013 EXPECT_EQ(hgmCore.RemoveScreen(extraScreenId), EXEC_SUCCESS);
1014 EXPECT_EQ(frameRateMgr->curScreenId_, internalScreenId);
1015
1016 EXPECT_EQ(hgmCore.AddScreen(extraScreenId, 0, screenSize), EXEC_SUCCESS);
1017 EXPECT_EQ(frameRateMgr->curScreenId_, internalScreenId);
1018 EXPECT_EQ(hgmCore.RemoveScreen(extraScreenId), EXEC_SUCCESS);
1019
1020 EXPECT_EQ(hgmCore.AddScreen(extraScreenId, 0, screenSize), EXEC_SUCCESS);
1021 frameRateMgr->HandleScreenPowerStatus(internalScreenId, ScreenPowerStatus::POWER_STATUS_SUSPEND);
1022 frameRateMgr->HandleScreenPowerStatus(externalScreenId, ScreenPowerStatus::POWER_STATUS_ON);
1023 EXPECT_EQ(frameRateMgr->curScreenId_, externalScreenId);
1024 EXPECT_EQ(hgmCore.RemoveScreen(extraScreenId), EXEC_SUCCESS);
1025 EXPECT_EQ(frameRateMgr->curScreenId_, externalScreenId);
1026
1027 // expand -> multiScreen -> expand
1028 frameRateMgr->HandleScreenPowerStatus(externalScreenId, ScreenPowerStatus::POWER_STATUS_SUSPEND);
1029 frameRateMgr->HandleScreenPowerStatus(internalScreenId, ScreenPowerStatus::POWER_STATUS_ON);
1030 EXPECT_EQ(frameRateMgr->curScreenId_, internalScreenId);
1031
1032 hgmCore.SetMultiSelfOwnedScreenEnable(true);
1033 frameRateMgr->HandleScreenPowerStatus(externalScreenId, ScreenPowerStatus::POWER_STATUS_ON);
1034 EXPECT_EQ(frameRateMgr->curScreenId_, internalScreenId);
1035
1036 hgmCore.SetMultiSelfOwnedScreenEnable(false);
1037 frameRateMgr->HandleScreenPowerStatus(externalScreenId, ScreenPowerStatus::POWER_STATUS_SUSPEND);
1038 EXPECT_EQ(frameRateMgr->curScreenId_, internalScreenId);
1039 }
1040
1041 /**
1042 * @tc.name: HandleThermalFrameRate
1043 * @tc.desc: Verify the result of HandleThermalFrameRate
1044 * @tc.type: FUNC
1045 * @tc.require:
1046 */
1047 HWTEST_F(HgmFrameRateMgrTest, HandleThermalFrameRate, Function | SmallTest | Level1)
1048 {
1049 auto &hgmCore = HgmCore::Instance();
1050 auto frameRateMgr = hgmCore.GetFrameRateMgr();
1051 if (frameRateMgr == nullptr || hgmCore.mPolicyConfigData_ == nullptr) {
1052 return;
1053 }
1054 frameRateMgr->HandleThermalFrameRate(true);
1055 EXPECT_EQ(frameRateMgr->isEnableThermalStrategy_, true);
1056
1057 frameRateMgr->HandleThermalFrameRate(false);
1058 EXPECT_EQ(frameRateMgr->isEnableThermalStrategy_, false);
1059 }
1060
1061 /**
1062 * @tc.name: HandlePackageEvent
1063 * @tc.desc: Verify the result of HandlePackageEvent
1064 * @tc.type: FUNC
1065 * @tc.require:
1066 */
1067 HWTEST_F(HgmFrameRateMgrTest, HandlePackageEvent, Function | SmallTest | Level1)
1068 {
1069 auto &hgmCore = HgmCore::Instance();
1070 auto frameRateMgr = hgmCore.GetFrameRateMgr();
1071 if (frameRateMgr == nullptr) {
1072 return;
1073 }
1074 std::string pkgName0 = "com.pkg0";
1075 std::string pkgName1 = "com.pkg1";
1076 std::string scene0 = "SCENE0";
1077 std::string scene1 = "SCENE1";
1078 std::string scene2 = "SCENE2";
1079
1080 auto sceneListConfig = frameRateMgr->GetMultiAppStrategy().GetScreenSetting();
1081 sceneListConfig.sceneList[scene0] = {"1", "1", false};
1082 sceneListConfig.sceneList[scene1] = {"1", "1", true};
1083 sceneListConfig.gameSceneList[scene0] = {"1", "1"};
1084
1085 frameRateMgr->GetMultiAppStrategy().SetScreenSetting(sceneListConfig);
1086
1087 auto checkFunc = [frameRateMgr, scene0, scene1] (bool scene0Existed, bool scene1Existed, bool gameScene0Existed,
__anon1896067b0502(bool scene0Existed, bool scene1Existed, bool gameScene0Existed, bool gameScene1Existed) 1088 bool gameScene1Existed) {
1089 auto sceneStack = frameRateMgr->sceneStack_;
1090 EXPECT_EQ(std::find(sceneStack.begin(), sceneStack.end(),
1091 std::pair<std::string, pid_t>({scene0, DEFAULT_PID})) != sceneStack.end(), scene0Existed);
1092 EXPECT_EQ(std::find(sceneStack.begin(), sceneStack.end(),
1093 std::pair<std::string, pid_t>({scene1, DEFAULT_PID})) != sceneStack.end(), scene1Existed);
1094
1095 auto gameScenes = frameRateMgr->gameScenes_;
1096 EXPECT_EQ(gameScenes.find(scene0) != gameScenes.end(), gameScene0Existed);
1097 EXPECT_EQ(gameScenes.find(scene1) != gameScenes.end(), gameScene1Existed);
1098 };
1099
1100 frameRateMgr->HandleSceneEvent(DEFAULT_PID, {"VOTER_SCENE", true, OLED_NULL_HZ, OLED_MAX_HZ, scene0});
1101 checkFunc(true, false, true, false);
1102
1103 frameRateMgr->HandlePackageEvent(DEFAULT_PID, {pkgName0});
1104 checkFunc(false, false, false, false);
1105
1106 // multi scene
1107 frameRateMgr->HandleSceneEvent(DEFAULT_PID, {"VOTER_SCENE", true, OLED_NULL_HZ, OLED_MAX_HZ, scene0});
1108 frameRateMgr->HandleSceneEvent(DEFAULT_PID, {"VOTER_SCENE", true, OLED_NULL_HZ, OLED_MAX_HZ, scene1});
1109 checkFunc(true, true, true, false);
1110
1111 frameRateMgr->HandlePackageEvent(DEFAULT_PID, {pkgName1});
1112 checkFunc(false, true, false, false);
1113 }
1114
1115 /**
1116 * @tc.name: ChangePriority
1117 * @tc.desc: Verify the result of ChangePriority
1118 * @tc.type: FUNC
1119 * @tc.require:
1120 */
1121 HWTEST_F(HgmFrameRateMgrTest, ChangePriority, Function | SmallTest | Level1)
1122 {
1123 constexpr uint32_t DEFAULT_PRIORITY = 0;
1124 constexpr uint32_t VOTER_SCENE_PRIORITY_BEFORE_PACKAGES = 1;
1125 constexpr uint32_t VOTER_LTPO_PRIORITY_BEFORE_PACKAGES = 2;
1126 auto &hgmCore = HgmCore::Instance();
1127 auto frameRateMgr = hgmCore.GetFrameRateMgr();
1128 if (frameRateMgr == nullptr) {
1129 return;
1130 }
1131
1132 frameRateMgr->ChangePriority(DEFAULT_PRIORITY);
1133 auto packagesPos = find(frameRateMgr->voters_.begin(), frameRateMgr->voters_.end(), "VOTER_PACKAGES");
1134 auto ltpoPos = find(frameRateMgr->voters_.begin(), frameRateMgr->voters_.end(), "VOTER_LTPO");
1135 auto scenePos = find(frameRateMgr->voters_.begin(), frameRateMgr->voters_.end(), "VOTER_SCENE");
1136 ASSERT_LT(packagesPos, ltpoPos);
1137 ASSERT_LT(ltpoPos, scenePos);
1138 frameRateMgr->ChangePriority(VOTER_SCENE_PRIORITY_BEFORE_PACKAGES);
1139 auto packagesPos1 = find(frameRateMgr->voters_.begin(), frameRateMgr->voters_.end(), "VOTER_PACKAGES");
1140 auto ltpoPos1 = find(frameRateMgr->voters_.begin(), frameRateMgr->voters_.end(), "VOTER_LTPO");
1141 auto scenePos1 = find(frameRateMgr->voters_.begin(), frameRateMgr->voters_.end(), "VOTER_SCENE");
1142 ASSERT_LT(scenePos1, packagesPos1);
1143 ASSERT_LT(packagesPos1, ltpoPos1);
1144 frameRateMgr->ChangePriority(VOTER_LTPO_PRIORITY_BEFORE_PACKAGES);
1145 auto packagesPos2 = find(frameRateMgr->voters_.begin(), frameRateMgr->voters_.end(), "VOTER_PACKAGES");
1146 auto ltpoPos2 = find(frameRateMgr->voters_.begin(), frameRateMgr->voters_.end(), "VOTER_LTPO");
1147 auto scenePos2 = find(frameRateMgr->voters_.begin(), frameRateMgr->voters_.end(), "VOTER_SCENE");
1148 ASSERT_LT(scenePos2, ltpoPos2);
1149 ASSERT_LT(ltpoPos2, packagesPos2);
1150 }
1151
1152 /**
1153 * @tc.name: HandleDynamicModeEvent
1154 * @tc.desc: Verify the result of HandleDynamicModeEvent
1155 * @tc.type: FUNC
1156 * @tc.require:
1157 */
1158 HWTEST_F(HgmFrameRateMgrTest, HandleDynamicModeEvent, Function | SmallTest | Level1)
1159 {
1160 auto &hgmCore = HgmCore::Instance();
1161 auto frameRateMgr = hgmCore.GetFrameRateMgr();
1162 if (frameRateMgr == nullptr) {
1163 return;
1164 }
1165 frameRateMgr->HandleDynamicModeEvent(true);
1166 EXPECT_EQ(hgmCore.enableDynamicMode_, true);
1167 }
1168 } // namespace Rosen
1169 } // namespace OHOS
1170