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 "common/rs_common_def.h"
21 #include "ffrt_inner.h"
22 #include "hgm_config_callback_manager.h"
23 #include "hgm_frame_rate_manager.h"
24 #include "hgm_idle_detector.h"
25 #include "hgm_test_base.h"
26 #include "ipc_callbacks/rs_frame_rate_linker_expected_fps_update_callback_stub.h"
27 #include "pipeline/rs_surface_render_node.h"
28 #include "transaction/rs_render_service_client.h"
29
30
31 using namespace testing;
32 using namespace testing::ext;
33
34 namespace OHOS {
35 namespace Rosen {
36 namespace {
37 int64_t offset0 = 0;
38 int32_t testThreadNums = 100;
39 int32_t touchCnt = 1;
40 const std::string otherSurface = "Other_SF";
41 const std::string settingStrategyName = "99";
42 const int32_t HGM_REFRESHRATE_MODE_HIGH = 2;
43 constexpr uint64_t currTime = 200000000;
44 constexpr uint64_t lastTime = 100000000;
45 constexpr pid_t appPid = 0;
46 constexpr pid_t pid = 1;
47 constexpr uint32_t touchCount = 1;
48 constexpr uint32_t delay_60Ms = 60;
49 constexpr uint32_t delay_110Ms = 110;
50 constexpr uint32_t lastTouchUpExpectFps = 90;
51 constexpr int32_t OLED_72_HZ = 72;
52 constexpr int32_t OLED_50_HZ = 50;
53 constexpr int32_t OLED_80_HZ = 80;
54 ScreenSize screenSize = { 720, 1080, 685, 1218 }; // width, height, phyWidth, phyHeight
55 constexpr int32_t internalScreenId = 5;
56 constexpr int32_t externalScreenId = 0;
57 constexpr int32_t frameRateLinkerId1 = 1;
58 constexpr int32_t frameRateLinkerId2 = 2;
59 constexpr int32_t errorVelocity = -1;
60 constexpr int32_t strategy3 = 3;
61 constexpr int32_t maxSize = 25;
62 const std::string testScene = "TestScene";
63 const std::string pkgName0 = "com.pkg.other:0:-1";
64 const std::string pkgName1 = "com.ss.hm.ugc.aweme:1001:10067";
65 const std::string pkgName2 = "com.wedobest.fivechess.harm:1002:10110";
66 const GraphicIRect rectF {
67 .x = 0,
68 .y = 0,
69 .w = 2232,
70 .h = 1008,
71 };
72 const GraphicIRect rectM {
73 .x = 0,
74 .y = 1136,
75 .w = 2232,
76 .h = 2048,
77 };
78 const GraphicIRect rectG {
79 .x = 0,
80 .y = 0,
81 .w = 2232,
82 .h = 3184,
83 };
84 const GraphicIRect rectNeg {
85 .x = -1,
86 .y = -1,
87 .w = -1,
88 .h = -1,
89 };
90 const GraphicIRect rectMax {
91 .x = INT_MAX,
92 .y = INT_MAX,
93 .w = INT_MAX,
94 .h = INT_MAX,
95 };
96 }
97
98 class MyCustomFrameRateLinkerExpectedFpsUpdateCallback : public RSFrameRateLinkerExpectedFpsUpdateCallbackStub {
99 public:
MyCustomFrameRateLinkerExpectedFpsUpdateCallback(const FrameRateLinkerExpectedFpsUpdateCallback & callback)100 explicit MyCustomFrameRateLinkerExpectedFpsUpdateCallback(
101 const FrameRateLinkerExpectedFpsUpdateCallback& callback) : cb_(callback) {}
~MyCustomFrameRateLinkerExpectedFpsUpdateCallback()102 ~MyCustomFrameRateLinkerExpectedFpsUpdateCallback() override {};
103
OnFrameRateLinkerExpectedFpsUpdate(pid_t dstPid,const std::string & xcomponentId,int32_t expectedFps)104 void OnFrameRateLinkerExpectedFpsUpdate(pid_t dstPid, const std::string& xcomponentId, int32_t expectedFps) override
105 {
106 ROSEN_LOGD("MyCustomFrameRateLinkerExpectedFpsUpdateCallback::OnFrameRateLinkerExpectedFpsUpdate called,"
107 " pid=%{public}d, fps=%{public}d", dstPid, expectedFps);
108 if (cb_ != nullptr) {
109 cb_(dstPid, xcomponentId, expectedFps);
110 }
111 }
112
113 private:
114 FrameRateLinkerExpectedFpsUpdateCallback cb_;
115 };
116
117 class HgmFrameRateMgrTest : public HgmTestBase {
118 public:
119 static void SetUpTestCase();
120 static void TearDownTestCase();
121 void SetUp();
122 void TearDown();
123 void InitHgmFrameRateManager(HgmFrameRateManager& frameRateMgr);
124 };
125
SetUpTestCase()126 void HgmFrameRateMgrTest::SetUpTestCase()
127 {
128 HgmTestBase::SetUpTestCase();
129 }
130
TearDownTestCase()131 void HgmFrameRateMgrTest::TearDownTestCase()
132 {
133 HgmTaskHandleThread::Instance().queue_ = std::make_shared<ffrt::queue>(
134 static_cast<ffrt::queue_type>(ffrt_inner_queue_type_t::ffrt_queue_eventhandler_adapter), "HgmTaskHandleThread",
135 ffrt::queue_attr().qos(ffrt::qos_user_interactive));
136 HgmTestBase::TearDownTestCase();
137 }
138
SetUp()139 void HgmFrameRateMgrTest::SetUp()
140 {
141 auto& hgmCore = HgmCore::Instance();
142 hgmCore.hgmFrameRateMgr_ = std::make_unique<HgmFrameRateManager>();
143 if (!HgmTaskHandleThread::Instance().queue_) {
144 HgmTaskHandleThread::Instance().queue_ = std::make_shared<ffrt::queue>(
145 static_cast<ffrt::queue_type>(ffrt_inner_queue_type_t::ffrt_queue_eventhandler_adapter),
146 "HgmTaskHandleThread", ffrt::queue_attr().qos(ffrt::qos_user_interactive));
147 }
148 }
149
TearDown()150 void HgmFrameRateMgrTest::TearDown() {}
151
152 class CustomHgmCallback : public IRemoteStub<RSIHgmConfigChangeCallback> {
153 public:
CustomHgmCallback()154 explicit CustomHgmCallback() {}
~CustomHgmCallback()155 ~CustomHgmCallback() override {};
156
OnHgmConfigChanged(std::shared_ptr<RSHgmConfigData> configData)157 void OnHgmConfigChanged(std::shared_ptr<RSHgmConfigData> configData) override {}
OnHgmRefreshRateModeChanged(int32_t refreshRateModeName)158 void OnHgmRefreshRateModeChanged(int32_t refreshRateModeName) override {}
OnHgmRefreshRateUpdate(int32_t refreshRateUpdate)159 void OnHgmRefreshRateUpdate(int32_t refreshRateUpdate) override {}
160 };
161
InitHgmFrameRateManager(HgmFrameRateManager & frameRateMgr)162 void HgmFrameRateMgrTest::InitHgmFrameRateManager(HgmFrameRateManager& frameRateMgr)
163 {
164 int64_t offset = 0;
165 auto& hgmCore = HgmCore::Instance();
166 auto vsyncGenerator = CreateVSyncGenerator();
167 sptr<Rosen::VSyncController> rsController = new VSyncController(vsyncGenerator, offset);
168 sptr<Rosen::VSyncController> appController = new VSyncController(vsyncGenerator, offset);
169 sptr<VSyncDistributor> appDistributor = new VSyncDistributor(appController, "connection");
170 auto& configData = hgmCore.GetPolicyConfigData();
171 configData->xmlCompatibleMode_ = true;
172 frameRateMgr.curScreenStrategyId_ = "";
173 frameRateMgr.curRefreshRateMode_ = 0;
174 frameRateMgr.Init(nullptr, nullptr, nullptr, nullptr);
175 frameRateMgr.Init(rsController, appController, vsyncGenerator, appDistributor);
176
177 auto strategyConfigs = frameRateMgr.multiAppStrategy_.GetStrategyConfigs();
178 auto screenSetting = frameRateMgr.multiAppStrategy_.GetScreenSetting();
179 frameRateMgr.HandleAppStrategyConfigEvent(DEFAULT_PID, "", {});
180 strategyConfigs[settingStrategyName] = { .min = OLED_NULL_HZ, .max = OLED_120_HZ, .down = OLED_144_HZ,
181 .dynamicMode = DynamicModeType::TOUCH_ENABLED, .pointerMode = PointerModeType::POINTER_ENABLED,
182 .isFactor = true };
183 screenSetting.strategy = settingStrategyName;
184 frameRateMgr.multiAppStrategy_.SetStrategyConfigs(strategyConfigs);
185 frameRateMgr.multiAppStrategy_.SetScreenSetting(screenSetting);
186 for (int i = 0; i < maxSize; ++i) {
187 frameRateMgr.frameRateVoteInfoVec_.emplace_back(i, VoteInfo{});
188 }
189 frameRateMgr.ReportHiSysEvent({ .extInfo = "ON" });
190 }
191
192 /**
193 * @tc.name: HandleGameNodeTest
194 * @tc.desc: Verify the result of HandleGameNodeTest function
195 * @tc.type: FUNC
196 * @tc.require:
197 */
198 HWTEST_F(HgmFrameRateMgrTest, HandleGameNodeTest, Function | SmallTest | Level0)
199 {
200 HgmFrameRateManager frameRateMgr;
201 frameRateMgr.curGameNodeName_ = "gameNode";
202 RSRenderNodeMap nodeMap;
203 RSSurfaceRenderNodeConfig config;
204
205 PART("HandleGameNodeTest") {
206 STEP("1. Test empty surfaceMap") {
207 frameRateMgr.HandleGameNode(nodeMap);
208 ASSERT_EQ(frameRateMgr.isGameNodeOnTree_.load(), false);
209 }
210 STEP("2. Test with a normal surfaceNode on tree") {
211 config.id = 1;
212 config.name = "normalNode";
213 auto normalNode = std::make_shared<RSSurfaceRenderNode>(config);
214 normalNode->SetIsOnTheTree(true);
215 nodeMap.RegisterRenderNode(normalNode);
216 frameRateMgr.HandleGameNode(nodeMap);
217 ASSERT_EQ(frameRateMgr.isGameNodeOnTree_.load(), false);
218 }
219 STEP("3. Test with a game surfaceNode not on tree") {
220 config.id = 2;
221 config.name = "gameNode";
222 config.nodeType = RSSurfaceNodeType::SELF_DRAWING_NODE;
223 auto gameNode1 = std::make_shared<RSSurfaceRenderNode>(config);
224 gameNode1->SetIsOnTheTree(false);
225 nodeMap.RegisterRenderNode(gameNode1);
226 frameRateMgr.HandleGameNode(nodeMap);
227 ASSERT_EQ(frameRateMgr.isGameNodeOnTree_.load(), false);
228 }
229 STEP("4. Test with a game surfaceNode on tree") {
230 config.id = 3;
231 auto gameNode2 = std::make_shared<RSSurfaceRenderNode>(config);
232 gameNode2->SetIsOnTheTree(true);
233 nodeMap.RegisterRenderNode(gameNode2);
234 frameRateMgr.HandleGameNode(nodeMap);
235 ASSERT_EQ(frameRateMgr.isGameNodeOnTree_.load(), true);
236 }
237 STEP("5. Test with a game surfaceNode on tree and other self node on tree") {
238 config.id = 4;
239 config.name = "other";
240 auto otherNode = std::make_shared<RSSurfaceRenderNode>(config);
241 otherNode->SetIsOnTheTree(true);
242 nodeMap.RegisterRenderNode(otherNode);
243 frameRateMgr.HandleGameNode(nodeMap);
244 ASSERT_EQ(frameRateMgr.isGameNodeOnTree_.load(), false);
245 }
246 }
247 sleep(1);
248 }
249
250 /**
251 * @tc.name: HgmUiFrameworkDirtyNodeTest
252 * @tc.desc: Verify the result of HgmUiFrameworkDirtyNodeTest function
253 * @tc.type: FUNC
254 * @tc.require:
255 */
256 HWTEST_F(HgmFrameRateMgrTest, HgmUiFrameworkDirtyNodeTest, Function | SmallTest | Level0)
257 {
258 HgmFrameRateManager frameRateMgr;
259 std::vector<std::weak_ptr<RSRenderNode>> uiFwkDirtyNodes;
260 PART("HgmUiFrameworkDirtyNodeTest") {
261 STEP("1. Test empty uiFwkDirtyNodes") {
262 ASSERT_EQ(uiFwkDirtyNodes.size(), 0);
263 frameRateMgr.UpdateUIFrameworkDirtyNodes(uiFwkDirtyNodes, 0);
264 frameRateMgr.voterTouchEffective_ = true;
265 {
266 std::shared_ptr<RSRenderNode> renderNode1 = std::make_shared<RSRenderNode>(0);
267 uiFwkDirtyNodes.emplace_back(renderNode1);
268 ASSERT_EQ(uiFwkDirtyNodes.size(), 1);
269 }
270 frameRateMgr.UpdateUIFrameworkDirtyNodes(uiFwkDirtyNodes, 0);
271 ASSERT_EQ(uiFwkDirtyNodes.size(), 0);
272 }
273 STEP("2. Test uiFwkDirtyNodes with a clean renderNode") {
274 std::shared_ptr<RSRenderNode> renderNode2 = std::make_shared<RSRenderNode>(0);
275 uiFwkDirtyNodes.emplace_back(renderNode2);
276 ASSERT_EQ(uiFwkDirtyNodes.size(), 1);
277 ASSERT_EQ(renderNode2->IsDirty(), false);
278 frameRateMgr.UpdateUIFrameworkDirtyNodes(uiFwkDirtyNodes, 0);
279 ASSERT_EQ(uiFwkDirtyNodes.size(), 1);
280 }
281 STEP("3. Test uiFwkDirtyNodes with a dirty renderNode") {
282 std::shared_ptr<RSRenderNode> renderNode3 = std::make_shared<RSRenderNode>(0);
283 uiFwkDirtyNodes.emplace_back(renderNode3);
284 ASSERT_EQ(uiFwkDirtyNodes.size(), 2);
285
286 frameRateMgr.UpdateUIFrameworkDirtyNodes(uiFwkDirtyNodes, 0);
287 ASSERT_EQ(uiFwkDirtyNodes.size(), 1);
288
289 renderNode3->SetDirty();
290 ASSERT_EQ(renderNode3->IsDirty(), true);
291 frameRateMgr.UpdateUIFrameworkDirtyNodes(uiFwkDirtyNodes, 0);
292 ASSERT_EQ(uiFwkDirtyNodes.size(), 1);
293 }
294 STEP("4. other branch") {
295 frameRateMgr.surfaceData_.emplace_back(std::tuple<std::string, pid_t, UIFWKType>());
296 frameRateMgr.UpdateUIFrameworkDirtyNodes(uiFwkDirtyNodes, 0);
297 frameRateMgr.frameVoter_.voterGamesEffective_ = true;
298 frameRateMgr.UpdateUIFrameworkDirtyNodes(uiFwkDirtyNodes, 0);
299 frameRateMgr.voterTouchEffective_ = false;
300 frameRateMgr.UpdateUIFrameworkDirtyNodes(uiFwkDirtyNodes, 0);
301 }
302 }
303 sleep(1);
304 }
305
306 /**
307 * @tc.name: ProcessPendingRefreshRate
308 * @tc.desc: Verify the result of ProcessPendingRefreshRate function
309 * @tc.type: FUNC
310 * @tc.require:
311 */
312 HWTEST_F(HgmFrameRateMgrTest, ProcessPendingRefreshRate, Function | SmallTest | Level0)
313 {
314 HgmFrameRateManager frameRateMgr;
315 std::vector<std::weak_ptr<RSRenderNode>> uiFwkDirtyNodes;
316 bool disableSafeVote = true;
317 frameRateMgr.multiAppStrategy_.SetDisableSafeVoteValue(disableSafeVote);
318
319 frameRateMgr.UpdateUIFrameworkDirtyNodes(uiFwkDirtyNodes, 0);
320 FrameRateLinkerMap appFrameRateLinkers;
321 const std::map<uint64_t, int> vRatesMap;
322 frameRateMgr.UniProcessDataForLtpo(currTime, frameRateMgr.rsFrameRateLinker_,
323 appFrameRateLinkers, vRatesMap);
324 auto& hgmCore = HgmCore::Instance();
325 hgmCore.ltpoEnabled_ = false;
326 FrameRateLinkerId id;
327 frameRateMgr.rsFrameRateLinker_ = std::make_shared<RSRenderFrameRateLinker>(id);
328
329 frameRateMgr.appFrameRateLinkers_.clear();
330 frameRateMgr.appFrameRateLinkers_.try_emplace(id, nullptr);
331 frameRateMgr.UpdateSoftVSync(true);
332 frameRateMgr.appFrameRateLinkers_.try_emplace(id, frameRateMgr.rsFrameRateLinker_);
333 frameRateMgr.UpdateSoftVSync(true);
334 frameRateMgr.currRefreshRate_.store(OLED_90_HZ);
335 frameRateMgr.UpdateSoftVSync(true);
336 int64_t vsyncid = 0;
337 uint32_t rsRate = 0;
338 bool isUiDvsyncOn = false;
339 frameRateMgr.pendingRefreshRate_ = nullptr;
340 frameRateMgr.ProcessPendingRefreshRate(currTime, vsyncid, rsRate, isUiDvsyncOn);
341 frameRateMgr.lastPendingConstraintRelativeTime_ = currTime;
342 frameRateMgr.ProcessPendingRefreshRate(currTime, vsyncid, rsRate, isUiDvsyncOn);
343 ASSERT_EQ(hgmCore.pendingConstraintRelativeTime_,
344 frameRateMgr.lastPendingConstraintRelativeTime_);
345 uint32_t pendingRefreshRate = OLED_60_HZ;
346 frameRateMgr.pendingRefreshRate_ = std::make_shared<uint32_t>(pendingRefreshRate);
347 frameRateMgr.ProcessPendingRefreshRate(currTime, vsyncid, rsRate, isUiDvsyncOn);
348 ASSERT_EQ(frameRateMgr.pendingConstraintRelativeTime_, 0);
349 ASSERT_EQ(frameRateMgr.lastPendingRefreshRate_, OLED_60_HZ);
350 frameRateMgr.pendingRefreshRate_ = nullptr;
351 frameRateMgr.ProcessPendingRefreshRate(currTime, vsyncid, rsRate, isUiDvsyncOn);
352 frameRateMgr.voterTouchEffective_ = true;
353 std::string surfaceName = "surface0";
354 size_t oldSize = frameRateMgr.surfaceData_.size();
355 frameRateMgr.UpdateSurfaceTime(surfaceName, pid, UIFWKType::FROM_UNKNOWN);
356 EXPECT_GE(frameRateMgr.surfaceData_.size(), oldSize);
357 }
358
359 /**
360 * @tc.name: HgmConfigCallbackManagerTest001
361 * @tc.desc: Verify the result of HgmConfigCallbackManagerTest001 function
362 * @tc.type: FUNC
363 * @tc.require:
364 */
365 HWTEST_F(HgmFrameRateMgrTest, HgmConfigCallbackManagerTest001, Function | SmallTest | Level0)
366 {
367 sptr<HgmConfigCallbackManager> hccMgr = HgmConfigCallbackManager::GetInstance();
368 PART("HgmConfigCallbackManagerTest") {
369 STEP("1. Callback is nullptr") {
370 sptr<CustomHgmCallback> cb1 = new CustomHgmCallback();
371 hccMgr->RegisterHgmRefreshRateModeChangeCallback(0, nullptr);
372 hccMgr->RegisterHgmRefreshRateModeChangeCallback(1, cb1);
373 }
374 STEP("2. Test SyncHgmConfigChangeCallback without callback") {
375 std::unordered_map<pid_t, sptr<RSIHgmConfigChangeCallback>> emptyCallback;
376 std::swap(hccMgr->animDynamicCfgCallbacks_, emptyCallback);
377 ASSERT_EQ(hccMgr->animDynamicCfgCallbacks_.empty(), true);
378 hccMgr->SyncHgmConfigChangeCallback();
379 }
380 }
381 }
382
383 /**
384 * @tc.name: HgmConfigCallbackManagerTest002
385 * @tc.desc: Verify the result of HgmConfigCallbackManagerTest002 function
386 * @tc.type: FUNC
387 * @tc.require:
388 */
389 HWTEST_F(HgmFrameRateMgrTest, HgmConfigCallbackManagerTest002, Function | SmallTest | Level0)
390 {
391 sptr<HgmConfigCallbackManager> hccMgr = HgmConfigCallbackManager::GetInstance();
392 PART("HgmConfigCallbackManagerTest") {
393 STEP("1. Test SyncCallback function with callback") {
394 sptr<CustomHgmCallback> cb = new CustomHgmCallback();
395 hccMgr->animDynamicCfgCallbacks_[0] = cb;
396 hccMgr->refreshRateModeCallbacks_[0] = cb;
397 hccMgr->SyncHgmConfigChangeCallback();
398 hccMgr->SyncRefreshRateModeChangeCallback(0);
399 hccMgr->RegisterHgmConfigChangeCallback(0, nullptr);
400 auto& hgmCore = HgmCore::Instance();
401 auto& configData = hgmCore.GetPolicyConfigData();
402 configData->pageNameList_.push_back("com.app10");
403 ScreenId id = 0;
404 int32_t mode = 0;
405 sptr<HgmScreen> screen = new HgmScreen(id, mode, screenSize);
406 hgmCore.screenList_.push_back(screen);
407 hccMgr->RegisterHgmConfigChangeCallback(pid, cb);
408 hccMgr->RegisterHgmRefreshRateUpdateCallback(0, nullptr);
409 hccMgr->RegisterHgmRefreshRateUpdateCallback(pid, cb);
410 hccMgr->refreshRateUpdateCallbacks_.try_emplace(0, cb);
411 hccMgr->RegisterHgmRefreshRateUpdateCallback(0, nullptr);
412 hccMgr->RegisterHgmRefreshRateUpdateCallback(pid, cb);
413 hccMgr->SyncHgmConfigChangeCallback();
414 hccMgr->SyncRefreshRateModeChangeCallback(0);
415 hccMgr->refreshRateUpdateCallbacks_ = {
416 {0, nullptr},
417 };
418 hccMgr->SyncRefreshRateUpdateCallback(OLED_60_HZ);
419 ASSERT_EQ(hccMgr->animDynamicCfgCallbacks_.empty(), false);
420 hccMgr->UnRegisterHgmConfigChangeCallback(pid);
421 hccMgr->UnRegisterHgmConfigChangeCallback(0);
422 hccMgr->animDynamicCfgCallbacks_.try_emplace(pid, cb);
423 hccMgr->SyncHgmConfigChangeCallback();
424 hccMgr->refreshRateUpdateCallbacks_.try_emplace(0, cb);
425 hccMgr->SyncRefreshRateUpdateCallback(OLED_60_HZ);
426 hccMgr->SyncHgmConfigChangeCallback();
427 hccMgr->refreshRateUpdateCallbacks_.clear();
428 hccMgr->refreshRateUpdateCallbacks_.try_emplace(0, cb);
429 hccMgr->SyncRefreshRateUpdateCallback(OLED_60_HZ);
430 std::unordered_map<pid_t, std::pair<int32_t, std::string>> foregroundPidAppMap;
431 foregroundPidAppMap.try_emplace(pid, std::pair<int32_t, std::string>{ 0, "com.app10" });
432 hccMgr->SyncHgmConfigChangeCallback(foregroundPidAppMap);
433 ASSERT_EQ(hccMgr->pendingAnimDynamicCfgCallbacks_.find(pid) ==
434 hccMgr->pendingAnimDynamicCfgCallbacks_.end(), true);
435 }
436 }
437 }
438
439 /**
440 * @tc.name: HgmConfigCallbackManagerTest003
441 * @tc.desc: Verify the result of HgmConfigCallbackManagerTest003 function
442 * @tc.type: FUNC
443 * @tc.require:
444 */
445 HWTEST_F(HgmFrameRateMgrTest, HgmConfigCallbackManagerTest003, Function | SmallTest | Level0)
446 {
447 sptr<HgmConfigCallbackManager> hccMgr = HgmConfigCallbackManager::GetInstance();
448 pid_t listenerPid = 3;
449 pid_t dstPid = 3;
450 pid_t dstPid1 = 5;
451 vector<int32_t> expectedFrameRates = { 60, 0 };
452 int32_t invalidRate = -1;
453 int32_t invalidRate1 = -60;
454 std::string idStr = "xcomponentId";
455 const sptr<RSIFrameRateLinkerExpectedFpsUpdateCallback> cb = nullptr;
456 std::unordered_map<pid_t, sptr<RSIFrameRateLinkerExpectedFpsUpdateCallback>> cbMap;
457 cbMap.try_emplace(listenerPid, cb);
458 hccMgr->xcomponentExpectedFrameRateCallbacks_.try_emplace(dstPid, cbMap);
459
460 int32_t fps_ = 30;
461 std::function<void(int32_t, const std::string&, int32_t)> callback = [&fps_](int32_t dstPid,
__anon09d8ed1d0202(int32_t dstPid, const std::string& xcomponentId, int32_t fps) 462 const std::string& xcomponentId, int32_t fps) {
463 fps_ = fps;
464 };
465 std::unordered_map<std::string, int32_t> xcomponentIdMap;
466
467 auto temp = new MyCustomFrameRateLinkerExpectedFpsUpdateCallback(callback);
468 auto cb1 = iface_cast<RSIFrameRateLinkerExpectedFpsUpdateCallback>(temp);
469 for (const auto& expectedFrameRate : expectedFrameRates) {
470 PART("HgmConfigCallbackManagerTest") {
471 STEP("1. Test RegisterXComponentExpectedFrameRateCallback function with callback") {
472 xcomponentIdMap.try_emplace(idStr, expectedFrameRate);
473 hccMgr->xcomponentExpectedFrameRateCallbacks_.clear();
474 cbMap.try_emplace(listenerPid, cb);
475 hccMgr->xcomponentExpectedFrameRateCallbacks_.try_emplace(dstPid1, cbMap);
476 hccMgr->RegisterXComponentExpectedFrameRateCallback(listenerPid, dstPid, cb);
477 hccMgr->xcomponentExpectedFrameRateCallbacks_.try_emplace(dstPid, cbMap);
478 hccMgr->RegisterXComponentExpectedFrameRateCallback(listenerPid, dstPid, cb);
479 hccMgr->xcomponentExpectedFrameRate_.clear();
480 hccMgr->xcomponentExpectedFrameRateCallbacks_.clear();
481 hccMgr->xcomponentExpectedFrameRate_.try_emplace(dstPid1, xcomponentIdMap);
482 hccMgr->RegisterXComponentExpectedFrameRateCallback(listenerPid, dstPid, cb1);
483 ASSERT_EQ(hccMgr->xcomponentExpectedFrameRateCallbacks_[dstPid][listenerPid], cb1);
484 hccMgr->xcomponentExpectedFrameRateCallbacks_.clear();
485 hccMgr->xcomponentExpectedFrameRate_.clear();
486 hccMgr->xcomponentExpectedFrameRate_.try_emplace(dstPid, xcomponentIdMap);
487 hccMgr->RegisterXComponentExpectedFrameRateCallback(listenerPid, dstPid, cb1);
488 ASSERT_EQ(hccMgr->xcomponentExpectedFrameRateCallbacks_[dstPid][listenerPid], cb1);
489 }
490 STEP("2. Test SyncXComponentExpectedFrameRateCallback function with callback") {
491 ASSERT_NE(cb1, nullptr);
492 hccMgr->xcomponentExpectedFrameRateCallbacks_.clear();
493 cbMap.clear();
494 cbMap.try_emplace(listenerPid, cb);
495 hccMgr->xcomponentExpectedFrameRateCallbacks_.try_emplace(dstPid, cbMap);
496 hccMgr->SyncXComponentExpectedFrameRateCallback(dstPid, idStr, expectedFrameRate);
497 hccMgr->xcomponentExpectedFrameRateCallbacks_.clear();
498 cbMap.clear();
499 cbMap.try_emplace(listenerPid, cb1);
500 hccMgr->xcomponentExpectedFrameRateCallbacks_.try_emplace(dstPid, cbMap);
501 hccMgr->SyncXComponentExpectedFrameRateCallback(dstPid, idStr, expectedFrameRate);
502 ASSERT_EQ(hccMgr->xcomponentExpectedFrameRate_[dstPid][idStr], expectedFrameRate);
503 hccMgr->xcomponentExpectedFrameRate_.clear();
504 hccMgr->xcomponentExpectedFrameRateCallbacks_.clear();
505 cbMap.clear();
506 cbMap.try_emplace(listenerPid, cb1);
507 hccMgr->xcomponentExpectedFrameRateCallbacks_.try_emplace(dstPid, cbMap);
508 hccMgr->SyncXComponentExpectedFrameRateCallback(dstPid, idStr, expectedFrameRate);
509 ASSERT_EQ(hccMgr->xcomponentExpectedFrameRate_[dstPid][idStr], expectedFrameRate);
510 }
511 ASSERT_EQ(fps_, expectedFrameRate);
512 hccMgr->SyncXComponentExpectedFrameRateCallback(dstPid, idStr, invalidRate);
513 hccMgr->SyncXComponentExpectedFrameRateCallback(0, idStr, invalidRate);
514 ASSERT_NE(hccMgr->xcomponentExpectedFrameRate_[dstPid][idStr], invalidRate);
515 hccMgr->SyncXComponentExpectedFrameRateCallback(dstPid, idStr, invalidRate1);
516 ASSERT_NE(hccMgr->xcomponentExpectedFrameRate_[dstPid][idStr], invalidRate1);
517
518 hccMgr->xcomponentExpectedFrameRate_.clear();
519 hccMgr->xcomponentExpectedFrameRateCallbacks_.clear();
520 cbMap.clear();
521 cbMap.try_emplace(listenerPid, cb);
522 cbMap.try_emplace(dstPid1, cb1);
523 hccMgr->xcomponentExpectedFrameRateCallbacks_.try_emplace(dstPid, cbMap);
524 hccMgr->SyncXComponentExpectedFrameRateCallback(dstPid, idStr, expectedFrameRate);
525 ASSERT_EQ(hccMgr->xcomponentExpectedFrameRate_[dstPid][idStr], expectedFrameRate);
526 hccMgr->xcomponentExpectedFrameRate_.clear();
527
528 xcomponentIdMap.clear();
529 xcomponentIdMap.try_emplace("xcomponentId1", OLED_30_HZ);
530 hccMgr->xcomponentExpectedFrameRate_.try_emplace(dstPid, xcomponentIdMap);
531 hccMgr->SyncXComponentExpectedFrameRateCallback(dstPid, idStr, expectedFrameRate);
532 }
533 }
534 hccMgr->UnRegisterHgmConfigChangeCallback(dstPid);
535 hccMgr->UnRegisterHgmConfigChangeCallback(dstPid1);
536 }
537
538 /**
539 * @tc.name: HgmConfigCallbackManagerTest004
540 * @tc.desc: Verify the result of HgmConfigCallbackManagerTest004 function
541 * @tc.type: FUNC
542 * @tc.require:
543 */
544 HWTEST_F(HgmFrameRateMgrTest, HgmConfigCallbackManagerTest004, Function | SmallTest | Level0)
545 {
546 int32_t invalidRate = 300;
547 int32_t dstPid = 1;
548 int32_t expectedFrameRate = 60;
549 std::string xcomponentId = "xcomponentId";
550 std::unordered_map<std::string, int32_t> xcomponentIdMap;
551 xcomponentIdMap.try_emplace(xcomponentId, invalidRate);
552 sptr<HgmConfigCallbackManager> hccMgr = HgmConfigCallbackManager::GetInstance();
553 hccMgr->xcomponentExpectedFrameRateCallbacks_.clear();
554 hccMgr->xcomponentExpectedFrameRate_.clear();
555 hccMgr->xcomponentExpectedFrameRate_.try_emplace(dstPid, xcomponentIdMap);
556
557 for (int32_t i = 0; i < 100; ++i) { // 100 : xcomponentIdNums
558 std::string idStr = xcomponentId + std::to_string(i);
559 hccMgr->SyncXComponentExpectedFrameRateCallback(dstPid, idStr, expectedFrameRate);
560 }
561 ASSERT_EQ(hccMgr->xcomponentExpectedFrameRate_[dstPid].size(), 50); // 50 : xcomponentIdNumsMax of one pid
562 }
563
564 /**
565 * @tc.name: MultiThread001
566 * @tc.desc: Verify the result of MultiThread001 function
567 * @tc.type: FUNC
568 * @tc.require:
569 */
570 HWTEST_F(HgmFrameRateMgrTest, MultiThread001, Function | SmallTest | Level0)
571 {
572 HgmFrameRateManager frameRateMgr;
573 auto vsyncGenerator = CreateVSyncGenerator();
574 sptr<Rosen::VSyncController> rsController = new VSyncController(vsyncGenerator, offset0);
575 sptr<Rosen::VSyncController> appController = new VSyncController(vsyncGenerator, offset0);
576 sptr<VSyncDistributor> appDistributor = new VSyncDistributor(appController, "connection");
577 frameRateMgr.Init(rsController, appController, vsyncGenerator, appDistributor);
__anon09d8ed1d0302(bool idleTimerExpired, bool forceUpdate) 578 frameRateMgr.forceUpdateCallback_ = [](bool idleTimerExpired, bool forceUpdate) { return; };
579 auto& touchManager = frameRateMgr.GetTouchManager();
580 touchManager.ChangeState(TouchState::DOWN_STATE);
581 touchManager.ChangeState(TouchState::UP_STATE);
582 usleep(100000); // 100000us
583 ASSERT_EQ(touchManager.GetState(), TouchState::UP_STATE);
584 touchManager.ChangeState(TouchState::IDLE_STATE);
585 usleep(100000); // 100000us
586 ASSERT_EQ(touchManager.GetState(), TouchState::IDLE_STATE);
587 ASSERT_NE(vsyncGenerator, nullptr);
588 ASSERT_NE(rsController, nullptr);
589 ASSERT_NE(appController, nullptr);
590 ASSERT_NE(appDistributor, nullptr);
__anon09d8ed1d0402() 591 HgmTaskHandleThread::Instance().PostTask([&]() {
592 for (int i = 0; i < testThreadNums; i++) {
593 // HandleLightFactorStatus
594 frameRateMgr.HandleLightFactorStatus(i, LightFactorStatus::NORMAL_LOW);
595 frameRateMgr.HandleLightFactorStatus(i, LightFactorStatus::NORMAL_HIGH);
596
597 // HandlePackageEvent
598 frameRateMgr.HandlePackageEvent(i, { pkgName0 });
599 ASSERT_NE(frameRateMgr.multiAppStrategy_.HandlePkgsEvent({ pkgName0 }), EXEC_SUCCESS);
600 frameRateMgr.HandlePackageEvent(i, { pkgName1 });
601 ASSERT_NE(frameRateMgr.multiAppStrategy_.HandlePkgsEvent({ pkgName1 }), EXEC_SUCCESS);
602 frameRateMgr.HandlePackageEvent(i, { pkgName2 });
603 ASSERT_NE(frameRateMgr.multiAppStrategy_.HandlePkgsEvent({ pkgName2 }), EXEC_SUCCESS);
604 frameRateMgr.HandlePackageEvent(i, { pkgName0, pkgName1 });
605 ASSERT_NE(frameRateMgr.multiAppStrategy_.HandlePkgsEvent({ pkgName0, pkgName1 }), EXEC_SUCCESS);
606
607 // HandleRefreshRateEvent
608 frameRateMgr.HandleRefreshRateEvent(i, {});
609
610 // HandleTouchEvent
611 frameRateMgr.HandleTouchEvent(i, TouchStatus::TOUCH_DOWN, touchCnt);
612 frameRateMgr.HandleTouchEvent(i, TouchStatus::TOUCH_UP, touchCnt);
613
614 // HandleRefreshRateMode
615 // param -1、0、1、2、3：refresh rate mode
616 frameRateMgr.HandleRefreshRateMode(-1);
617 frameRateMgr.HandleRefreshRateMode(0);
618 frameRateMgr.HandleRefreshRateMode(1);
619 frameRateMgr.HandleRefreshRateMode(2);
620 frameRateMgr.HandleRefreshRateMode(3);
621
622 // HandleScreenPowerStatus
623 frameRateMgr.HandleScreenPowerStatus(i, ScreenPowerStatus::POWER_STATUS_ON);
624 frameRateMgr.HandleScreenPowerStatus(i, ScreenPowerStatus::POWER_STATUS_OFF);
625 }
626 });
627 sleep(2); // wait for handler task finished
628 HgmTaskHandleThread::Instance().queue_ = nullptr;
629 }
630
631 /**
632 * @tc.name: HandleScreenRectFrameRate
633 * @tc.desc: Verify the result of HandleScreenRectFrameRate function
634 * @tc.type: FUNC
635 * @tc.require:
636 */
637 HWTEST_F(HgmFrameRateMgrTest, HandleScreenRectFrameRate, Function | SmallTest | Level0)
638 {
639 int32_t testThreadNum = 100;
640 auto& hgmCore = HgmCore::Instance();
641 EXPECT_EQ(hgmCore.AddScreen(externalScreenId, 0, screenSize), EXEC_SUCCESS);
642 auto screen = hgmCore.GetScreen(externalScreenId);
643 ASSERT_NE(screen, nullptr);
644 screen->isSelfOwnedScreenFlag_.store(true);
645
646 HgmFrameRateManager frameRateMgr;
__anon09d8ed1d0502() 647 HgmTaskHandleThread::Instance().PostTask([&]() {
648 for (int i = 0; i < testThreadNum; i++) {
649 // HandleScreenRectFrameRate
650 frameRateMgr.HandleScreenRectFrameRate(i, rectF);
651 frameRateMgr.HandleScreenRectFrameRate(i, rectM);
652 frameRateMgr.HandleScreenRectFrameRate(i, rectG);
653 frameRateMgr.HandleScreenRectFrameRate(i, rectNeg);
654 auto& configData = hgmCore.GetPolicyConfigData();
655 configData->virtualDisplayConfigs_.clear();
656 frameRateMgr.HandleScreenRectFrameRate(i, rectMax);
657 EXPECT_EQ(frameRateMgr.curScreenStrategyId_, "LTPO-DEFAULT");
658 }
659 });
660 EXPECT_EQ(hgmCore.RemoveScreen(externalScreenId), EXEC_SUCCESS);
661 sleep(2); // wait for handler task finished
662 }
663
664 /**
665 * @tc.name: UpdateGuaranteedPlanVoteTest
666 * @tc.desc: Verify the result of UpdateGuaranteedPlanVote
667 * @tc.type: FUNC
668 * @tc.require:
669 */
670 HWTEST_F(HgmFrameRateMgrTest, UpdateGuaranteedPlanVoteTest, Function | SmallTest | Level0)
671 {
672 std::unique_ptr<HgmFrameRateManager> mgr = std::make_unique<HgmFrameRateManager>();
673
674 mgr->idleDetector_.SetAppSupportedState(false);
675 mgr->UpdateGuaranteedPlanVote(currTime);
676
677 mgr->idleDetector_.SetAppSupportedState(true);
678 mgr->UpdateGuaranteedPlanVote(currTime);
679
680 mgr->HandleTouchEvent(appPid, TouchStatus::TOUCH_DOWN, touchCount);
681 mgr->HandleTouchEvent(appPid, TouchStatus::TOUCH_UP, touchCount);
682 std::this_thread::sleep_for(std::chrono::milliseconds(delay_110Ms));
683 mgr->UpdateGuaranteedPlanVote(currTime);
684
685 mgr->idleDetector_.bufferFpsMap_["AceAnimato"] = 90;
686 mgr->HandleTouchEvent(appPid, TouchStatus::TOUCH_DOWN, touchCount);
687 mgr->HandleTouchEvent(appPid, TouchStatus::TOUCH_UP, touchCount);
688 std::this_thread::sleep_for(std::chrono::milliseconds(delay_110Ms));
689 mgr->UpdateGuaranteedPlanVote(currTime);
690
691 mgr->idleDetector_.SetAceAnimatorIdleState(false);
692 mgr->HandleTouchEvent(appPid, TouchStatus::TOUCH_DOWN, touchCount);
693 mgr->HandleTouchEvent(appPid, TouchStatus::TOUCH_UP, touchCount);
694 std::this_thread::sleep_for(std::chrono::milliseconds(delay_110Ms));
695 mgr->UpdateGuaranteedPlanVote(currTime);
696 EXPECT_FALSE(mgr->idleDetector_.GetAceAnimatorIdleState());
697 mgr->lastTouchUpExpectFps_ = OLED_90_HZ;
698 EXPECT_EQ(mgr->idleDetector_.GetTouchUpExpectedFPS(), mgr->lastTouchUpExpectFps_);
699 mgr->touchManager_.ChangeState(TouchState::IDLE_STATE);
700 }
701
702 /**
703 * @tc.name: CleanPidCallbackTest
704 * @tc.desc: Verify the result of CleanPidCallbackTest
705 * @tc.type: FUNC
706 * @tc.require:
707 */
708 HWTEST_F(HgmFrameRateMgrTest, CleanPidCallbackTest, Function | SmallTest | Level0)
709 {
710 std::unique_ptr<HgmFrameRateManager> mgr = std::make_unique<HgmFrameRateManager>();
711 int32_t defaultPid = 0;
712 int32_t gamePid = 10024;
713 uint32_t undefinedCallbackType = 0xff;
714 std::string defaultScreenStrategyId = "LTPO-DEFAULT";
715 std::string invalidScreenStrategyId = "DEFAULT-INVALID";
716 auto& hgm = HgmCore::Instance();
717
718 mgr->CleanVote(defaultPid);
719 mgr->cleanPidCallback_[gamePid].insert(CleanPidCallbackType::LIGHT_FACTOR);
720 mgr->cleanPidCallback_[gamePid].insert(CleanPidCallbackType::PACKAGE_EVENT);
721 mgr->cleanPidCallback_[gamePid].insert(CleanPidCallbackType::TOUCH_EVENT);
722 mgr->cleanPidCallback_[gamePid].insert(CleanPidCallbackType::GAMES);
723 mgr->cleanPidCallback_[gamePid].insert(static_cast<CleanPidCallbackType>(undefinedCallbackType));
724 mgr->CleanVote(gamePid);
725 mgr->frameVoter_.pidRecord_.emplace(defaultPid);
726 mgr->CleanVote(gamePid);
727 mgr->frameVoter_.pidRecord_.emplace(gamePid);
728 mgr->CleanVote(gamePid);
729 EXPECT_EQ(mgr->frameVoter_.pidRecord_.find(gamePid), mgr->frameVoter_.pidRecord_.end());
730
731 if (hgm.mPolicyConfigData_ == nullptr) {
732 return;
733 }
734 auto screenSetting = mgr->multiAppStrategy_.GetScreenSetting();
735 screenSetting.sceneList.insert(make_pair(testScene, PolicyConfigData::SceneConfig{ "1", "1" }));
736 screenSetting.gameSceneList.insert(make_pair(testScene, "1"));
737 screenSetting.ancoSceneList.insert(make_pair(testScene, PolicyConfigData::SceneConfig{ "1", "1" }));
738 mgr->multiAppStrategy_.SetScreenSetting(screenSetting);
739 EventInfo eventInfo2 = { .eventName = "VOTER_SCENE", .eventStatus = true, .description = testScene };
740 mgr->HandleRefreshRateEvent(0, eventInfo2);
741 EventInfo eventInfo3 = { .eventName = "ENERGY_CONSUMPTION_ASSURANCE", .eventStatus = true,
742 .description = "DRAG_SCENE:0"};
743 mgr->HandleRefreshRateEvent(0, eventInfo3);
744 EventInfo eventInfo4 = { .eventName = "ENERGY_CONSUMPTION_ASSURANCE", .eventStatus = false,
745 .description = "DRAG_SCENE:0"};
746 mgr->HandleRefreshRateEvent(0, eventInfo4);
747 sleep(1);
748 }
749
750 /**
751 * @tc.name: HandleEventTest
752 * @tc.desc: Verify the result of HandleEventTest
753 * @tc.type: FUNC
754 * @tc.require:
755 */
756 HWTEST_F(HgmFrameRateMgrTest, HandleEventTest, Function | SmallTest | Level0)
757 {
758 std::string pkg0 = "com.pkg.other:0:-1";
759 std::string pkg1 = "com.pkg.other:1:-1";
760
761 std::unique_ptr<HgmFrameRateManager> mgr = std::make_unique<HgmFrameRateManager>();
762 auto& hgm = HgmCore::Instance();
763 mgr->DeliverRefreshRateVote({ "VOTER_GAMES", 120, 90, 0 }, true);
764
765 mgr->GetExpectedFrameRate(static_cast<RSPropertyUnit>(RSPropertyUnit::PIXEL_POSITION), 100.f, 0, 0);
766 mgr->GetExpectedFrameRate(static_cast<RSPropertyUnit>(0xff), 100.f, 0, 0);
767 if (hgm.mPolicyConfigData_ == nullptr) {
768 return;
769 }
770 EXPECT_NE(hgm.mPolicyConfigData_, nullptr);
771 mgr->GetPreferredFps("aaa", 100.f, 100.f, 100.f);
772 mgr->GetPreferredFps("aaa", 100.f, 0.f, 0.f);
773
774 std::shared_ptr<PolicyConfigData> cachedPolicyConfigData = nullptr;
775 std::swap(hgm.mPolicyConfigData_, cachedPolicyConfigData);
776 EXPECT_EQ(hgm.mPolicyConfigData_, nullptr);
777 ASSERT_EQ(nullptr, hgm.GetPolicyConfigData());
778 mgr->GetPreferredFps("aaa", 100.f, 0.f, 0.f);
779
780 EventInfo eventInfo = { .eventName = "VOTER_GAMES", .eventStatus = false,
781 .description = pkg0,
782 };
783 mgr->HandleRefreshRateEvent(0, eventInfo);
784 mgr->HandleGamesEvent(0, eventInfo);
785 eventInfo.eventStatus = true;
786 mgr->HandleGamesEvent(0, eventInfo);
787 eventInfo.description = pkg1;
788 mgr->HandleGamesEvent(0, eventInfo);
789 mgr->HandleGamesEvent(1, eventInfo);
790 mgr->HandleIdleEvent(true);
791 mgr->HandleIdleEvent(false);
792 auto screenSetting = mgr->multiAppStrategy_.GetScreenSetting();
793 screenSetting.sceneList.insert(make_pair(testScene, PolicyConfigData::SceneConfig{ "1", "1" }));
794 screenSetting.gameSceneList.insert(make_pair(testScene, "1"));
795 screenSetting.ancoSceneList.insert(make_pair(testScene, PolicyConfigData::SceneConfig{ "1", "1" }));
796 mgr->multiAppStrategy_.SetScreenSetting(screenSetting);
797 EventInfo eventInfo2 = { .eventName = "VOTER_SCENE", .eventStatus = true, .description = testScene };
798 mgr->HandleRefreshRateEvent(0, eventInfo2);
799 eventInfo2.eventStatus = false;
800 mgr->HandleRefreshRateEvent(0, eventInfo2);
801
802 std::swap(hgm.mPolicyConfigData_, cachedPolicyConfigData);
803 EXPECT_NE(hgm.mPolicyConfigData_, nullptr);
804 eventInfo2.eventName = "VOTER_VIDEO_CALL";
805 mgr->HandleRefreshRateEvent(0, eventInfo2);
806 eventInfo2.eventName = "VOTER_VIRTUALDISPLAY";
807 mgr->HandleRefreshRateEvent(0, eventInfo2);
808 eventInfo2.eventName = "VOTER_MULTISELFOWNEDSCREEN";
809 mgr->HandleRefreshRateEvent(0, eventInfo2);
810 }
811
812 /**
813 * @tc.name: ProcessRefreshRateVoteTest
814 * @tc.desc: Verify the result of ProcessRefreshRateVoteTest
815 * @tc.type: FUNC
816 * @tc.require:
817 */
818 HWTEST_F(HgmFrameRateMgrTest, ProcessRefreshRateVoteTest, Function | SmallTest | Level0)
819 {
820 HgmFrameRateManager mgr;
821 VoteInfo resultVoteInfo;
822 VoteRange voteRange = { OLED_MIN_HZ, OLED_MAX_HZ };
823 bool voterGamesEffective = false;
824 auto voterIter = std::find(mgr.frameVoter_.voters_.begin(), mgr.frameVoter_.voters_.end(), "VOTER_GAMES");
825 mgr.frameVoter_.ProcessVoteIter(voterIter, resultVoteInfo, voteRange, voterGamesEffective);
826 mgr.DeliverRefreshRateVote({ "VOTER_GAMES", OLED_120_HZ, OLED_90_HZ, OLED_NULL_HZ }, true);
827 mgr.DeliverRefreshRateVote({ "VOTER_THERMAL", OLED_120_HZ, OLED_90_HZ, OLED_NULL_HZ }, true);
828 mgr.DeliverRefreshRateVote({ "VOTER_MULTISELFOWNEDSCREEN", OLED_120_HZ, OLED_90_HZ, OLED_NULL_HZ }, true);
829 auto screenSetting = mgr.multiAppStrategy_.GetScreenSetting();
830 screenSetting.sceneList.insert(make_pair(testScene, PolicyConfigData::SceneConfig{ "1", "1" }));
831 screenSetting.gameSceneList.insert(make_pair(testScene, "1"));
832 screenSetting.ancoSceneList.insert(make_pair(testScene, PolicyConfigData::SceneConfig{ "1", "1" }));
833 mgr.multiAppStrategy_.SetScreenSetting(screenSetting);
834 EventInfo eventInfo2 = { .eventName = "VOTER_SCENE", .eventStatus = true, .description = testScene };
835 mgr.HandleRefreshRateEvent(0, eventInfo2);
836 mgr.DeliverRefreshRateVote({ "VOTER_ANCO", OLED_120_HZ, OLED_90_HZ, OLED_60_HZ }, true);
837 auto resVoteInfo = mgr.ProcessRefreshRateVote();
838 EXPECT_EQ(resVoteInfo.min, OLED_MIN_HZ);
839 mgr.frameVoter_.voters_.push_back("VOTER_ANCO");
840 auto voterIter1 = std::find(mgr.frameVoter_.voters_.begin(), mgr.frameVoter_.voters_.end(), "VOTER_ANCO");
841 EXPECT_FALSE(mgr.frameVoter_.ProcessVoteIter(voterIter1, resultVoteInfo, voteRange, voterGamesEffective));
842 mgr.frameVoter_.voters_.push_back("VOTER_VIDEO");
843 voterIter1 = std::find(mgr.frameVoter_.voters_.begin(), mgr.frameVoter_.voters_.end(), "VOTER_VIDEO");
844 EXPECT_FALSE(mgr.frameVoter_.ProcessVoteIter(voterIter1, resultVoteInfo, voteRange, voterGamesEffective));
845 }
846
847 /**
848 * @tc.name: ProcessRefreshRateVoteTest2
849 * @tc.desc: Verify the result of ProcessRefreshRateVote when idle 30 enabled
850 * @tc.type: FUNC
851 * @tc.require:
852 */
853 HWTEST_F(HgmFrameRateMgrTest, ProcessRefreshRateVoteTest2, Function | SmallTest | Level0)
854 {
855 HgmFrameRateManager frameRateMgr;
856 VoteRange voteRange = { OLED_MIN_HZ, OLED_MAX_HZ };
857 frameRateMgr.DeliverRefreshRateVote({ "VOTER_PACKAGES", OLED_60_HZ, OLED_120_HZ, 0 }, true);
858 frameRateMgr.DeliverRefreshRateVote({ "VOTER_LTPO", OLED_120_HZ, OLED_120_HZ, 0 }, true);
859 frameRateMgr.DeliverRefreshRateVote({ "VOTER_IDLE", OLED_30_HZ, OLED_30_HZ, 0 }, true);
860 auto resVoteInfo = frameRateMgr.ProcessRefreshRateVote();
861 EXPECT_EQ(resVoteInfo.min, OLED_120_HZ);
862 frameRateMgr.DeliverRefreshRateVote({ "VOTER_LTPO", OLED_120_HZ, OLED_120_HZ, 0 }, false);
863 frameRateMgr.DeliverRefreshRateVote({ "VOTER_LTPO", OLED_60_HZ, OLED_60_HZ, 0 }, true);
864 resVoteInfo = frameRateMgr.ProcessRefreshRateVote();
865 EXPECT_EQ(resVoteInfo.min, OLED_60_HZ);
866 EXPECT_EQ(resVoteInfo.max, OLED_60_HZ);
867 frameRateMgr.DeliverRefreshRateVote({ "VOTER_LTPO", OLED_60_HZ, OLED_60_HZ, 0 }, false);
868 resVoteInfo = frameRateMgr.ProcessRefreshRateVote();
869 EXPECT_EQ(resVoteInfo.min, OLED_60_HZ);
870 EXPECT_EQ(resVoteInfo.max, OLED_60_HZ);
871 frameRateMgr.DeliverRefreshRateVote({ "VOTER_PACKAGES", OLED_60_HZ, OLED_120_HZ, 0 }, false);
872 frameRateMgr.DeliverRefreshRateVote({ "VOTER_PACKAGES", OLED_30_HZ, OLED_120_HZ, 0 }, true);
873 resVoteInfo = frameRateMgr.ProcessRefreshRateVote();
874 EXPECT_EQ(resVoteInfo.max, OLED_30_HZ);
875 frameRateMgr.controller_ = std::make_shared<HgmVSyncGeneratorController>(nullptr, nullptr, nullptr);
876 resVoteInfo = frameRateMgr.ProcessRefreshRateVote();
877 sleep(1); // wait for handler task finished
878 }
879
880 /**
881 * @tc.name: SetAceAnimatorVoteTest
882 * @tc.desc: Verify the result of SetAceAnimatorVoteTest
883 * @tc.type: FUNC
884 * @tc.require:
885 */
886 HWTEST_F(HgmFrameRateMgrTest, SetAceAnimatorVoteTest, Function | SmallTest | Level0)
887 {
888 HgmFrameRateManager frameRateMgr;
889 frameRateMgr.SetAceAnimatorVote(nullptr);
890 std::shared_ptr<RSRenderFrameRateLinker> linker = std::make_shared<RSRenderFrameRateLinker>();
891 ASSERT_NE(linker, nullptr);
892 frameRateMgr.SetAceAnimatorVote(linker);
893 linker->SetAnimatorExpectedFrameRate(OLED_60_HZ);
894 frameRateMgr.SetAceAnimatorVote(linker);
895 }
896
897 /**
898 * @tc.name: HgmSimpleTimerTest
899 * @tc.desc: Verify the result of HgmSimpleTimerTest
900 * @tc.type: FUNC
901 * @tc.require:
902 */
903 HWTEST_F(HgmFrameRateMgrTest, HgmSimpleTimerTest, Function | SmallTest | Level0)
904 {
905 auto timer = HgmSimpleTimer("HgmSimpleTimer", std::chrono::milliseconds(delay_60Ms), nullptr, nullptr);
906 ASSERT_EQ(timer.name_, "HgmSimpleTimer");
907 ASSERT_EQ(timer.interval_.load(), std::chrono::milliseconds(delay_60Ms));
908 ASSERT_EQ(timer.startCallback_, nullptr);
909 ASSERT_EQ(timer.expiredCallback_, nullptr);
910 timer.Start();
911 timer.Reset();
912 timer.Stop();
913 sleep(1); // wait for timer stop
914 }
915
916 /**
917 * @tc.name: FrameRateReportTest
918 * @tc.desc: Verify the result of FrameRateReportTest
919 * @tc.type: FUNC
920 * @tc.require:
921 */
922 HWTEST_F(HgmFrameRateMgrTest, FrameRateReportTest, Function | SmallTest | Level0)
923 {
924 HgmFrameRateManager mgr;
925 mgr.FrameRateReport();
926 mgr.curRefreshRateMode_ = HGM_REFRESHRATE_MODE_HIGH;
927 mgr.FrameRateReport();
928 EXPECT_EQ(mgr.schedulePreferredFpsChange_, false);
929 mgr.schedulePreferredFps_ = OLED_60_HZ;
930 mgr.currRefreshRate_ = OLED_60_HZ;
931 mgr.FrameRateReport();
932 mgr.currRefreshRate_ = OLED_90_HZ;
933 mgr.FrameRateReport();
934 mgr.curRefreshRateMode_ = 0;
935 mgr.schedulePreferredFps_ = 0;
936 mgr.schedulePreferredFpsChange_ = true;
937 mgr.FrameRateReport();
938 EXPECT_EQ(mgr.schedulePreferredFpsChange_, false);
939 }
940
941 /**
942 * @tc.name: HandleFrameRateChangeForLTPO
943 * @tc.desc: Verify the result of HandleFrameRateChangeForLTPO
944 * @tc.type: FUNC
945 * @tc.require:
946 */
947 HWTEST_F(HgmFrameRateMgrTest, HandleFrameRateChangeForLTPO, Function | SmallTest | Level0)
948 {
949 auto& hgmCore = HgmCore::Instance();
950 auto frameRateMgr = std::make_unique<HgmFrameRateManager>();
951 hgmCore.SetPendingScreenRefreshRate(OLED_30_HZ);
952 frameRateMgr->currRefreshRate_ = OLED_120_HZ;
953 hgmCore.lowRateToHighQuickSwitch_.store(false);
954 frameRateMgr->HandleFrameRateChangeForLTPO(0, false, true);
955 hgmCore.lowRateToHighQuickSwitch_.store(true);
956 frameRateMgr->HandleFrameRateChangeForLTPO(0, false, true);
957 frameRateMgr->forceUpdateCallback_ = nullptr;
958 frameRateMgr->HandleFrameRateChangeForLTPO(0, false, true);
__anon09d8ed1d0602(bool idleTimerExpired, bool forceUpdate) 959 frameRateMgr->forceUpdateCallback_ = [](bool idleTimerExpired, bool forceUpdate) { return; };
960 frameRateMgr->HandleFrameRateChangeForLTPO(0, false, true);
961 EXPECT_EQ(frameRateMgr->GetPreferredFps("aaa", errorVelocity, 0, 0), 0);
962 hgmCore.lowRateToHighQuickSwitch_.store(true);
963 VSyncController* rsController;
964 VSyncController* appController;
965 VSyncGenerator* vsyncGenerator;
966 frameRateMgr->controller_ = std::make_shared<HgmVSyncGeneratorController>(rsController,
967 appController, vsyncGenerator);
968 frameRateMgr->HandleFrameRateChangeForLTPO(0, false, true);
969 sleep(1);
970 }
971
972 /**
973 * @tc.name: DVSyncTaskProcess
974 * @tc.desc: Verify the result of DVSyncTaskProcess
975 * @tc.type: FUNC
976 * @tc.require: issueIBX8OW
977 */
978 HWTEST_F(HgmFrameRateMgrTest, DVSyncTaskProcessor, Function | SmallTest | Level0)
979 {
980 auto& hgmCore = HgmCore::Instance();
981 auto frameRateMgr = std::make_unique<HgmFrameRateManager>();
982 hgmCore.SetPendingScreenRefreshRate(OLED_144_HZ);
983 auto lastRefreshRate = hgmCore.GetPendingScreenRefreshRate();
984 frameRateMgr->currRefreshRate_ = OLED_120_HZ;
985 VSyncController* rsController = nullptr;
986 VSyncController* appController = nullptr;
987 VSyncGenerator* vsyncGenerator = nullptr;
988 frameRateMgr->controller_ = std::make_shared<HgmVSyncGeneratorController>(rsController,
989 appController, vsyncGenerator);
990 ASSERT_NE(frameRateMgr->controller_, nullptr);
991 int64_t delayTime = 10;
992 uint64_t targetTime = 0;
993 std::vector<std::pair<FrameRateLinkerId, uint32_t>> appChangeData;
994 frameRateMgr->DVSyncTaskProcessor(delayTime, targetTime, appChangeData, OLED_30_HZ);
995 sleep(1);
996 }
997
998 /**
999 * @tc.name: GetLowBrightVec
1000 * @tc.desc: Verify the result of GetLowBrightVec
1001 * @tc.type: FUNC
1002 * @tc.require:
1003 */
1004 HWTEST_F(HgmFrameRateMgrTest, GetLowBrightVec, Function | SmallTest | Level0)
1005 {
1006 HgmFrameRateManager mgr;
1007 std::shared_ptr<PolicyConfigData> configData = std::make_shared<PolicyConfigData>();
1008
1009 std::vector<std::string> screenConfigs = {"LTPO-DEFAULT", "LTPO-internal", "LTPO-external"};
1010 PolicyConfigData::SupportedModeConfig supportedMode = {{ "LowBright", {} }};
1011 PolicyConfigData::SupportedModeConfig supportedMode1 = {{ "LowBright", { OLED_30_HZ, OLED_60_HZ, OLED_120_HZ } }};
1012 PolicyConfigData::SupportedModeConfig supportedMode2 = {{ "LowBright", { OLED_MIN_HZ } }};
1013 for (const auto& screenConfig : screenConfigs) {
1014 if (configData->screenStrategyConfigs_.find(screenConfig) == configData->screenStrategyConfigs_.end()) {
1015 continue;
1016 }
1017 configData->supportedModeConfigs_[screenConfig] = supportedMode;
1018 mgr.GetLowBrightVec(configData);
1019 ASSERT_EQ(mgr.isAmbientEffect_, false);
1020 ASSERT_TRUE(mgr.lowBrightVec_.empty());
1021
1022 configData->supportedModeConfigs_[screenConfig].clear();
1023 configData->supportedModeConfigs_[screenConfig] = supportedMode1;
1024 mgr.GetLowBrightVec(configData);
1025 ASSERT_EQ(mgr.isAmbientEffect_, true);
1026 ASSERT_TRUE(!mgr.lowBrightVec_.empty());
1027
1028 configData->supportedModeConfigs_[screenConfig].clear();
1029 configData->supportedModeConfigs_[screenConfig] = supportedMode2;
1030 mgr.GetLowBrightVec(configData);
1031 ASSERT_EQ(mgr.isAmbientEffect_, false);
1032 ASSERT_TRUE(mgr.lowBrightVec_.empty());
1033 }
1034 }
1035
1036 /**
1037 * @tc.name: GetAncoLowBrightVec
1038 * @tc.desc: Verify the result of GetAncoLowBrightVec
1039 * @tc.type: FUNC
1040 * @tc.require:
1041 */
1042 HWTEST_F(HgmFrameRateMgrTest, GetAncoLowBrightVec, Function | SmallTest | Level0)
1043 {
1044 HgmFrameRateManager mgr;
1045 std::shared_ptr<PolicyConfigData> configData = std::make_shared<PolicyConfigData>();
1046
1047 std::vector<std::string> screenConfigs = { "LTPO-DEFAULT", "LTPO-internal", "LTPO-external" };
1048 PolicyConfigData::SupportedModeConfig supportedMode = {{ "AncoLowBright", {} }};
1049 PolicyConfigData::SupportedModeConfig supportedMode1 = {{ "AncoLowBright", { OLED_90_HZ } }};
1050 for (const auto& screenConfig : screenConfigs) {
1051 if (configData->screenStrategyConfigs_.find(screenConfig) == configData->screenStrategyConfigs_.end()) {
1052 continue;
1053 }
1054 configData->supportedModeConfigs_[screenConfig] = supportedMode;
1055 mgr.GetAncoLowBrightVec(configData);
1056 ASSERT_TRUE(mgr.ancoLowBrightVec_.empty());
1057
1058 configData->supportedModeConfigs_[screenConfig].clear();
1059 configData->supportedModeConfigs_[screenConfig] = supportedMode1;
1060 mgr.GetAncoLowBrightVec(configData);
1061 ASSERT_TRUE(!mgr.ancoLowBrightVec_.empty());
1062 }
1063 }
1064
1065 /**
1066 * @tc.name: CheckAncoVoterStatus
1067 * @tc.desc: Verify the result of CheckAncoVoterStatus
1068 * @tc.type: FUNC
1069 * @tc.require:
1070 */
1071 HWTEST_F(HgmFrameRateMgrTest, CheckAncoVoterStatus, Function | SmallTest | Level0)
1072 {
1073 HgmFrameRateManager mgr;
1074 struct AncoVoterStatusTestParams {
1075 LightFactorStatus ambientStatus;
1076 bool isLtpo;
1077 bool isAmbientEffect;
1078 std::vector<uint32_t> ancoLowBrightVec;
1079 std::string voteRecordKey;
1080 std::vector<VoteInfo> voteRecordFirst;
1081 bool voteRecordSecond;
1082 };
1083
__anon09d8ed1d0702(AncoVoterStatusTestParams params, bool expected) 1084 auto testParams = [&mgr](AncoVoterStatusTestParams params, bool expected) {
1085 mgr.isAmbientStatus_ = params.ambientStatus;
1086 mgr.isLtpo_ = params.isLtpo;
1087 mgr.isAmbientEffect_ = params.isAmbientEffect;
1088 mgr.ancoLowBrightVec_ = params.ancoLowBrightVec;
1089 mgr.frameVoter_.voteRecord_[params.voteRecordKey] =
1090 std::make_pair(params.voteRecordFirst, params.voteRecordSecond);
1091 EXPECT_EQ(mgr.CheckAncoVoterStatus(), expected);
1092 mgr.frameVoter_.voteRecord_.clear();
1093 };
1094
1095 testParams({LightFactorStatus::NORMAL_LOW, true, true, {OLED_90_HZ},
1096 "VOTER_ANCO", {{ .voterName = "VOTER_ANCO" }}, true}, true);
1097 testParams({LightFactorStatus::NORMAL_HIGH, true, true, {OLED_90_HZ},
1098 "VOTER_ANCO", {{ .voterName = "VOTER_ANCO" }}, true}, false);
1099 testParams({LightFactorStatus::NORMAL_LOW, false, true, {OLED_90_HZ},
1100 "VOTER_ANCO", {{ .voterName = "VOTER_ANCO" }}, true}, false);
1101 testParams({LightFactorStatus::NORMAL_LOW, true, false, {OLED_90_HZ},
1102 "VOTER_ANCO", {{ .voterName = "VOTER_ANCO" }}, true}, false);
1103 testParams({LightFactorStatus::NORMAL_LOW, true, true, {},
1104 "VOTER_ANCO", {{ .voterName = "VOTER_ANCO" }}, true}, false);
1105 testParams({LightFactorStatus::NORMAL_LOW, true, true, {OLED_90_HZ},
1106 "VOTER_LTPO", {{ .voterName = "VOTER_LTPO" }}, true}, false);
1107 testParams({LightFactorStatus::NORMAL_LOW, true, true, {OLED_90_HZ},
1108 "VOTER_ANCO", {}, true}, false);
1109 testParams({LightFactorStatus::NORMAL_LOW, true, true, {OLED_90_HZ},
1110 "VOTER_ANCO", {{ .voterName = "VOTER_ANCO" }}, false}, false);
1111 }
1112
1113 /**
1114 * @tc.name: SetTimeoutParamsFromConfig
1115 * @tc.desc: Verify the result of SetTimeoutParamsFromConfig
1116 * @tc.type: FUNC
1117 * @tc.require:
1118 */
1119 HWTEST_F(HgmFrameRateMgrTest, SetTimeoutParamsFromConfig, Function | SmallTest | Level0)
1120 {
1121 HgmFrameRateManager mgr;
1122 std::shared_ptr<PolicyConfigData> configData = std::make_shared<PolicyConfigData>();
1123
1124 auto time1 = mgr.touchManager_.upTimeoutTimer_.interval_.load();
1125 auto time2 = mgr.touchManager_.rsIdleTimeoutTimer_.interval_.load();
1126 ASSERT_EQ(time1, std::chrono::milliseconds(3000));
1127 ASSERT_EQ(time2, std::chrono::milliseconds(600));
1128
1129 int32_t upTimeoutMs = 2000;
1130 int32_t rsIdleTimeoutMs = 300;
1131 configData->timeoutStrategyConfig_["up_timeout_ms"] = "2000";
1132 configData->timeoutStrategyConfig_["rs_idle_timeout_ms"] = "300";
1133
1134 mgr.SetTimeoutParamsFromConfig(configData);
1135 auto time3 = mgr.touchManager_.upTimeoutTimer_.interval_.load();
1136 auto time4 = mgr.touchManager_.rsIdleTimeoutTimer_.interval_.load();
1137 ASSERT_EQ(time3, std::chrono::milliseconds(upTimeoutMs));
1138 ASSERT_EQ(time4, std::chrono::milliseconds(rsIdleTimeoutMs));
1139 }
1140
1141 /**
1142 * @tc.name: GetStylusVec
1143 * @tc.desc: Verify the result of GetStylusVec
1144 * @tc.type: FUNC
1145 * @tc.require:
1146 */
1147 HWTEST_F(HgmFrameRateMgrTest, GetStylusVec, Function | SmallTest | Level0)
1148 {
1149 HgmFrameRateManager mgr;
1150 std::shared_ptr<PolicyConfigData> configData = std::make_shared<PolicyConfigData>();
1151 PolicyConfigData::SupportedModeConfig supportedMode = {{ "test", { OLED_60_HZ, OLED_120_HZ } }};
1152 PolicyConfigData::SupportedModeConfig supportedMode1 = {{ "StylusPen", { OLED_60_HZ, OLED_120_HZ } }};
1153 configData->supportedModeConfigs_["LTPO-DEFAULT"] = supportedMode;
1154 configData->supportedModeConfigs_["LTPS-DEFAULT"] = supportedMode1;
1155
1156 std::vector<std::string> screenConfigs = { "LTPO-DEFAULT", "LTPS-DEFAULT" };
1157 for (const auto& screenConfig : screenConfigs) {
1158 mgr.curScreenStrategyId_ = screenConfig;
1159
1160 auto iter = configData->supportedModeConfigs_.find(screenConfig);
1161 if (iter == configData-> supportedModeConfigs_.end()) {
1162 continue;
1163 }
1164
1165 auto& supportedModeConfig = iter->second;
1166 auto it = supportedModeConfig.find("StylusPen");
1167 if (it == supportedModeConfig.end()) {
1168 continue;
1169 }
1170
1171 supportedModeConfig["StylusPen"].clear();
1172 mgr.GetStylusVec(configData);
1173 ASSERT_TRUE(mgr.stylusVec_.empty());
1174
1175 std::vector<uint32_t> expectedVec = { OLED_60_HZ, OLED_120_HZ };
1176 supportedModeConfig["StylusPen"] = expectedVec;
1177 ASSERT_NO_FATAL_FAILURE({mgr.GetStylusVec(configData);});
1178 }
1179 }
1180
1181 /**
1182 * @tc.name: HandleScreenPowerStatus
1183 * @tc.desc: Verify the result of HandleScreenPowerStatus
1184 * @tc.type: FUNC
1185 * @tc.require:
1186 */
1187 HWTEST_F(HgmFrameRateMgrTest, HandleScreenPowerStatus, Function | SmallTest | Level0)
1188 {
1189 ScreenId extraScreenId = 1;
1190 auto& hgmCore = HgmCore::Instance();
1191 auto frameRateMgr = hgmCore.GetFrameRateMgr();
1192 auto configData = hgmCore.GetPolicyConfigData();
1193 if (configData == nullptr || frameRateMgr == nullptr) {
1194 return;
1195 }
1196 // init
1197 configData->screenStrategyConfigs_["screen0_LTPS"] = "LTPS-DEFAULT";
1198 configData->screenStrategyConfigs_["screen0_LTPO"] = "LTPO-DEFAULT";
1199 configData->screenStrategyConfigs_["screen5_LTPS"] = "LTPS-DEFAULT";
1200 configData->screenStrategyConfigs_["screen5_LTPO"] = "LTPO-DEFAULT";
1201 EXPECT_EQ(hgmCore.AddScreen(externalScreenId, 0, screenSize), EXEC_SUCCESS);
1202 EXPECT_EQ(hgmCore.AddScreen(internalScreenId, 0, screenSize), EXEC_SUCCESS);
1203
1204 // fold -> expand -> fold
1205 frameRateMgr->curScreenStrategyId_.clear();
1206 frameRateMgr->HandleScreenPowerStatus(internalScreenId, ScreenPowerStatus::POWER_STATUS_SUSPEND);
1207 frameRateMgr->HandleScreenPowerStatus(externalScreenId, ScreenPowerStatus::POWER_STATUS_ON);
1208 EXPECT_EQ(frameRateMgr->curScreenId_, externalScreenId);
1209 EXPECT_EQ(hgmCore.AddScreen(extraScreenId, 0, screenSize), EXEC_SUCCESS);
1210 EXPECT_EQ(frameRateMgr->curScreenId_, externalScreenId);
1211 EXPECT_EQ(hgmCore.RemoveScreen(extraScreenId), EXEC_SUCCESS);
1212 EXPECT_EQ(frameRateMgr->curScreenId_, externalScreenId);
1213
1214 EXPECT_EQ(hgmCore.AddScreen(extraScreenId, 0, screenSize), EXEC_SUCCESS);
1215 frameRateMgr->HandleScreenPowerStatus(externalScreenId, ScreenPowerStatus::POWER_STATUS_SUSPEND);
1216 frameRateMgr->HandleScreenPowerStatus(internalScreenId, ScreenPowerStatus::POWER_STATUS_ON);
1217 EXPECT_EQ(frameRateMgr->curScreenId_, internalScreenId);
1218 EXPECT_EQ(hgmCore.RemoveScreen(extraScreenId), EXEC_SUCCESS);
1219 EXPECT_EQ(frameRateMgr->curScreenId_, internalScreenId);
1220
1221 EXPECT_EQ(hgmCore.AddScreen(extraScreenId, 0, screenSize), EXEC_SUCCESS);
1222 EXPECT_EQ(frameRateMgr->curScreenId_, internalScreenId);
1223 EXPECT_EQ(hgmCore.RemoveScreen(extraScreenId), EXEC_SUCCESS);
1224
1225 EXPECT_EQ(hgmCore.AddScreen(extraScreenId, 0, screenSize), EXEC_SUCCESS);
1226 frameRateMgr->HandleScreenPowerStatus(internalScreenId, ScreenPowerStatus::POWER_STATUS_SUSPEND);
1227 frameRateMgr->HandleScreenPowerStatus(externalScreenId, ScreenPowerStatus::POWER_STATUS_ON);
1228 EXPECT_EQ(frameRateMgr->curScreenId_, externalScreenId);
1229 EXPECT_EQ(hgmCore.RemoveScreen(extraScreenId), EXEC_SUCCESS);
1230 EXPECT_EQ(frameRateMgr->curScreenId_, externalScreenId);
1231
1232 // expand -> multiScreen -> expand
1233 frameRateMgr->HandleScreenPowerStatus(externalScreenId, ScreenPowerStatus::POWER_STATUS_SUSPEND);
1234 frameRateMgr->HandleScreenPowerStatus(internalScreenId, ScreenPowerStatus::POWER_STATUS_ON);
1235 EXPECT_EQ(frameRateMgr->curScreenId_, internalScreenId);
1236
1237 hgmCore.SetMultiSelfOwnedScreenEnable(true);
1238 frameRateMgr->HandleScreenPowerStatus(externalScreenId, ScreenPowerStatus::POWER_STATUS_ON);
1239 EXPECT_EQ(frameRateMgr->curScreenId_, internalScreenId);
1240
1241 hgmCore.SetMultiSelfOwnedScreenEnable(false);
1242 frameRateMgr->HandleScreenPowerStatus(externalScreenId, ScreenPowerStatus::POWER_STATUS_SUSPEND);
1243 EXPECT_EQ(frameRateMgr->curScreenId_, internalScreenId);
1244 }
1245
1246 /**
1247 * @tc.name: NotifyScreenRectFrameRateChange
1248 * @tc.desc: Verify the result of NotifyScreenRectFrameRateChange
1249 * @tc.type: FUNC
1250 * @tc.require:
1251 */
1252 HWTEST_F(HgmFrameRateMgrTest, NotifyScreenRectFrameRateChange, Function | SmallTest | Level0)
1253 {
1254 auto& hgmCore = HgmCore::Instance();
1255 Rect activeRect;
1256 ScreenId id = 0;
1257 GraphicIRect dstActiveRect {
1258 .x = activeRect.x,
1259 .y = activeRect.y,
1260 .w = activeRect.w,
1261 .h = activeRect.h,
1262 };
1263 hgmCore.NotifyScreenRectFrameRateChange(id, dstActiveRect);
1264 EXPECT_NE(hgmCore.hgmFrameRateMgr_, nullptr);
1265 }
1266
1267 /**
1268 * @tc.name: HandleScreenExtStrategyChange
1269 * @tc.desc: Verify the result of HandleScreenExtStrategyChange
1270 * @tc.type: FUNC
1271 * @tc.require:
1272 */
1273 HWTEST_F(HgmFrameRateMgrTest, HandleScreenExtStrategyChange, Function | SmallTest | Level0)
1274 {
1275 auto& hgmCore = HgmCore::Instance();
1276 auto frameRateMgr = hgmCore.GetFrameRateMgr();
1277 if (frameRateMgr == nullptr || hgmCore.mPolicyConfigData_ == nullptr) {
1278 return;
1279 }
1280 frameRateMgr->HandleScreenExtStrategyChange(true, "_THERMAL");
1281 frameRateMgr->HandleScreenExtStrategyChange(false, "test");
1282 EXPECT_NE(frameRateMgr, nullptr);
1283 }
1284
1285 /**
1286 * @tc.name: HandlePackageEvent
1287 * @tc.desc: Verify the result of HandlePackageEvent
1288 * @tc.type: FUNC
1289 * @tc.require:
1290 */
1291 HWTEST_F(HgmFrameRateMgrTest, HandlePackageEvent, Function | SmallTest | Level0)
1292 {
1293 auto& hgmCore = HgmCore::Instance();
1294 auto frameRateMgr = hgmCore.GetFrameRateMgr();
1295 if (frameRateMgr == nullptr) {
1296 return;
1297 }
1298 std::string pkgName0 = "com.pkg0";
1299 std::string pkgName1 = "com.pkg1";
1300 std::string scene0 = "SCENE0";
1301 std::string scene1 = "SCENE1";
1302 std::string scene2 = "SCENE2";
1303
1304 auto sceneListConfig = frameRateMgr->GetMultiAppStrategy().GetScreenSetting();
1305 sceneListConfig.sceneList[scene0] = { "1", "1", false };
1306 sceneListConfig.sceneList[scene1] = { "1", "1", true };
1307
1308 frameRateMgr->GetMultiAppStrategy().SetScreenSetting(sceneListConfig);
1309
1310 frameRateMgr->HandleSceneEvent(DEFAULT_PID, { "VOTER_SCENE", true, OLED_NULL_HZ, OLED_MAX_HZ, scene0 });
1311 frameRateMgr->HandlePackageEvent(DEFAULT_PID, {pkgName0});
1312 // multi scene
1313 frameRateMgr->HandleSceneEvent(DEFAULT_PID, { "VOTER_SCENE", true, OLED_NULL_HZ, OLED_MAX_HZ, scene0 });
1314 frameRateMgr->HandleSceneEvent(DEFAULT_PID, { "VOTER_SCENE", true, OLED_NULL_HZ, OLED_MAX_HZ, scene1 });
1315 frameRateMgr->HandlePackageEvent(DEFAULT_PID, { pkgName1 });
1316 frameRateMgr->currRefreshRate_ = OLED_30_HZ;
1317 FrameRateRange finalRange = { OLED_60_HZ, OLED_120_HZ, OLED_60_HZ };
1318 EXPECT_EQ(frameRateMgr->CalcRefreshRate(frameRateMgr->curScreenId_.load(), finalRange),
1319 frameRateMgr->currRefreshRate_);
1320 frameRateMgr->isStylusWakeUp_ = true;
1321 frameRateMgr->stylusVec_.clear();
1322 ASSERT_EQ(frameRateMgr->CalcRefreshRate(frameRateMgr->curScreenId_.load(), finalRange),
1323 frameRateMgr->currRefreshRate_);
1324 }
1325
1326 /**
1327 * @tc.name: UpdateFrameRateWithDelay
1328 * @tc.desc: Verify the result of UpdateFrameRateWithDelay
1329 * @tc.type: FUNC
1330 * @tc.require:
1331 */
1332 HWTEST_F(HgmFrameRateMgrTest, UpdateFrameRateWithDelay, Function | SmallTest | Level0)
1333 {
1334 auto& hgmCore = HgmCore::Instance();
1335 auto frameRateMgr = hgmCore.GetFrameRateMgr();
1336 if (frameRateMgr == nullptr) {
1337 return;
1338 }
1339
1340 frameRateMgr->frameVoter_.isDragScene_ = false;
1341 ASSERT_EQ(frameRateMgr->UpdateFrameRateWithDelay(120), 120);
1342 ASSERT_EQ(frameRateMgr->UpdateFrameRateWithDelay(72), 72);
1343
1344 frameRateMgr->frameVoter_.isDragScene_ = true;
1345 ASSERT_EQ(frameRateMgr->UpdateFrameRateWithDelay(120), 120);
1346
1347 std::this_thread::sleep_for(std::chrono::seconds(1));
1348 ASSERT_EQ(frameRateMgr->UpdateFrameRateWithDelay(72), 72);
1349 }
1350
1351 /**
1352 * @tc.name: HandleDynamicModeEvent
1353 * @tc.desc: Verify the result of HandleDynamicModeEvent
1354 * @tc.type: FUNC
1355 * @tc.require:
1356 */
1357 HWTEST_F(HgmFrameRateMgrTest, HandleDynamicModeEvent, Function | SmallTest | Level0)
1358 {
1359 auto& hgmCore = HgmCore::Instance();
1360 auto frameRateMgr = hgmCore.GetFrameRateMgr();
1361 if (frameRateMgr == nullptr) {
1362 return;
1363 }
1364 frameRateMgr->HandleDynamicModeEvent(true);
1365 EXPECT_EQ(hgmCore.enableDynamicMode_, true);
1366 }
1367
1368 /**
1369 * @tc.name: ProcessPageUrlVote
1370 * @tc.desc: Verify the result of ProcessPageUrlVote
1371 * @tc.type: FUNC
1372 * @tc.require:
1373 */
1374 HWTEST_F(HgmFrameRateMgrTest, ProcessPageUrlVote, Function | SmallTest | Level0)
1375 {
1376 auto frameRateMgr = HgmCore::Instance().GetFrameRateMgr();
1377 pid_t pid = 0;
1378 std::string strategy = "";
1379 bool isAddVote = true;
1380 std::string packageName = "";
1381 std::string pageName = "";
1382 bool isEnter = true;
1383 frameRateMgr->ProcessPageUrlVote(pid, strategy, isAddVote);
1384 frameRateMgr->CleanPageUrlVote(pid);
1385 frameRateMgr->NotifyPageName(pid, packageName, pageName, isEnter);
1386 EXPECT_EQ(frameRateMgr->appPageUrlStrategy_.pageUrlConfig_,
1387 frameRateMgr->multiAppStrategy_.screenSettingCache_.pageUrlConfig);
1388 }
1389
1390 /**
1391 * @tc.name: TestCheckNeedUpdateAppOffset
1392 * @tc.desc: Verify the result of CheckNeedUpdateAppOffset
1393 * @tc.type: FUNC
1394 * @tc.require:
1395 */
1396 HWTEST_F(HgmFrameRateMgrTest, TestCheckNeedUpdateAppOffset, Function | SmallTest | Level0)
1397 {
1398 HgmFrameRateManager mgr;
1399 mgr.isNeedUpdateAppOffset_ = false;
1400 mgr.touchManager_.state_.store(TouchState::DOWN_STATE);
1401 mgr.controller_ = std::make_shared<HgmVSyncGeneratorController>(nullptr, nullptr, nullptr);
1402 mgr.CheckNeedUpdateAppOffset(OLED_60_HZ, OLED_60_HZ);
1403 mgr.DeliverRefreshRateVote({ "VOTER_THERMAL", OLED_60_HZ, OLED_60_HZ, DEFAULT_PID }, true);
1404 mgr.CheckNeedUpdateAppOffset(OLED_60_HZ, OLED_60_HZ);
1405 EXPECT_EQ(mgr.isNeedUpdateAppOffset_, true);
1406 }
1407
1408 /**
1409 * @tc.name: TestCheckForceUpdateCallback
1410 * @tc.desc: Verify the result of CheckForceUpdateCallback
1411 * @tc.type: FUNC
1412 * @tc.require:
1413 */
1414 HWTEST_F(HgmFrameRateMgrTest, TestCheckForceUpdateCallback, Function | SmallTest | Level0)
1415 {
1416 HgmFrameRateManager mgr;
1417 mgr.InitTouchManager();
1418 mgr.needForceUpdateUniRender_ = true;
1419 mgr.currRefreshRate_.store(OLED_120_HZ);
1420 mgr.CheckForceUpdateCallback(OLED_60_HZ);
1421 EXPECT_EQ(mgr.needForceUpdateUniRender_, true);
1422
__anon09d8ed1d0802(bool idleTimerExpired, bool forceUpdate) 1423 mgr.forceUpdateCallback_ = [](bool idleTimerExpired, bool forceUpdate) {};
1424 mgr.CheckForceUpdateCallback(OLED_60_HZ);
1425 mgr.CheckForceUpdateCallback(OLED_120_HZ);
1426
1427 mgr.touchManager_.ChangeState(TouchState::DOWN_STATE);
1428 EXPECT_EQ(mgr.needForceUpdateUniRender_, false);
1429 mgr.CheckForceUpdateCallback(OLED_120_HZ);
1430 mgr.touchManager_.ChangeState(TouchState::UP_STATE);
1431 mgr.touchManager_.ChangeState(TouchState::IDLE_STATE);
1432 }
1433
1434 /**
1435 * @tc.name: TestHandleTouchEvent
1436 * @tc.desc: Verify the result of HandleTouchEvent
1437 * @tc.type: FUNC
1438 * @tc.require:
1439 */
1440 HWTEST_F(HgmFrameRateMgrTest, TestHandleTouchEvent, Function | SmallTest | Level0)
1441 {
1442 HgmFrameRateManager mgr;
1443 mgr.touchManager_.eventCallbacks_.clear();
1444 mgr.frameVoter_.voterGamesEffective_ = true;
1445 mgr.touchManager_.state_.store(TouchState::DOWN_STATE);
1446 mgr.HandleTouchEvent(0, TOUCH_DOWN, 1);
1447
1448 mgr.frameVoter_.voterGamesEffective_ = true;
1449 mgr.touchManager_.state_.store(TouchState::IDLE_STATE);
1450 mgr.HandleTouchEvent(0, TOUCH_MOVE, 1);
1451
1452 mgr.frameVoter_.voterGamesEffective_ = true;
1453 mgr.touchManager_.state_.store(TouchState::IDLE_STATE);
1454 mgr.HandleTouchEvent(0, TOUCH_BUTTON_DOWN, 1);
1455
1456 mgr.frameVoter_.voterGamesEffective_ = true;
1457 mgr.touchManager_.state_.store(TouchState::IDLE_STATE);
1458 mgr.HandleTouchEvent(0, TOUCH_BUTTON_UP, 1);
1459
1460 mgr.frameVoter_.voterGamesEffective_ = true;
1461 mgr.touchManager_.state_.store(TouchState::IDLE_STATE);
1462 mgr.HandleTouchEvent(0, AXIS_BEGIN, 1);
1463
1464 mgr.frameVoter_.voterGamesEffective_ = true;
1465 mgr.touchManager_.state_.store(TouchState::IDLE_STATE);
1466 mgr.HandleTouchEvent(0, AXIS_UPDATE, 1);
1467
1468 mgr.frameVoter_.voterGamesEffective_ = true;
1469 mgr.touchManager_.state_.store(TouchState::IDLE_STATE);
1470 mgr.HandleTouchEvent(0, AXIS_END, 1);
1471
1472 mgr.frameVoter_.voterGamesEffective_ = true;
1473 mgr.touchManager_.state_.store(TouchState::IDLE_STATE);
1474 mgr.HandleTouchEvent(0, TOUCH_DOWN, 1);
1475 mgr.HandleTouchEvent(0, TOUCH_UP, 1);
1476 mgr.touchManager_.ChangeState(TouchState::IDLE_STATE);
1477 sleep(1);
1478 EXPECT_EQ(mgr.touchManager_.pkgName_, "");
1479 }
1480
1481 /**
1482 * @tc.name: TestHandlePointerTask
1483 * @tc.desc: Verify the result of HandlePointerTask
1484 * @tc.type: FUNC
1485 * @tc.require:
1486 */
1487 HWTEST_F(HgmFrameRateMgrTest, TestHandlePointerTask, Function | SmallTest | Level1)
1488 {
1489 HgmFrameRateManager mgr;
1490 pid_t pid = DEFAULT_PID + 1;
1491 int32_t pointerStatus = AXIS_BEGIN;
1492 std::string pkg0 = "com.wedobest.fivechess.harm:1002:10110";
1493 std::string pkg1 = "com.undefined.pkg:10020:-1";
1494
1495 mgr.HandlePointerTask(pid, pointerStatus, 1);
1496 EXPECT_TRUE(mgr.cleanPidCallback_[pid].count(CleanPidCallbackType::TOUCH_EVENT) > 0);
1497
1498 pid = DEFAULT_PID;
1499 mgr.HandlePointerTask(pid, pointerStatus, 1);
1500
1501 pointerStatus = AXIS_UPDATE;
1502 mgr.HandlePointerTask(pid, pointerStatus, 1);
1503
1504 pointerStatus = AXIS_END;
1505 mgr.HandlePointerTask(pid, pointerStatus, 1);
1506
1507 pointerStatus = AXIS_BEGIN;
1508 mgr.multiAppStrategy_.pkgs_ = {pkg0};
1509 mgr.HandlePointerTask(pid, pointerStatus, 1);
1510 EXPECT_EQ(mgr.pointerManager_.pkgName_, "");
1511
1512 mgr.multiAppStrategy_.pkgs_ = {pkg1};
1513 mgr.multiAppStrategy_.strategyConfigMapCache_[mgr.multiAppStrategy_.screenSettingCache_.strategy]
1514 .pointerMode = PointerModeType::POINTER_DISENABLED;
1515 mgr.HandlePointerTask(pid, pointerStatus, 1);
1516
1517 mgr.multiAppStrategy_.screenSettingCache_.strategy = "undefined";
1518 mgr.HandlePointerTask(pid, pointerStatus, 1);
1519 mgr.pointerManager_.ChangeState(PointerState::POINTER_IDLE_STATE);
1520 sleep(1);
1521 }
1522
1523 /**
1524 * @tc.name: TestHandleTouchTask
1525 * @tc.desc: Verify the result of HandleTouchTask
1526 * @tc.type: FUNC
1527 * @tc.require:
1528 */
1529 HWTEST_F(HgmFrameRateMgrTest, TestHandleTouchTask, Function | SmallTest | Level0)
1530 {
1531 HgmFrameRateManager mgr;
1532 mgr.touchManager_.eventCallbacks_.clear();
1533 mgr.HandleTouchTask(DEFAULT_PID, TOUCH_PULL_UP, 1);
1534 mgr.DeliverRefreshRateVote({ "VOTER_GAMES", OLED_60_HZ, OLED_60_HZ, DEFAULT_PID }, true);
1535 mgr.HandleTouchTask(DEFAULT_PID, TOUCH_PULL_UP, 1);
1536 mgr.multiAppStrategy_.backgroundPid_.Put(DEFAULT_PID);
1537 mgr.HandleTouchTask(DEFAULT_PID, TOUCH_PULL_UP, 1);
1538 mgr.frameVoter_.voteRecord_.erase("VOTER_GAMES");
1539 mgr.HandleTouchTask(DEFAULT_PID, TOUCH_PULL_UP, 1);
1540
1541 mgr.frameVoter_.voterGamesEffective_ = true;
1542 mgr.HandleTouchTask(DEFAULT_PID, TOUCH_PULL_UP, 1);
1543 mgr.frameVoter_.voterGamesEffective_ = false;
1544 mgr.HandleTouchTask(DEFAULT_PID, TOUCH_PULL_UP, 1);
1545
1546 EXPECT_EQ(mgr.touchManager_.pkgName_, "");
1547 }
1548
1549 /**
1550 * @tc.name: TestMarkVoteChange
1551 * @tc.desc: Verify the result of MarkVoteChange
1552 * @tc.type: FUNC
1553 * @tc.require:
1554 */
1555 HWTEST_F(HgmFrameRateMgrTest, TestMarkVoteChange, Function | SmallTest | Level0)
1556 {
1557 HgmFrameRateManager mgr;
1558 mgr.voterTouchEffective_ = true;
1559 mgr.MarkVoteChange();
1560 mgr.MarkVoteChange("NULL");
1561 mgr.voterTouchEffective_ = false;
1562 mgr.MarkVoteChange("NULL");
1563 mgr.MarkVoteChange("VOTER_POWER_MODE");
1564 mgr.frameVoter_.voteRecord_["VOTER_POWER_MODE"].second = false;
1565 mgr.MarkVoteChange("VOTER_POWER_MODE");
1566 mgr.voterTouchEffective_ = true;
1567 mgr.DeliverRefreshRateVote({ "VOTER_POWER_MODE", OLED_60_HZ, OLED_60_HZ, DEFAULT_PID }, true);
1568 mgr.MarkVoteChange("VOTER_POWER_MODE");
1569 EXPECT_EQ(mgr.frameVoter_.voteRecord_["VOTER_POWER_MODE"].second, true);
1570 }
1571
1572 /**
1573 * @tc.name: InitTimers
1574 * @tc.desc: Verify the result of InitTimers
1575 * @tc.type: FUNC
1576 * @tc.require:
1577 */
1578 HWTEST_F(HgmFrameRateMgrTest, InitTimers, Function | SmallTest | Level0)
1579 {
1580 HgmFrameRateManager mgr;
1581 mgr.SetVsyncRateDiscountLTPO({}, 0);
1582 ASSERT_TRUE(mgr.changeGeneratorRateValid_);
1583 mgr.SetChangeGeneratorRateValid(false);
1584 EXPECT_FALSE(mgr.changeGeneratorRateValid_);
1585 sleep(1);
1586 EXPECT_TRUE(mgr.changeGeneratorRateValid_);
1587 mgr.changeGeneratorRateValidTimer_.Stop();
1588
1589 EXPECT_EQ(mgr.rsFrameRateLinker_, nullptr);
1590 mgr.rsFrameRateTimer_.Start();
1591 sleep(1);
1592
1593 mgr.rsFrameRateLinker_ = std::make_shared<RSRenderFrameRateLinker>();
1594 ASSERT_NE(mgr.rsFrameRateLinker_, nullptr);
1595 mgr.rsFrameRateLinker_->SetExpectedRange(FrameRateRange{0, 1, 1}); // not null
1596 mgr.rsFrameRateTimer_.Start();
1597 sleep(1);
1598 EXPECT_EQ(mgr.rsFrameRateLinker_->GetExpectedRange(), FrameRateRange{});
1599 mgr.rsFrameRateTimer_.Stop();
1600 }
1601
1602 /**
1603 * @tc.name: TestCheckRefreshRateChange
1604 * @tc.desc: Verify the result of CheckRefreshRateChange
1605 * @tc.type: FUNC
1606 * @tc.require:
1607 */
1608 HWTEST_F(HgmFrameRateMgrTest, TestCheckRefreshRateChange, Function | SmallTest | Level2)
1609 {
1610 HgmFrameRateManager mgr;
1611 auto& hgmCore = HgmCore::Instance();
1612 mgr.CheckRefreshRateChange(false, false, 120, true);
__anon09d8ed1d0902(bool idleTimerExpired, bool forceUpdate) 1613 mgr.forceUpdateCallback_ = [](bool idleTimerExpired, bool forceUpdate) {};
1614 mgr.CheckRefreshRateChange(false, false, 120, true);
1615 mgr.CheckRefreshRateChange(false, false, 120, false);
1616 EXPECT_EQ(mgr.isNeedUpdateAppOffset_, false);
1617
1618 hgmCore.SetLtpoEnabled(true);
1619 hgmCore.SetSupportedMaxTE(360);
1620 mgr.CheckRefreshRateChange(false, true, 120, true);
1621 mgr.forceUpdateCallback_ = nullptr;
1622 mgr.CheckRefreshRateChange(false, true, 120, true);
1623 mgr.CheckRefreshRateChange(false, true, 120, false);
1624 EXPECT_EQ(mgr.isNeedUpdateAppOffset_, false);
1625 }
1626 } // namespace Rosen
1627 } // namespace OHOS
1628