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
19 #include "hgm_core.h"
20 #include "hgm_frame_rate_manager.h"
21
22 #include "screen_manager/screen_types.h"
23
24 using namespace testing;
25 using namespace testing::ext;
26
27 namespace OHOS {
28 namespace Rosen {
29 namespace {
30 int32_t width = 720;
31 int32_t height = 1080;
32 int32_t phyWidth = 685;
33 int32_t phyHeight = 1218;
34 ScreenSize screenSize = {width, height, phyWidth, phyHeight};
35 }
36 class HyperGraphicManagerTest : public testing::Test {
37 public:
38 static void SetUpTestCase();
39 static void TearDownTestCase();
40 void SetUp();
41 void TearDown();
42 };
43
SetUpTestCase()44 void HyperGraphicManagerTest::SetUpTestCase() {}
TearDownTestCase()45 void HyperGraphicManagerTest::TearDownTestCase() {}
SetUp()46 void HyperGraphicManagerTest::SetUp() {}
TearDown()47 void HyperGraphicManagerTest::TearDown() {}
48
49 /**
50 * @tc.name: Instance
51 * @tc.desc: Verify the independency of HgmCore instance
52 * @tc.type: FUNC
53 * @tc.require: I7DMS1
54 */
55 HWTEST_F(HyperGraphicManagerTest, Instance, Function | SmallTest | Level4)
56 {
57 PART("CaseDescription") {
58 STEP("1. call GetInstance twice") {
59 auto &instance1 = HgmCore::Instance();
60 auto &instance2 = HgmCore::Instance();
61 STEP("2. check the result of configuration") {
62 STEP_ASSERT_EQ(&instance1, &instance2);
63 }
64 }
65 }
66 }
67
68 /**
69 * @tc.name: IsInit
70 * @tc.desc: Verify the result of initialization
71 * @tc.type: FUNC
72 * @tc.require: I7DMS1
73 */
74 HWTEST_F(HyperGraphicManagerTest, IsInit, Function | SmallTest | Level2)
75 {
76 auto &instance = HgmCore::Instance();
77
78 PART("CaseDescription") {
79 STEP("1. check if IsInit() is true") {
80 bool init = instance.IsInit();
81 STEP_ASSERT_EQ(init, true);
82 bool enabled = instance.IsEnabled();
83 STEP_ASSERT_EQ(enabled, true);
84 instance.GetPolicyConfigData();
85 auto hgmFrameRateMgr_ = instance.GetFrameRateMgr();
86 STEP_ASSERT_NE(hgmFrameRateMgr_, nullptr);
87 }
88 }
89 }
90
91 /**
92 * @tc.name: AddScreen
93 * @tc.desc: Verify the result of AddScreen function
94 * @tc.type: FUNC
95 * @tc.require: I7DMS1
96 */
97 HWTEST_F(HyperGraphicManagerTest, AddScreen, Function | MediumTest | Level2)
98 {
99 auto &instance = HgmCore::Instance();
100 int sizeListBefore = 0;
101 int sizeListAfter = 0;
102 int sizeScreenIds = 0;
103
104 PART("EnvConditions") {
105 STEP("get Instance") {
106 bool init = instance.IsInit();
107 STEP_ASSERT_EQ(init, true);
108 }
109 }
110
111 PART("CaseDescription") {
112 STEP("1. mark screenList_ size before add") {
113 sizeListBefore = instance.GetScreenListSize();
114 STEP_ASSERT_GE(sizeListBefore, 0);
115 }
116
117 STEP("2. add new screen") {
118 ScreenId screenId = 2;
119 auto addScreen = instance.AddScreen(screenId, 0, screenSize);
120 STEP_ASSERT_EQ(addScreen, 0);
121 }
122
123 STEP("3. mark screenList_ size after add") {
124 sizeListAfter = instance.GetScreenListSize();
125 }
126
127 STEP("4. check screenList_ size") {
128 STEP_ASSERT_EQ(sizeListAfter, sizeListBefore + 1);
129 }
130
131 STEP("5. mark screenIds Size") {
132 sizeScreenIds = instance.GetScreenIds().size();
133 STEP_ASSERT_EQ(sizeScreenIds, sizeListAfter);
134 }
135 }
136 }
137
138 /**
139 * @tc.name: GetScreen
140 * @tc.desc: Verify the result of GetScreen function
141 * @tc.type: FUNC
142 * @tc.require: I7DMS1
143 */
144 HWTEST_F(HyperGraphicManagerTest, GetScreen, Function | SmallTest | Level2)
145 {
146 auto &instance5 = HgmCore::Instance();
147 sptr<HgmScreen> screen = nullptr;
148 ScreenId screenId = 3;
149 ScreenId screenId2 = 4;
150
151
152 PART("EnvConditions") {
153 STEP("get Instance and call Init and add a screen") {
154 auto addScreen = instance5.AddScreen(screenId, 0, screenSize);
155 auto activeScreen = instance5.GetActiveScreen();
156 STEP_ASSERT_EQ(activeScreen, nullptr);
157 instance5.SetActiveScreenId(screenId);
158 activeScreen = instance5.GetActiveScreen();
159 STEP_ASSERT_NE(activeScreen, nullptr);
160 STEP_ASSERT_GE(addScreen, 0);
161 STEP_ASSERT_GE(instance5.GetActiveScreenId(), screenId);
162 }
163 }
164
165 PART("CaseDescription") {
166 STEP("1. try get the previously added screen") {
167 screen = instance5.GetScreen(screenId);
168 }
169
170 STEP("2. check the pointer") {
171 STEP_ASSERT_NE(screen, nullptr);
172 }
173
174 STEP("3. try get the non-existence screen") {
175 screen = instance5.GetScreen(screenId2);
176 STEP_ASSERT_EQ(screen, nullptr);
177 }
178 }
179 }
180
181 /**
182 * @tc.name: AddScreenModeInfo
183 * @tc.desc: Verify the result of AddScreenModeInfo function
184 * @tc.type: FUNC
185 * @tc.require: I7DMS1
186 */
187 HWTEST_F(HyperGraphicManagerTest, AddScreenModeInfo, Function | SmallTest | Level3)
188 {
189 auto &instance6 = HgmCore::Instance();
190 int addMode = 0;
191 ScreenId screenId = 4;
192
193 PART("EnvConditions") {
194 STEP("get Instance and add a screen") {
195 auto addScreen = instance6.AddScreen(screenId, 0, screenSize);
196 STEP_ASSERT_GE(addScreen, 0);
197 }
198 }
199
200 PART("CaseDescription") {
201 STEP("1. try get the previously added screen") {
202 auto screen = instance6.GetScreen(screenId);
203 STEP_ASSERT_NE(screen, nullptr);
204 }
205
206 STEP("2. add a supported config to the new screen") {
207 addMode = instance6.AddScreen(screenId, addMode, screenSize);
208 }
209
210 STEP("3. verify adding result") {
211 STEP_ASSERT_EQ(addMode, 0);
212 }
213 }
214 }
215
216 /**
217 * @tc.name: RemoveScreen
218 * @tc.desc: Verify the result of RemoveScreen function
219 * @tc.type: FUNC
220 * @tc.require: I7DMS1
221 */
222 HWTEST_F(HyperGraphicManagerTest, RemoveScreen, Function | MediumTest | Level2)
223 {
224 auto &instance7 = HgmCore::Instance();
225 int sizeListBefore = 0;
226 int sizeListAfter = 0;
227 ScreenId screenId = 6;
228
229 PART("EnvConditions") {
230 STEP("get Instance and call Init and add a screen") {
231 bool init = instance7.IsInit();
232 STEP_ASSERT_EQ(init, true);
233 auto addScreen = instance7.AddScreen(screenId, 0, screenSize);
234 STEP_ASSERT_EQ(addScreen, 0);
235 }
236 }
237
238 PART("CaseDescription") {
239 STEP("1. mark screenList_ size before remove") {
240 sizeListBefore = instance7.GetScreenListSize();
241 STEP_ASSERT_GE(sizeListBefore, 1);
242 }
243
244 STEP("2. add new screen") {
245 ScreenId screenId = 2;
246 auto removeScreen = instance7.RemoveScreen(screenId);
247 STEP_ASSERT_EQ(removeScreen, 0);
248 }
249
250 STEP("3. mark screenList_ size after remove") {
251 sizeListAfter = instance7.GetScreenListSize();
252 }
253
254 STEP("3. check screenList_ size") {
255 STEP_ASSERT_EQ(sizeListAfter, sizeListBefore - 1);
256 }
257 }
258 }
259
260 /**
261 * @tc.name: SetScreenRefreshRate
262 * @tc.desc: Verify the result of SetScreenRefreshRate function
263 * @tc.type: FUNC
264 * @tc.require: I7DMS1
265 */
266 HWTEST_F(HyperGraphicManagerTest, SetScreenRefreshRate, Function | MediumTest | Level2)
267 {
268 auto &instance8 = HgmCore::Instance();
269 ScreenId screenId = 7;
270 ScreenId screenId2 = 1;
271 sptr<HgmScreen> screen = nullptr;
272 int32_t width = 1344;
273 int32_t height = 2772;
274 uint32_t rate = 120;
275 int32_t mode = 1;
276 int32_t width0 = 1344;
277 int32_t height0 = 2772;
278 uint32_t rate0 = 60;
279 int32_t mode0 = 0;
280 int32_t timestamp = 1704038400; // 2024-01-01 00:00:00
281
282 PART("CaseDescription") {
283 STEP("1. add a new screen") {
284 auto addScreen = instance8.AddScreen(screenId, 0, screenSize);
285 STEP_ASSERT_EQ(addScreen, 0);
286 auto addScreenProfile = instance8.AddScreenInfo(screenId, width, height, rate, mode);
287 STEP_ASSERT_EQ(addScreenProfile, 0);
288 auto addScreenProfile0 = instance8.AddScreenInfo(screenId, width0, height0, rate0, mode0);
289 STEP_ASSERT_EQ(addScreenProfile0, 0);
290 addScreenProfile0 = instance8.AddScreenInfo(screenId2, width0, height0, rate0, mode0);
291 STEP_ASSERT_EQ(addScreenProfile0, 100);
292 auto setRate500 = instance8.SetScreenRefreshRate(screenId, 0, 500);
293 STEP_ASSERT_EQ(setRate500, -1);
294 screen = instance8.GetScreen(screenId);
295 STEP_ASSERT_NE(screen->GetActiveRefreshRate(), 500);
296 auto setRate120 = instance8.SetScreenRefreshRate(screenId, 0, 120);
297 STEP_ASSERT_NE(setRate120, -1);
298 auto setRate60 = instance8.SetScreenRefreshRate(screenId2, 0, 60);
299 STEP_ASSERT_EQ(setRate60, -1);
300 auto setRateNegative = instance8.SetScreenRefreshRate(screenId, 0, -1);
301 STEP_ASSERT_EQ(setRateNegative, -1);
302 screen = instance8.GetScreen(screenId);
303 STEP_ASSERT_EQ(screen->GetActiveRefreshRate(), 120);
304 auto modeListToApply = instance8.GetModesToApply();
305 STEP_ASSERT_NE(modeListToApply->size(), 0);
306 instance8.SetPendingScreenRefreshRate(rate0);
307 STEP_ASSERT_EQ(instance8.GetPendingScreenRefreshRate(), rate0);
308 instance8.SetTimestamp(timestamp);
309 STEP_ASSERT_EQ(instance8.GetCurrentTimestamp(), timestamp);
310 }
311 }
312 }
313
314 /**
315 * @tc.name: SetRefreshRateMode
316 * @tc.desc: Verify the result of SetRefreshRateMode function
317 * @tc.type: FUNC
318 * @tc.require: I7DMS1
319 */
320 HWTEST_F(HyperGraphicManagerTest, SetRefreshRateMode, Function | SmallTest | Level2)
321 {
322 auto &instance = HgmCore::Instance();
323 ScreenId screenId = 7;
324 sptr<HgmScreen> screen = nullptr;
325 int32_t width = 1344;
326 int32_t height = 2772;
327 uint32_t rate = 120;
328 int32_t mode = 1;
329 RefreshRateMode modeToSet = HGM_REFRESHRATE_MODE_MEDIUM;
330
331 PART("EnvConditions") {
332 STEP("get Instance") {
333 bool init = instance.IsInit();
334 STEP_ASSERT_EQ(init, true);
335 }
336 }
337
338 PART("CaseDescription") {
339 STEP("1. add a new screen") {
340 auto addScreen = instance.AddScreen(screenId, 0, screenSize);
341 STEP_ASSERT_GE(addScreen, 0);
342 }
343
344 STEP("2. add a a supported config to the new screen") {
345 auto addScreenProfile = instance.AddScreenInfo(screenId, width, height, rate, mode);
346 STEP_ASSERT_EQ(addScreenProfile, 0);
347 }
348
349 STEP("3. set the refreshrate mode") {
350 auto setMode2 = instance.SetRefreshRateMode(modeToSet);
351 STEP_ASSERT_EQ(setMode2, 0);
352 }
353 }
354 }
355
356 /**
357 * @tc.name: HgmScreenTests
358 * @tc.desc: Others functions in HgmScreen
359 * @tc.type: FUNC
360 * @tc.require: I7NJ2G
361 */
362 HWTEST_F(HyperGraphicManagerTest, HgmScreenTests, Function | MediumTest | Level2)
363 {
364 auto &instance = HgmCore::Instance();
365 ScreenId screenId1 = 7;
366 ScreenId screenId2 = 8;
367 int32_t width = 1344;
368 int32_t height = 2772;
369 int32_t width2 = 640;
370 int32_t height2 = 1320;
371 uint32_t rate = 120;
372 uint32_t rate2 = 60;
373 uint32_t rate3 = 150;
374 uint32_t rate4 = 0;
375 uint32_t rate5 = 80;
376 int32_t mode = 1;
377 int32_t mode2 = 2;
378 instance.AddScreen(screenId2, 1, screenSize);
379 instance.AddScreenInfo(screenId2, width, height, rate, mode);
380 instance.AddScreenInfo(screenId2, width, height, rate2, mode2);
381 sptr<HgmScreen> screen = instance.GetScreen(screenId1);
382 sptr<HgmScreen> screen2 = instance.GetScreen(screenId2);
383
384 instance.AddScreen(screenId1, 0, screenSize);
385 EXPECT_GE(screen->GetActiveRefreshRate(), 0);
386 EXPECT_EQ(screen2->SetActiveRefreshRate(screenId2, rate2), 2);
387 EXPECT_EQ(screen2->SetActiveRefreshRate(screenId2, rate3), -1);
388 screen2->SetRateAndResolution(screenId2, rate2, width, height);
389 EXPECT_EQ(screen2->SetRateAndResolution(screenId2, rate, width, height), mode);
390 EXPECT_EQ(screen2->SetRateAndResolution(screenId2, rate3, width, height), -1);
391 EXPECT_EQ(screen2->SetRateAndResolution(screenId2, rate4, width, height), -1);
392 EXPECT_EQ(screen2->SetRateAndResolution(screenId2, rate5, width, height), -1);
393 EXPECT_EQ(screen2->SetRateAndResolution(screenId2, rate5, width2, height2), -1);
394 EXPECT_EQ(screen2->SetRateAndResolution(screenId2, rate5, width, height2), -1);
395 EXPECT_EQ(screen2->SetRateAndResolution(screenId2, rate5, width2, height), -1);
396 EXPECT_EQ(screen2->SetRateAndResolution(screenId2, rate, width2, height2), -1);
397 EXPECT_EQ(screen2->SetRateAndResolution(screenId2, rate, width, height2), -1);
398 EXPECT_EQ(screen2->SetRateAndResolution(screenId2, rate, width2, height), -1);
399 screen2->AddScreenModeInfo(width, height, rate, mode);
400 EXPECT_EQ(screen2->SetRefreshRateRange(rate2, rate), 0);
401 }
402
403 /**
404 * @tc.name: HgmScreenTests2
405 * @tc.desc: Others functions in HgmScreen
406 * @tc.type: FUNC
407 * @tc.require: I7NJ2G
408 */
409 HWTEST_F(HyperGraphicManagerTest, HgmScreenTests2, Function | MediumTest | Level2) {
410 PART("HgmScreen") {
411 STEP("screen tests") {
412 sptr<HgmScreen> screen1 = new HgmScreen();
413 STEP_ASSERT_EQ(screen1->GetId(), 0);
414 STEP_ASSERT_EQ(screen1->GetActiveMode(), 0);
415 STEP_ASSERT_EQ(screen1->GetSupportedRates().size(), 0);
416 STEP_ASSERT_EQ(screen1->IsSupportRate(OLED_30_HZ), false);
417 STEP_ASSERT_EQ(screen1->GetActiveRefreshRateMode(), -1);
418 STEP_ASSERT_EQ(screen1->GetWidth(), 0);
419 STEP_ASSERT_EQ(screen1->GetHeight(), 0);
420 STEP_ASSERT_EQ(screen1->GetPhyWidth(), 0);
421 STEP_ASSERT_EQ(screen1->GetPhyHeight(), 0);
422 STEP_ASSERT_EQ(screen1->GetPpi(), 0);
423 STEP_ASSERT_EQ(screen1->GetXDpi(), 0);
424 STEP_ASSERT_EQ(screen1->GetYDpi(), 0);
425
426 delete screen1;
427 screen1 = nullptr;
428 STEP_ASSERT_EQ(screen1, nullptr);
429 }
430 }
431 }
432
433
434 /**
435 * @tc.name: HgmCoreTests
436 * @tc.desc: Others functions in HgmCore
437 * @tc.type: FUNC
438 * @tc.require: I7NJ2G
439 */
440 HWTEST_F(HyperGraphicManagerTest, HgmCoreTests, Function | MediumTest | Level2)
441 {
442 auto &instance = HgmCore::Instance();
443 ScreenId screenId2 = 8;
444 ScreenId screenId3 = 9;
445 sptr<HgmScreen> screen = nullptr;
446 int32_t width = 1344;
447 int32_t height = 2772;
448 uint32_t rate = 120;
449 uint32_t rate2 = 60;
450 uint32_t rate3 = -1;
451 int32_t mode = 1;
452 int32_t mode2 = 2;
453 instance.AddScreen(screenId2, 1, screenSize);
454 instance.AddScreenInfo(screenId2, width, height, rate, mode);
455 instance.AddScreenInfo(screenId2, width, height, rate2, mode2);
456
457 PART("HgmCore") {
458 STEP("1. set active mode") {
459 int32_t setResult = instance.SetRefreshRateMode(HGM_REFRESHRATE_MODE_HIGH);
460 setResult = instance.SetRefreshRateMode(HGM_REFRESHRATE_MODE_LOW);
461 setResult = instance.SetRefreshRateMode(HGM_REFRESHRATE_MODE_HIGH);
462 STEP_ASSERT_EQ(setResult, 0);
463 }
464
465 STEP("2. set refresh rate via core") {
466 int32_t setResult = instance.SetScreenRefreshRate(screenId3, 0, rate);
467 setResult = instance.SetScreenRefreshRate(screenId2, 0, rate3);
468 setResult = instance.SetScreenRefreshRate(screenId2, 0, rate2);
469 setResult = instance.SetRefreshRateMode(HGM_REFRESHRATE_MODE_HIGH);
470 STEP_ASSERT_GE(setResult, -1);
471 }
472
473 STEP("3. set rate and resolution") {
474 int32_t setResult = instance.SetRateAndResolution(screenId2, 0, 0, 0, 0);
475 STEP_ASSERT_EQ(setResult, -1);
476 int32_t addResult = instance.AddScreen(screenId2, 1, screenSize);
477 STEP_ASSERT_GE(addResult, -1);
478 }
479
480 STEP("4. add screen info, screen does not exist") {
481 int32_t setResult = instance.AddScreenInfo(screenId3, 0, 0, 0, 0);
482 STEP_ASSERT_NE(setResult, 0);
483 uint32_t getResult = instance.GetScreenCurrentRefreshRate(screenId3);
484 STEP_ASSERT_EQ(getResult, 0);
485 std::vector<uint32_t> getVResult = instance.GetScreenSupportedRefreshRates(screenId3);
486 STEP_ASSERT_EQ(getVResult.size(), 0);
487 }
488
489 STEP("5. add screen info, screen exist") {
490 instance.GetScreenCurrentRefreshRate(screenId2);
491 std::vector<uint32_t> getVResult = instance.GetScreenSupportedRefreshRates(screenId2);
492 auto screenComponentRefreshRates = instance.GetScreenComponentRefreshRates(screenId2);
493 }
494 }
495 }
496
497 /**
498 * @tc.name: RefreshBundleName
499 * @tc.desc: Verify the result of RefreshBundleName
500 * @tc.type: FUNC
501 * @tc.require: I7DMS1
502 */
503 HWTEST_F(HyperGraphicManagerTest, RefreshBundleName, Function | SmallTest | Level2)
504 {
505 auto &instance = HgmCore::Instance();
506
507 PART("EnvConditions") {
508 STEP("get Instance") {
509 bool init = instance.IsInit();
510 STEP_ASSERT_EQ(init, true);
511 }
512 }
513
514 PART("CaseConditions") {
515 STEP("1. test RefreshBundleName is true") {
516 auto setMode = instance.RefreshBundleName("test hgm_core");
517 STEP_ASSERT_EQ(setMode, 0);
518 instance.SetRefreshRateMode(HGM_REFRESHRATE_MODE_AUTO);
519 setMode = instance.RefreshBundleName("test hgm_core2");
520 STEP_ASSERT_EQ(setMode, 0);
521 }
522 }
523 }
524
525 /**
526 * @tc.name: GetIdealPeriod
527 * @tc.desc: Test GetIdealPeriod
528 * @tc.type: FUNC
529 * @tc.require:
530 */
531 HWTEST_F(HyperGraphicManagerTest, GetIdealPeriod, Function | SmallTest | Level2)
532 {
533 auto &instance = HgmCore::Instance();
534 EXPECT_EQ(instance.GetIdealPeriod(30), 0);
535 EXPECT_EQ(instance.GetIdealPeriod(60), 16666666);
536 }
537
538 /**
539 * @tc.name: GetLtpoEnabled
540 * @tc.desc: Test GetLtpoEnabled
541 * @tc.type: FUNC
542 * @tc.require:
543 */
544 HWTEST_F(HyperGraphicManagerTest, GetLtpoEnabled, Function | SmallTest | Level2)
545 {
546 auto &instance = HgmCore::Instance();
547 instance.SetLtpoEnabled(true);
548 instance.SetSupportedMaxTE(VSYNC_MAX_REFRESHRATE);
549 instance.SetRefreshRateMode(HGM_REFRESHRATE_MODE_AUTO);
550 EXPECT_EQ(instance.IsLTPOSwitchOn(), true);
551 EXPECT_EQ(instance.GetSupportedMaxTE(), VSYNC_MAX_REFRESHRATE);
552 EXPECT_EQ(instance.GetCurrentRefreshRateMode(), static_cast<int32_t>(HGM_REFRESHRATE_MODE_AUTO));
553 EXPECT_EQ(instance.GetLtpoEnabled(), true);
554 }
555
556 /**
557 * @tc.name: NotifyScreenPowerStatus
558 * @tc.desc: Test NotifyScreenPowerStatus
559 * @tc.type: FUNC
560 * @tc.require:
561 */
562 HWTEST_F(HyperGraphicManagerTest, NotifyScreenPowerStatus, Function | SmallTest | Level2)
563 {
564 ScreenId screenId = 8;
565 auto &instance = HgmCore::Instance();
566 instance.NotifyScreenPowerStatus(screenId, POWER_STATUS_ON);
567 }
568
569
570 /**
571 * @tc.name: RefreshRateModeChangeCallback
572 * @tc.desc: Test RefreshRateModeChangeCallback
573 * @tc.type: FUNC
574 * @tc.require:
575 */
576 HWTEST_F(HyperGraphicManagerTest, RefreshRateModeChangeCallback, Function | SmallTest | Level2)
577 {
578 auto &instance = HgmCore::Instance();
__anonc7e7fc500202(int32_t num) 579 instance.RegisterRefreshRateModeChangeCallback([](int32_t num) {return;});
580 EXPECT_NE(instance.GetRefreshRateModeChangeCallback(), nullptr);
581 }
582
583 } // namespace Rosen
584 } // namespace OHOS