1 /*
2 * Copyright (c) 2024 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/mock/core/pipeline/mock_pipeline_context.h"
18
19 #include "base/memory/referenced.h"
20 #include "core/components_ng/base/frame_node.h"
21 #include "core/components_ng/pattern/stage/page_pattern.h"
22 #include "core/components_ng/pattern/checkbox/checkbox_pattern.h"
23 #include "frameworks/core/components_ng/manager/safe_area/safe_area_manager.h"
24
25 using namespace testing;
26 using namespace testing::ext;
27 namespace OHOS::Ace::NG {
28
29 namespace {
30 constexpr double DISPLAY_WIDTH = 720;
31 constexpr double DISPLAY_HEIGHT = 1280;
32
33 constexpr double SYSTEM_LEFT_START = 0.0f;
34 constexpr double SYSTEM_LEFT_END = 30.0f;
35 constexpr double SYSTEM_RIGHT_START = DISPLAY_WIDTH - 30.0f;
36 constexpr double SYSTEM_RIGHT_END = DISPLAY_WIDTH - 0.0f;
37 constexpr double SYSTEM_TOP_START = 0.0f;
38 constexpr double SYSTEM_TOP_END = 30.0f;
39 constexpr double SYSTEM_BOTTOM_START = DISPLAY_HEIGHT - 30.0f;
40 constexpr double SYSTEM_BOTTOM_END = DISPLAY_HEIGHT - 0.0f;
41
42 constexpr double CUTOUT_LEFT_START = 10.0f;
43 constexpr double CUTOUT_LEFT_END = 40.0f;
44 constexpr double CUTOUT_RIGHT_START = DISPLAY_WIDTH - 40.0f;
45 constexpr double CUTOUT_RIGHT_END = DISPLAY_WIDTH - 10.0f;
46 constexpr double CUTOUT_TOP_START = 20.0f;
47 constexpr double CUTOUT_TOP_END = 50.0f;
48 constexpr double CUTOUT_BOTTOM_START = DISPLAY_HEIGHT - 50.0f;
49 constexpr double CUTOUT_BOTTOM_END = DISPLAY_HEIGHT - 20.0f;
50
51 constexpr double NAV_LEFT_START = 20.0f;
52 constexpr double NAV_LEFT_END = 50.0f;
53 constexpr double NAV_RIGHT_START = DISPLAY_WIDTH - 50.0f;
54 constexpr double NAV_RIGHT_END = DISPLAY_WIDTH - 20.0f;
55 constexpr double NAV_TOP_START = 40.0f;
56 constexpr double NAV_TOP_END = 70.0f;
57 constexpr double NAV_BOTTOM_START = DISPLAY_HEIGHT - 70.0f;
58 constexpr double NAV_BOTTOM_END = DISPLAY_HEIGHT - 40.0f;
59
60 constexpr double KEYBOARD_HEIGHT = 420.0f;
61 } // namespace
62
63 class SafeAreaManagerTest : public testing::Test {
64 public:
65 static void SetUpTestCase();
66 static void TearDownTestCase();
67 void SetUp() override;
68 void TearDown() override;
69
70 struct Rect {
71 float left;
72 float right;
73 float top;
74 float bottom;
75 };
76 void CommonExpectEQ(const Rect& s1, const Rect& s2);
77
78 RefPtr<SafeAreaManager> safeAreaManager_;
79 NG::SafeAreaInsets cutoutArea =
80 NG::SafeAreaInsets({ CUTOUT_LEFT_START, CUTOUT_LEFT_END }, { CUTOUT_TOP_START, CUTOUT_TOP_END },
81 { CUTOUT_RIGHT_START, CUTOUT_RIGHT_END }, { CUTOUT_BOTTOM_START, CUTOUT_BOTTOM_END });
82 NG::SafeAreaInsets systemArea =
83 NG::SafeAreaInsets({ SYSTEM_LEFT_START, SYSTEM_LEFT_END }, { SYSTEM_TOP_START, SYSTEM_TOP_END },
84 { SYSTEM_RIGHT_START, SYSTEM_RIGHT_END }, { SYSTEM_BOTTOM_START, SYSTEM_BOTTOM_END });
85 NG::SafeAreaInsets navArea =
86 NG::SafeAreaInsets({ NAV_LEFT_START, NAV_LEFT_END }, { NAV_TOP_START, NAV_TOP_END },
87 { NAV_RIGHT_START, NAV_RIGHT_END }, { NAV_BOTTOM_START, NAV_BOTTOM_END });
88 NG::SafeAreaInsets cutoutAreaNotValid =
89 NG::SafeAreaInsets({ CUTOUT_LEFT_END, CUTOUT_LEFT_START }, { CUTOUT_TOP_END, CUTOUT_TOP_START },
90 { CUTOUT_RIGHT_END, CUTOUT_RIGHT_START }, { CUTOUT_BOTTOM_END, CUTOUT_BOTTOM_START });
91 NG::SafeAreaInsets systemAreaNotValid =
92 NG::SafeAreaInsets({ SYSTEM_LEFT_END, SYSTEM_LEFT_START }, { SYSTEM_TOP_END, SYSTEM_TOP_START },
93 { SYSTEM_RIGHT_END, SYSTEM_RIGHT_START }, { SYSTEM_BOTTOM_END, SYSTEM_BOTTOM_START });
94 NG::SafeAreaInsets navAreaNotValid =
95 NG::SafeAreaInsets({ NAV_LEFT_END, NAV_LEFT_START }, { NAV_TOP_END, NAV_TOP_START },
96 { NAV_RIGHT_END, NAV_RIGHT_START }, { NAV_BOTTOM_END, NAV_BOTTOM_START });
97 };
98
SetUpTestCase()99 void SafeAreaManagerTest::SetUpTestCase()
100 {
101 MockPipelineContext::SetUp();
102 }
103
TearDownTestCase()104 void SafeAreaManagerTest::TearDownTestCase()
105 {
106 MockPipelineContext::TearDown();
107 }
108
SetUp()109 void SafeAreaManagerTest::SetUp()
110 {
111 safeAreaManager_ = Referenced::MakeRefPtr<SafeAreaManager>();
112 }
113
TearDown()114 void SafeAreaManagerTest::TearDown()
115 {
116 safeAreaManager_ = nullptr;
117 }
118
CommonExpectEQ(const Rect & s1,const Rect & s2)119 void SafeAreaManagerTest::CommonExpectEQ(const Rect& s1, const Rect& s2)
120 {
121 EXPECT_EQ(s1.left, s2.left);
122 EXPECT_EQ(s1.right, s2.right);
123 EXPECT_EQ(s1.top, s2.top);
124 EXPECT_EQ(s1.bottom, s2.bottom);
125 }
126
127 /**
128 * @tc.name: IsSafeAreaValidTest
129 * @tc.desc: Use IsSafeAreaValid and test.
130 * @tc.type: FUNC
131 */
132 HWTEST_F(SafeAreaManagerTest, IsSafeAreaValidTest, TestSize.Level1)
133 {
134 EXPECT_EQ(safeAreaManager_->IsIgnoreAsfeArea(), false);
135 EXPECT_EQ(safeAreaManager_->IsFullScreen(), false);
136 EXPECT_EQ(safeAreaManager_->IsNeedAvoidWindow(), false);
137 EXPECT_EQ(safeAreaManager_->IsSafeAreaValid(), false);
138
139 auto res = safeAreaManager_->GetCutoutSafeArea();
140 CommonExpectEQ(Rect{res.left_.start, res.right_.end, res.top_.start, res.bottom_.end},
141 Rect{0.0f, 0.0f, 0.0f, 0.0f});
142 res = safeAreaManager_->GetSafeArea();
143 CommonExpectEQ(Rect{res.left_.start, res.right_.end, res.top_.start, res.bottom_.end},
144 Rect{0.0f, 0.0f, 0.0f, 0.0f});
145 res = safeAreaManager_->GetSafeAreaWithoutCutout();
146 CommonExpectEQ(Rect{res.left_.start, res.right_.end, res.top_.start, res.bottom_.end},
147 Rect{0.0f, 0.0f, 0.0f, 0.0f});
148 res = safeAreaManager_->GetCombinedSafeArea(SafeAreaExpandOpts());
149 CommonExpectEQ(Rect{res.left_.start, res.right_.end, res.top_.start, res.bottom_.end},
150 Rect{0.0f, 0.0f, 0.0f, 0.0f});
151
152 EXPECT_EQ(safeAreaManager_->SetIgnoreSafeArea(true), true);
153 EXPECT_EQ(safeAreaManager_->SetIgnoreSafeArea(true), false);
154 EXPECT_EQ(safeAreaManager_->IsSafeAreaValid(), false);
155 EXPECT_EQ(safeAreaManager_->SetIgnoreSafeArea(false), true);
156
157 EXPECT_EQ(safeAreaManager_->SetIsFullScreen(true), true);
158 EXPECT_EQ(safeAreaManager_->SetIsFullScreen(true), false);
159 EXPECT_EQ(safeAreaManager_->IsSafeAreaValid(), true);
160 EXPECT_EQ(safeAreaManager_->SetIsFullScreen(false), true);
161
162 EXPECT_EQ(safeAreaManager_->SetIsNeedAvoidWindow(true), true);
163 EXPECT_EQ(safeAreaManager_->SetIsNeedAvoidWindow(true), false);
164 EXPECT_EQ(safeAreaManager_->IsSafeAreaValid(), true);
165 EXPECT_EQ(safeAreaManager_->SetIsNeedAvoidWindow(false), true);
166
167 EXPECT_EQ(safeAreaManager_->SetIsFullScreen(true), true);
168 EXPECT_EQ(safeAreaManager_->SetIsNeedAvoidWindow(true), true);
169 EXPECT_EQ(safeAreaManager_->IsSafeAreaValid(), true);
170
171 EXPECT_EQ(safeAreaManager_->IsAtomicService(), false);
172 EXPECT_EQ(safeAreaManager_->SetIsAtomicService(true), true);
173 EXPECT_EQ(safeAreaManager_->SetIsAtomicService(true), false);
174 EXPECT_EQ(safeAreaManager_->IsAtomicService(), true);
175 }
176
177 /**
178 * @tc.name: UpdateCutoutTest
179 * @tc.desc: Use UpdateCutoutSafeArea and test.
180 * @tc.type: FUNC
181 */
182 HWTEST_F(SafeAreaManagerTest, UpdateCutoutTest, TestSize.Level1)
183 {
184 /**
185 * @tc.steps: step1 call UpdateCutoutSafeArea no rootSize params
186 * @tc.expected: cutout regions need to adjacent to edges.
187 */
188 safeAreaManager_->SetIsFullScreen(true);
189 auto ret = safeAreaManager_->UpdateCutoutSafeArea(cutoutArea);
190 EXPECT_EQ(ret, true);
191 ret = safeAreaManager_->UpdateCutoutSafeArea(cutoutArea);
192 EXPECT_EQ(ret, false);
193
194 auto csa = safeAreaManager_->GetCutoutSafeArea();
195 auto sa = safeAreaManager_->GetSafeArea();
196 EXPECT_EQ(csa, sa);
197 CommonExpectEQ(Rect{sa.left_.start, sa.right_.end, sa.top_.start, sa.bottom_.end},
198 Rect{0.0f, DISPLAY_WIDTH, 0.0f, DISPLAY_HEIGHT});
199 /**
200 * @tc.steps: step2 call UpdateCutoutSafeArea has rootSize params
201 * @tc.expected: cutout regions need to adjacent to edges.
202 */
203 NG::OptionalSize<uint32_t> rootSize;
204 rootSize.SetWidth(DISPLAY_WIDTH-20);
205 rootSize.SetHeight(DISPLAY_HEIGHT-25);
206 ret = safeAreaManager_->UpdateCutoutSafeArea(cutoutArea, rootSize);
207 EXPECT_EQ(ret, true);
208 sa = safeAreaManager_->GetSafeArea();
209 CommonExpectEQ(Rect{sa.left_.start, sa.right_.end, sa.top_.start, sa.bottom_.end},
210 Rect{0.0f, DISPLAY_WIDTH-20, 0.0f, DISPLAY_HEIGHT-25});
211 /**
212 * @tc.steps: step3 call UpdateCutoutSafeArea SafeAreaInsets is not valid params
213 * @tc.expected: cutout regions need to adjacent to edges.
214 */
215 ret = safeAreaManager_->UpdateCutoutSafeArea(cutoutAreaNotValid);
216 EXPECT_EQ(ret, true);
217 ret = safeAreaManager_->UpdateCutoutSafeArea(cutoutAreaNotValid);
218 EXPECT_EQ(ret, false);
219 }
220
221 /**
222 * @tc.name: UpdateSystemSafeAreaTest
223 * @tc.desc: Use UpdateSystemSafeArea and test.
224 * @tc.type: FUNC
225 */
226 HWTEST_F(SafeAreaManagerTest, UpdateSystemSafeAreaTest, TestSize.Level1)
227 {
228 /**
229 * @tc.steps: call UpdateSystemSafeAreaTest
230 */
231 safeAreaManager_->SetIsFullScreen(true);
232 auto ret = safeAreaManager_->UpdateSystemSafeArea(systemArea);
233 EXPECT_EQ(ret, true);
234 ret = safeAreaManager_->UpdateSystemSafeArea(systemArea);
235 EXPECT_EQ(ret, false);
236
237 auto ssa = safeAreaManager_->GetSystemSafeArea();
238 EXPECT_EQ(ssa, systemArea);
239
240 auto sas = safeAreaManager_->GetSafeArea();
241 CommonExpectEQ(Rect{sas.left_.start, sas.right_.end, sas.top_.start, sas.bottom_.end},
242 Rect{SYSTEM_LEFT_START, SYSTEM_RIGHT_END, SYSTEM_TOP_START, SYSTEM_BOTTOM_END});
243 }
244
245 /**
246 * @tc.name: UpdateNavAreaTest
247 * @tc.desc: Use UpdateNavArea and test.
248 * @tc.type: FUNC
249 */
250 HWTEST_F(SafeAreaManagerTest, UpdateNavAreaTest, TestSize.Level1)
251 {
252 /**
253 * @tc.steps: call UpdateNavAreaTest
254 */
255 safeAreaManager_->SetIsFullScreen(true);
256 auto ret = safeAreaManager_->UpdateNavArea(navArea);
257 EXPECT_EQ(ret, true);
258 ret = safeAreaManager_->UpdateNavArea(navArea);
259 EXPECT_EQ(ret, false);
260 auto san = safeAreaManager_->GetSafeArea();
261 CommonExpectEQ(Rect{san.left_.start, san.right_.end, san.top_.start, san.bottom_.end},
262 Rect{NAV_LEFT_START, NAV_RIGHT_END, NAV_TOP_START, NAV_BOTTOM_END});
263 }
264
265 /**
266 * @tc.name: UpdateKeyboardSafeAreaTest
267 * @tc.desc: Use UpdateKeyboardSafeArea and test.
268 * @tc.type: FUNC
269 */
270 HWTEST_F(SafeAreaManagerTest, UpdateKeyboardSafeAreaTest, TestSize.Level1)
271 {
272 /**
273 * @tc.steps: step1 call UpdateKeyboardSafeAreaTest systemArea is valid
274 */
275 safeAreaManager_->SetIsFullScreen(true);
276 safeAreaManager_->UpdateSystemSafeArea(systemArea);
277 auto ret = safeAreaManager_->UpdateKeyboardSafeArea(KEYBOARD_HEIGHT);
278 EXPECT_EQ(ret, true);
279 ret = safeAreaManager_->UpdateKeyboardSafeArea(KEYBOARD_HEIGHT);
280 EXPECT_EQ(ret, false);
281 auto retKbi = safeAreaManager_->GetKeyboardInset();
282 EXPECT_EQ(retKbi.start, systemArea.bottom_.start-KEYBOARD_HEIGHT);
283 EXPECT_EQ(retKbi.end, systemArea.bottom_.start);
284 /**
285 * @tc.steps: step2 call UpdateKeyboardSafeAreaTest systemArea not valid
286 */
287 safeAreaManager_->UpdateSystemSafeArea(systemAreaNotValid);
288 safeAreaManager_->UpdateKeyboardSafeArea(KEYBOARD_HEIGHT);
289 retKbi = safeAreaManager_->GetKeyboardInset();
290 auto tmpBottom = PipelineContext::GetCurrentRootHeight();
291 EXPECT_EQ(retKbi.start, tmpBottom-KEYBOARD_HEIGHT);
292 EXPECT_EQ(retKbi.end, tmpBottom);
293 /**
294 * @tc.steps: step3 call UpdateKeyboardSafeAreaTest systemArea not valid and has rootHeight
295 */
296 uint32_t rootHeight = SYSTEM_BOTTOM_START;
297 safeAreaManager_->UpdateSystemSafeArea(systemAreaNotValid);
298 safeAreaManager_->UpdateKeyboardSafeArea(KEYBOARD_HEIGHT, rootHeight);
299 retKbi = safeAreaManager_->GetKeyboardInset();
300 EXPECT_EQ(retKbi.start, rootHeight-KEYBOARD_HEIGHT);
301 EXPECT_EQ(retKbi.end, rootHeight);
302 }
303
304 /**
305 * @tc.name: GetCombinedSafeAreaTest
306 * @tc.desc: Use GetCombinedSafeArea GetSafeAreaWithoutCutout GetSafeAreaWithoutProcess and test.
307 * @tc.type: FUNC
308 */
309 HWTEST_F(SafeAreaManagerTest, GetCombinedSafeAreaTest, TestSize.Level1)
310 {
__anonb179e79c0202(SafeAreaExpandOpts saeo, float l, float r, float t, float b) 311 auto funExPect = [this](SafeAreaExpandOpts saeo, float l, float r, float t, float b) {
312 auto res = safeAreaManager_->GetCombinedSafeArea(saeo);
313 CommonExpectEQ(Rect{res.left_.start, res.right_.end, res.top_.start, res.bottom_.end},
314 Rect{l, r, t, b});
315 };
316 safeAreaManager_->SetIsFullScreen(true);
317 safeAreaManager_->UpdateCutoutSafeArea(cutoutArea);
318 safeAreaManager_->UpdateSystemSafeArea(systemArea);
319 safeAreaManager_->UpdateNavArea(navArea);
320 safeAreaManager_->UpdateKeyboardSafeArea(KEYBOARD_HEIGHT);
321 safeAreaManager_->SetKeyBoardAvoidMode(false);
322 SafeAreaExpandOpts opt;
323 /*@tc.steps: step1 call GetCombinedSafeArea ignore SafeArea*/
324 safeAreaManager_->SetIgnoreSafeArea(true);
325 funExPect(opt, 0.0f, 0.0f, 0.0f, 0.0f);
326 /*@tc.steps: step2 call GetCombinedSafeArea opt is null*/
327 safeAreaManager_->SetIgnoreSafeArea(false);
328 funExPect(opt, 0.0f, 0.0f, 0.0f, 0.0f);
329 /*@tc.steps: step3 call GetCombinedSafeArea not ignore SafeArea and SAFE_AREA_TYPE_CUTOUT*/
330 opt.type |= SAFE_AREA_TYPE_CUTOUT;
331 funExPect(opt, 0.0f, DISPLAY_WIDTH, 0.0f, DISPLAY_HEIGHT);
332 /*@tc.steps: step4 call GetCombinedSafeArea not ignore SafeArea and SAFE_AREA_TYPE_SYSTEM*/
333 opt.type |= SAFE_AREA_TYPE_SYSTEM;
334 funExPect(opt, SYSTEM_LEFT_START, SYSTEM_RIGHT_END, SYSTEM_TOP_START, SYSTEM_BOTTOM_END);
335 /**@tc.steps: step5 call GetCombinedSafeArea not ignore SafeArea and keyboardSafeAreaEnabled_
336 and SAFE_AREA_TYPE_KEYBOARD*/
337 safeAreaManager_->SetKeyBoardAvoidMode(true);
338 funExPect(opt, SYSTEM_LEFT_START, SYSTEM_RIGHT_END, SYSTEM_TOP_START, SYSTEM_BOTTOM_END);
339
340 safeAreaManager_->SetKeyBoardAvoidMode(false);
341 opt.type |= SAFE_AREA_TYPE_KEYBOARD;
342 funExPect(opt, SYSTEM_LEFT_START, SYSTEM_RIGHT_END, SYSTEM_TOP_START, SYSTEM_BOTTOM_END);
343
344 safeAreaManager_->SetKeyBoardAvoidMode(true);
345 funExPect(opt, SYSTEM_LEFT_START, SYSTEM_RIGHT_END, SYSTEM_TOP_START, SYSTEM_BOTTOM_END);
346 /*@tc.steps: step6 call GetSafeAreaWithoutCutout*/
347 auto res = safeAreaManager_->GetSafeAreaWithoutCutout();
348 CommonExpectEQ(Rect{res.left_.start, res.right_.end, res.top_.start, res.bottom_.end},
349 Rect{0.0f, DISPLAY_WIDTH, 0.0f, DISPLAY_HEIGHT});
350 /*@tc.steps: step7 call GetSafeAreaWithoutProcess*/
351 res = safeAreaManager_->GetSafeAreaWithoutProcess();
352 CommonExpectEQ(Rect{res.left_.start, res.right_.end, res.top_.start, res.bottom_.end},
353 Rect{0.0f, DISPLAY_WIDTH, 0.0f, DISPLAY_HEIGHT});
354 }
355
356 /**
357 * @tc.name: KeyboardOffsetTest
358 * @tc.desc: Use UpdateKeyboardOffset GetKeyboardOffset KeyboardSafeAreaEnabled
359 * SetKeyBoardAvoidMode and test.
360 * @tc.type: FUNC
361 */
362 HWTEST_F(SafeAreaManagerTest, KeyboardOffsetTest, TestSize.Level1)
363 {
364 float offset = 20.0f;
365 safeAreaManager_->UpdateKeyboardOffset(offset);
366 /**
367 * @tc.steps: step1 keyboardSafeAreaEnabled_ is true
368 */
369 auto kbam = safeAreaManager_->SetKeyBoardAvoidMode(true);
370 EXPECT_EQ(kbam, true);
371 kbam = safeAreaManager_->SetKeyBoardAvoidMode(true);
372 EXPECT_EQ(kbam, false);
373 auto ret = safeAreaManager_->KeyboardSafeAreaEnabled();
374 EXPECT_EQ(ret, true);
375 auto kbo = safeAreaManager_->GetKeyboardOffset();
376 EXPECT_EQ(kbo, 0.0f);
377 /**
378 * @tc.steps: step2 keyboardSafeAreaEnabled_ is false
379 */
380 safeAreaManager_->SetKeyBoardAvoidMode(false);
381 ret = safeAreaManager_->KeyboardSafeAreaEnabled();
382 EXPECT_EQ(ret, false);
383 kbo = safeAreaManager_->GetKeyboardOffset();
384 EXPECT_EQ(kbo, offset);
385 }
386
387 /**
388 * @tc.name: LastKeyboardPoistionTest
389 * @tc.desc: Use SetLastKeyboardPoistion GetLastKeyboardPoistion and test.
390 * @tc.type: FUNC
391 */
392 HWTEST_F(SafeAreaManagerTest, LastKeyboardPoistionTest, TestSize.Level1)
393 {
394 float lastKeyPos = 10.0f;
395 EXPECT_EQ(safeAreaManager_->GetLastKeyboardPoistion(), 0.0f);
396 safeAreaManager_->SetLastKeyboardPoistion(lastKeyPos);
397 EXPECT_EQ(safeAreaManager_->GetLastKeyboardPoistion(), lastKeyPos);
398 safeAreaManager_->SetLastKeyboardPoistion(0.0f);
399 EXPECT_EQ(safeAreaManager_->GetLastKeyboardPoistion(), 0.0f);
400 }
401
402 /**
403 * @tc.name: WindowWrapperOffsetTest
404 * @tc.desc: Use GetWindowWrapperOffset and test.
405 * @tc.type: FUNC
406 */
407 HWTEST_F(SafeAreaManagerTest, WindowWrapperOffsetTest, TestSize.Level1)
408 {
__anonb179e79c0302() 409 auto windowModeCallback1 = []() { return WindowMode::WINDOW_MODE_FLOATING; };
__anonb179e79c0402() 410 auto windowModeCallback2 = []() { return WindowMode::WINDOW_MODE_FULLSCREEN; };
411 auto pipeline = PipelineContext::GetCurrentContext();
412 auto manager = pipeline->GetSafeAreaManager();
413 auto windowManager = pipeline->GetWindowManager();
414
415 pipeline->SetWindowModal(WindowModal::NORMAL);
416 windowManager->SetWindowGetModeCallBack(std::move(windowModeCallback1));
417 auto ret = manager->GetWindowWrapperOffset();
418 EXPECT_EQ(ret, OffsetF());
419
420 pipeline->SetWindowModal(WindowModal::CONTAINER_MODAL);
421 windowManager->SetWindowGetModeCallBack(std::move(windowModeCallback1));
422 ret = manager->GetWindowWrapperOffset();
423 EXPECT_EQ(ret, OffsetF(5.0f, 1.0f));
424
425 pipeline->SetWindowModal(WindowModal::NORMAL);
426 windowManager->SetWindowGetModeCallBack(std::move(windowModeCallback2));
427 ret = manager->GetWindowWrapperOffset();
428 EXPECT_EQ(ret, OffsetF());
429
430 pipeline->SetWindowModal(WindowModal::CONTAINER_MODAL);
431 windowManager->SetWindowGetModeCallBack(std::move(windowModeCallback2));
432 ret = manager->GetWindowWrapperOffset();
433 EXPECT_EQ(ret, OffsetF());
434 }
435
436 /**
437 * @tc.name: NodesTest
438 * @tc.desc: Use GetGeoRestoreNodes AddGeoRestoreNode RemoveRestoreNode
439 * AddNeedExpandNode ClearNeedExpandNode ExpandSafeArea AddNodeToExpandListIfNeeded and test.
440 * @tc.type: FUNC
441 */
442 HWTEST_F(SafeAreaManagerTest, NodesTest, TestSize.Level1)
443 {
444 safeAreaManager_->ExpandSafeArea();
445 auto frameNode0 = FrameNode::CreateFrameNode(V2::PAGE_ETS_TAG, 0,
446 AceType::MakeRefPtr<PagePattern>(AceType::MakeRefPtr<PageInfo>()), true);
447 frameNode0->SetRootNodeId(0);
448 auto pattern0 = frameNode0->GetPattern<PagePattern>();
449 pattern0->CreateOverlayManager(true);
450 auto frameNode1 = FrameNode::CreateFrameNode(V2::PAGE_ETS_TAG, 1,
451 AceType::MakeRefPtr<PagePattern>(AceType::MakeRefPtr<PageInfo>()), true);
452 frameNode1->SetRootNodeType(RootNodeType::PAGE_ETS_TAG);
453 frameNode1->SetRootNodeId(0);
454 auto frameNode2 = FrameNode::CreateFrameNode(V2::PAGE_ETS_TAG, 2,
455 AceType::MakeRefPtr<PagePattern>(AceType::MakeRefPtr<PageInfo>()), false);
456 frameNode2->SetRootNodeType(RootNodeType::NAVDESTINATION_VIEW_ETS_TAG);
457 frameNode2->SetRootNodeId(0);
458 auto frameNode3 = FrameNode::CreateFrameNode(V2::NAVDESTINATION_VIEW_ETS_TAG, 3,
459 AceType::MakeRefPtr<PagePattern>(AceType::MakeRefPtr<PageInfo>()), false);
460 frameNode3->SetRootNodeType(RootNodeType::NAVDESTINATION_VIEW_ETS_TAG);
461 frameNode3->SetRootNodeId(0);
462 auto frameNode4 = FrameNode::CreateFrameNode(V2::CHECK_BOX_ETS_TAG, 4,
463 AceType::MakeRefPtr<CheckBoxPattern>());
464 EXPECT_EQ(safeAreaManager_->CheckPageNeedAvoidKeyboard(frameNode0), true);
465 EXPECT_EQ(safeAreaManager_->CheckPageNeedAvoidKeyboard(frameNode1), true);
466 EXPECT_EQ(safeAreaManager_->CheckPageNeedAvoidKeyboard(frameNode2), true);
467 EXPECT_EQ(safeAreaManager_->CheckPageNeedAvoidKeyboard(frameNode3), false);
468 EXPECT_EQ(safeAreaManager_->CheckPageNeedAvoidKeyboard(frameNode4), false);
469
470 EXPECT_EQ(safeAreaManager_->AddNodeToExpandListIfNeeded(frameNode0), true);
471 EXPECT_EQ(safeAreaManager_->AddNodeToExpandListIfNeeded(frameNode1), true);
472 EXPECT_EQ(safeAreaManager_->AddNodeToExpandListIfNeeded(frameNode2), true);
473 EXPECT_EQ(safeAreaManager_->AddNodeToExpandListIfNeeded(frameNode3), true);
474 EXPECT_EQ(safeAreaManager_->AddNodeToExpandListIfNeeded(frameNode4), true);
475
476 EXPECT_EQ(safeAreaManager_->AddNodeToExpandListIfNeeded(frameNode0), false);
477 EXPECT_EQ(safeAreaManager_->AddNodeToExpandListIfNeeded(frameNode1), false);
478 EXPECT_EQ(safeAreaManager_->AddNodeToExpandListIfNeeded(frameNode2), false);
479 EXPECT_EQ(safeAreaManager_->AddNodeToExpandListIfNeeded(frameNode3), false);
480 EXPECT_EQ(safeAreaManager_->AddNodeToExpandListIfNeeded(frameNode4), false);
481
482 safeAreaManager_->ExpandSafeArea();
483 EXPECT_EQ(safeAreaManager_->AddNodeToExpandListIfNeeded(frameNode0), true);
484 EXPECT_EQ(safeAreaManager_->AddNodeToExpandListIfNeeded(frameNode1), true);
485 EXPECT_EQ(safeAreaManager_->AddNodeToExpandListIfNeeded(frameNode2), true);
486 EXPECT_EQ(safeAreaManager_->AddNodeToExpandListIfNeeded(frameNode3), true);
487 EXPECT_EQ(safeAreaManager_->AddNodeToExpandListIfNeeded(frameNode4), true);
488 auto pipeline = PipelineContext::GetCurrentContext();
489 auto manager = pipeline->GetSafeAreaManager();
490 EXPECT_EQ(manager->GetGeoRestoreNodes().size(), 5);
491 }
492 } // namespace OHOS::Ace::NG