From 94b8845abac19ec225dff68d59ecafcf2ccf595f Mon Sep 17 00:00:00 2001 From: xiaojianfeng Date: Wed, 29 Jun 2022 20:05:18 +0800 Subject: [PATCH] fix avoid_area_controller_test bug Signed-off-by: xiaojianfeng Change-Id: I85e37864aeb8a2d5402fd3704d05b03317165928 --- utils/include/window_helper.h | 16 +- wm/test/unittest/BUILD.gn | 1 + .../unittest/avoid_area_controller_test.cpp | 608 ++++++++++-------- wm/test/unittest/avoid_area_controller_test.h | 12 +- wmserver/src/avoid_area_controller.cpp | 15 +- 5 files changed, 378 insertions(+), 274 deletions(-) diff --git a/utils/include/window_helper.h b/utils/include/window_helper.h index c879ce70..e3e552c0 100644 --- a/utils/include/window_helper.h +++ b/utils/include/window_helper.h @@ -127,17 +127,19 @@ public: return !(r1XEnd < r2.posX_ || r1.posX_ > r2XEnd || r1YEnd < r2.posY_ || r1.posY_ > r2YEnd); } - static inline Rect GetOverlap(const Rect& rect1, const Rect& rect2, const int offsetX, const int offsetY) + static Rect GetOverlap(const Rect& rect1, const Rect& rect2, const int offsetX, const int offsetY) { - const static Rect noOverlapRect = { 0, 0, 0, 0 }; int32_t x_begin = std::max(rect1.posX_, rect2.posX_); - int32_t x_end = std::min(rect1.posX_ + rect1.width_ - 1, rect2.posX_ + rect2.width_ - 1); + int32_t x_end = std::min(rect1.posX_ + static_cast(rect1.width_), + rect2.posX_ + static_cast(rect2.width_)); int32_t y_begin = std::max(rect1.posY_, rect2.posY_); - int32_t y_end = std::min(rect1.posY_ + rect1.height_ - 1, rect2.posY_ + rect2.height_ - 1); - if (y_begin > y_end || x_begin > x_end) { - return noOverlapRect; + int32_t y_end = std::min(rect1.posY_ + static_cast(rect1.height_), + rect2.posY_ + static_cast(rect2.height_)); + if (y_begin >= y_end || x_begin >= x_end) { + return { 0, 0, 0, 0 }; } - return { x_begin - offsetX, y_begin - offsetY, x_end - x_begin + 1, y_end - y_begin + 1 }; + return { x_begin - offsetX, y_begin - offsetY, + static_cast(x_end - x_begin), static_cast(y_end - y_begin) }; } static bool IsWindowModeSupported(uint32_t modeSupportInfo, WindowMode mode) diff --git a/wm/test/unittest/BUILD.gn b/wm/test/unittest/BUILD.gn index 48d9f1fc..a0b90166 100644 --- a/wm/test/unittest/BUILD.gn +++ b/wm/test/unittest/BUILD.gn @@ -19,6 +19,7 @@ group("unittest") { testonly = true deps = [ + ":avoid_area_controller_test", ":wm_input_transfer_station_test", ":wm_window_effect_test", ":wm_window_impl_test", diff --git a/wm/test/unittest/avoid_area_controller_test.cpp b/wm/test/unittest/avoid_area_controller_test.cpp index d213b5f9..96700164 100644 --- a/wm/test/unittest/avoid_area_controller_test.cpp +++ b/wm/test/unittest/avoid_area_controller_test.cpp @@ -16,7 +16,8 @@ #include "avoid_area_controller_test.h" #include "avoid_area_controller.h" #include "display_manager.h" -#include "mock_window_adapter.h" +#include "display_manager_config.h" +#include "future.h" #include "singleton_mocker.h" #include "window_node.h" @@ -29,45 +30,101 @@ namespace { constexpr HiviewDFX::HiLogLabel LABEL = {LOG_CORE, HILOG_DOMAIN_WINDOW, "AvoidAreaControllerTest"}; const Rect EMPTY_RECT = {0, 0, 0, 0}; - const uint32_t LEFT = 0; - const uint32_t TOP = 1; - const uint32_t RIGHT = 2; - const uint32_t BOTTOM = 3; const float BARRATIO = 0.3; + const long TIME_OUT = 1000; + const AvoidArea EMPTY_AVOID_AREA = {}; } -Rect AvoidAreaControllerTest::topAvoidRect_ = EMPTY_RECT; -Rect AvoidAreaControllerTest::leftAvoidRect_ = EMPTY_RECT; +sptr AvoidAreaControllerTest::statusbarWindowNode = nullptr; +sptr AvoidAreaControllerTest::navigationBarWindowNode = nullptr; +sptr AvoidAreaControllerTest::keyboardWindowNode = nullptr; +Rect AvoidAreaControllerTest::screenRect; +Rect AvoidAreaControllerTest::cut_out_rect = { 10, 10, 100, 20 }; -static bool RectEqualToRect(const Rect& l, const Rect& r) -{ - bool res = ((l.posX_ == r.posX_) && (l.posY_ == r.posY_) && (l.width_ == r.width_) && (l.height_ == r.height_)); - if (!res) { - WLOGFE(" [ x y w h]"); - WLOGFE("Expect:%{public}4d %{public}4d %{public}4u %{public}4u ", l.posX_, l.posY_, l.width_, l.height_); - WLOGFE("Get: %{public}4d %{public}4d %{public}4u %{public}4u ", r.posX_, r.posY_, r.width_, r.height_); +class WindowListener : public IWindow { +public: + void UpdateWindowRect(const struct Rect& rect, bool decoStatus, WindowSizeChangeReason reason) override {} + void UpdateWindowMode(WindowMode mode) override {} + void UpdateFocusStatus(bool focused) override {} + void UpdateAvoidArea(const sptr& avoidArea, AvoidAreaType type) override + { + if (type == AvoidAreaType::TYPE_SYSTEM) { + statusBarAvoidAreaFuture_.SetValue(*avoidArea); + } + if (type == AvoidAreaType::TYPE_CUTOUT) { + cutoutAvoidAreaFuture_.SetValue(*avoidArea); + } + if (type == AvoidAreaType::TYPE_KEYBOARD) { + keyboardAvoidAreaFuture_.SetValue(*avoidArea); + } } - return res; -} + void UpdateWindowModeSupportInfo(uint32_t modeSupportInfo) override {} + void UpdateWindowState(WindowState state) override {} + void UpdateWindowDragInfo(const PointInfo& point, DragEvent event) override {} + void UpdateDisplayId(DisplayId from, DisplayId to) override {} + void UpdateOccupiedAreaChangeInfo(const sptr& info) override {} + void UpdateActiveStatus(bool isActive) override {} + sptr GetWindowProperty() override + { + return nullptr; + } + void NotifyTouchOutside() override {} + void DumpInfo(const std::vector& params, std::vector& info) override {} + RunnableFuture statusBarAvoidAreaFuture_; + RunnableFuture keyboardAvoidAreaFuture_; + RunnableFuture cutoutAvoidAreaFuture_; -void AvoidAreaControllerTest::InitByScreenRect(const Rect& screenRect) -{ - topAvoidRect_ = {0, 0, screenRect.width_, - std::min(static_cast(screenRect.height_), static_cast(screenRect.width_ * BARRATIO))}; - // make sure leftAvoidRect h > w and w < screen.width. And use a bigger ratio to cover origin topAvoid - leftAvoidRect_ = {0, 0, - std::min(static_cast(screenRect.width_), static_cast(screenRect.height_ * BARRATIO)), - screenRect.height_}; -} + sptr AsObject() override + { + return nullptr; + } +}; void AvoidAreaControllerTest::SetUpTestCase() { - auto display = DisplayManager::GetInstance().GetDisplayById(0); + DisplayManagerConfig::LoadConfigXml(); + auto numbersConfig = DisplayManagerConfig::GetIntNumbersConfig(); + if (numbersConfig.count("cutoutArea") > 0) { + std::vector cutoutArea = numbersConfig["cutoutArea"]; + // 0, 1, 2, 3 means the index in the vector. + cut_out_rect = { cutoutArea[0], cutoutArea[1], (uint32_t)cutoutArea[2], (uint32_t)cutoutArea[3] }; + } + auto display = DisplayManager::GetInstance().GetDefaultDisplay(); ASSERT_TRUE((display != nullptr)); WLOGFI("GetDefaultDisplay: id %{public}" PRIu64", w %{public}d, h %{public}d, fps %{public}u", display->GetId(), display->GetWidth(), display->GetHeight(), display->GetRefreshRate()); - Rect screenRect = {0, 0, display->GetWidth(), display->GetHeight()}; - AvoidAreaControllerTest::InitByScreenRect(screenRect); + screenRect = { 0, 0, static_cast(display->GetWidth()), static_cast(display->GetHeight()) }; + auto barHeight = static_cast(screenRect.height_ * BARRATIO); + Rect statusBarRect = { 0, 0, screenRect.width_, barHeight }; + Rect navigationRect = { 0, static_cast(screenRect.height_ - barHeight), screenRect.width_, barHeight }; + + sptr statusbarProperty = new WindowProperty(); + statusbarProperty->SetWindowId(100u); + statusbarProperty->SetWindowName("status bar"); + statusbarProperty->SetWindowType(WindowType::WINDOW_TYPE_STATUS_BAR); + statusbarProperty->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING); + statusbarProperty->SetWindowRect(statusBarRect); + sptr windowListener = new WindowListener(); + statusbarWindowNode = new WindowNode(statusbarProperty, windowListener, nullptr); + + sptr navigationBarProperty = new WindowProperty(); + navigationBarProperty->SetWindowId(101u); + navigationBarProperty->SetWindowName("navigation bar"); + navigationBarProperty->SetWindowType(WindowType::WINDOW_TYPE_NAVIGATION_BAR); + navigationBarProperty->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING); + navigationBarProperty->SetWindowRect(navigationRect); + windowListener = new WindowListener(); + navigationBarWindowNode = new WindowNode(navigationBarProperty, windowListener, nullptr); + + sptr keyboardProperty = new WindowProperty(); + keyboardProperty->SetWindowId(101u); + keyboardProperty->SetWindowName("navigation bar"); + keyboardProperty->SetWindowType(WindowType::WINDOW_TYPE_INPUT_METHOD_FLOAT); + keyboardProperty->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING); + Rect keyboardRect = { 0, static_cast(screenRect.height_ / 2), screenRect.width_, screenRect.height_ / 2 }; + keyboardProperty->SetWindowRect(keyboardRect); + windowListener = new WindowListener(); + keyboardWindowNode = new WindowNode(keyboardProperty, windowListener, nullptr); } void AvoidAreaControllerTest::TearDownTestCase() @@ -82,275 +139,324 @@ void AvoidAreaControllerTest::TearDown() { } +#define CHECK_AVOID_AREA(avoidArea, topRect, leftRect, rightRect, bottomRect) \ + do { \ + ASSERT_EQ(avoidArea.topRect_, topRect); \ + ASSERT_EQ(avoidArea.bottomRect_, bottomRect); \ + ASSERT_EQ(avoidArea.leftRect_, leftRect); \ + ASSERT_EQ(avoidArea.rightRect_, rightRect); \ + } while (false) + + namespace { /** - * @tc.name: IsAvoidAreaNode01 - * @tc.desc: Create a APP Window. Test IsAvoidAreaNode + * @tc.name: SystemBarAndCutOutAvoidArea01 + * @tc.desc: Get avoid areas with TYPE_SYSTEM and TYPE_CUTOUT * @tc.type: FUNC */ -HWTEST_F(AvoidAreaControllerTest, IsAvoidAreaNode01, Function | SmallTest | Level2) +HWTEST_F(AvoidAreaControllerTest, SystemBarAndCutOutAvoidArea01, Function | SmallTest | Level2) { - auto avoidAreaController = new AvoidAreaController(0, nullptr); - - sptr node = new WindowNode(); sptr property = new WindowProperty(); - property->SetWindowId(100u); + property->SetWindowId(110u); + property->SetWindowName("test"); property->SetWindowType(WindowType::APP_WINDOW_BASE); - node->SetWindowProperty(property); + property->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN); + property->SetWindowRect(screenRect); + sptr listener = new WindowListener(); + sptr appWindow = new WindowNode(property, listener, nullptr); + uint32_t focusedWindow = appWindow->GetWindowId(); + sptr avoidAreaController = new AvoidAreaController(focusedWindow); + avoidAreaController->ProcessWindowChange(statusbarWindowNode, AvoidControlType::AVOID_NODE_ADD, nullptr); + avoidAreaController->ProcessWindowChange(navigationBarWindowNode, AvoidControlType::AVOID_NODE_ADD, nullptr); + avoidAreaController->ProcessWindowChange(appWindow, AvoidControlType::AVOID_NODE_ADD, nullptr); + auto avoidArea = avoidAreaController->GetAvoidAreaByType(appWindow, AvoidAreaType::TYPE_SYSTEM); + CHECK_AVOID_AREA(avoidArea, statusbarWindowNode->GetWindowRect(), + EMPTY_RECT, EMPTY_RECT, navigationBarWindowNode->GetWindowRect()); + avoidArea = avoidAreaController->GetAvoidAreaByType(appWindow, AvoidAreaType::TYPE_CUTOUT); + CHECK_AVOID_AREA(avoidArea, cut_out_rect, EMPTY_RECT, EMPTY_RECT, EMPTY_RECT); - ASSERT_EQ(false, avoidAreaController->IsAvoidAreaNode(node)); + // set rect + Rect statusBarRect = statusbarWindowNode->GetWindowRect(); + Rect navigationBarRect = navigationBarWindowNode->GetWindowRect(); + Rect windowRect = { 0, static_cast(statusBarRect.height_), statusBarRect.width_, + static_cast(navigationBarRect.posY_ - statusBarRect.height_) }; + property->SetWindowRect(windowRect); + avoidArea = avoidAreaController->GetAvoidAreaByType(appWindow, AvoidAreaType::TYPE_SYSTEM); + CHECK_AVOID_AREA(avoidArea, EMPTY_RECT, EMPTY_RECT, EMPTY_RECT, EMPTY_RECT); + avoidArea = avoidAreaController->GetAvoidAreaByType(appWindow, AvoidAreaType::TYPE_CUTOUT); + CHECK_AVOID_AREA(avoidArea, EMPTY_RECT, EMPTY_RECT, EMPTY_RECT, EMPTY_RECT); + + // restore rect + property->SetWindowRect(screenRect); + avoidArea = avoidAreaController->GetAvoidAreaByType(appWindow, AvoidAreaType::TYPE_SYSTEM); + CHECK_AVOID_AREA(avoidArea, statusbarWindowNode->GetWindowRect(), + EMPTY_RECT, EMPTY_RECT, navigationBarWindowNode->GetWindowRect()); + avoidArea = avoidAreaController->GetAvoidAreaByType(appWindow, AvoidAreaType::TYPE_CUTOUT); + CHECK_AVOID_AREA(avoidArea, cut_out_rect, EMPTY_RECT, EMPTY_RECT, EMPTY_RECT); + + avoidAreaController->ProcessWindowChange(statusbarWindowNode, AvoidControlType::AVOID_NODE_REMOVE, nullptr); + avoidAreaController->ProcessWindowChange(navigationBarWindowNode, AvoidControlType::AVOID_NODE_REMOVE, nullptr); + avoidAreaController->ProcessWindowChange(appWindow, AvoidControlType::AVOID_NODE_REMOVE, nullptr); + avoidArea = avoidAreaController->GetAvoidAreaByType(appWindow, AvoidAreaType::TYPE_SYSTEM); + CHECK_AVOID_AREA(avoidArea, EMPTY_RECT, EMPTY_RECT, EMPTY_RECT, EMPTY_RECT); } /** - * @tc.name: IsAvoidAreaNode02 - * @tc.desc: Create a Status Bar Window. Test IsAvoidAreaNode + * @tc.name: SystemBarAndCutOutAvoidArea02 + * @tc.desc: Get avoid areas with listener, TYPE_SYSTEM and TYPE_CUTOUT. * @tc.type: FUNC */ -HWTEST_F(AvoidAreaControllerTest, IsAvoidAreaNode02, Function | SmallTest | Level2) +HWTEST_F(AvoidAreaControllerTest, SystemBarAndCutOutAvoidArea02, Function | SmallTest | Level2) { - auto avoidAreaController = new AvoidAreaController(0, nullptr); - - sptr node = new WindowNode(); sptr property = new WindowProperty(); - property->SetWindowType(WindowType::WINDOW_TYPE_STATUS_BAR); - node->SetWindowProperty(property); + property->SetWindowId(110u); + property->SetWindowName("test"); + property->SetWindowType(WindowType::APP_WINDOW_BASE); + property->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN); + property->SetWindowRect(screenRect); + sptr windowListener = new WindowListener(); + sptr appWindow = new WindowNode(property, windowListener, nullptr); + uint32_t focusedWindow = appWindow->GetWindowId(); + sptr avoidAreaController = new AvoidAreaController(focusedWindow); + avoidAreaController->ProcessWindowChange(appWindow, AvoidControlType::AVOID_NODE_ADD, nullptr); + avoidAreaController->UpdateAvoidAreaListener(appWindow, true); - ASSERT_TRUE(avoidAreaController->IsAvoidAreaNode(node)); + // add status bar + avoidAreaController->ProcessWindowChange(statusbarWindowNode, AvoidControlType::AVOID_NODE_ADD, nullptr); + auto avoidArea = windowListener->statusBarAvoidAreaFuture_.GetResult(TIME_OUT); + windowListener->statusBarAvoidAreaFuture_.Reset(EMPTY_AVOID_AREA); + CHECK_AVOID_AREA(avoidArea, statusbarWindowNode->GetWindowRect(), EMPTY_RECT, EMPTY_RECT, EMPTY_RECT); + + // add navigation bar + avoidAreaController->ProcessWindowChange(navigationBarWindowNode, AvoidControlType::AVOID_NODE_ADD, nullptr); + avoidArea = windowListener->statusBarAvoidAreaFuture_.GetResult(TIME_OUT); + windowListener->statusBarAvoidAreaFuture_.Reset(EMPTY_AVOID_AREA); + CHECK_AVOID_AREA(avoidArea, statusbarWindowNode->GetWindowRect(), EMPTY_RECT, + EMPTY_RECT, navigationBarWindowNode->GetWindowRect()); + + // update appWindow rect + Rect statusBarRect = statusbarWindowNode->GetWindowRect(); + Rect navigationBarRect = navigationBarWindowNode->GetWindowRect(); + Rect windowRect = { 0, static_cast(statusBarRect.height_), statusBarRect.width_, + static_cast(navigationBarRect.posY_ - statusBarRect.height_) }; + property->SetWindowRect(windowRect); + avoidAreaController->ProcessWindowChange(appWindow, AvoidControlType::AVOID_NODE_UPDATE, nullptr); + avoidArea = windowListener->statusBarAvoidAreaFuture_.GetResult(TIME_OUT); + windowListener->statusBarAvoidAreaFuture_.Reset(EMPTY_AVOID_AREA); + CHECK_AVOID_AREA(avoidArea, EMPTY_RECT, EMPTY_RECT, EMPTY_RECT, EMPTY_RECT); + avoidArea = windowListener->cutoutAvoidAreaFuture_.GetResult(TIME_OUT); + windowListener->cutoutAvoidAreaFuture_.Reset(EMPTY_AVOID_AREA); + CHECK_AVOID_AREA(avoidArea, EMPTY_RECT, EMPTY_RECT, EMPTY_RECT, EMPTY_RECT); + + // restore appWindow rect + property->SetWindowRect(screenRect); + avoidAreaController->ProcessWindowChange(appWindow, AvoidControlType::AVOID_NODE_UPDATE, nullptr); + avoidArea = windowListener->statusBarAvoidAreaFuture_.GetResult(TIME_OUT); + windowListener->statusBarAvoidAreaFuture_.Reset(EMPTY_AVOID_AREA); + CHECK_AVOID_AREA(avoidArea, statusbarWindowNode->GetWindowRect(), + EMPTY_RECT, EMPTY_RECT, navigationBarWindowNode->GetWindowRect()); + avoidArea = windowListener->cutoutAvoidAreaFuture_.GetResult(TIME_OUT); + windowListener->cutoutAvoidAreaFuture_.Reset(EMPTY_AVOID_AREA); + CHECK_AVOID_AREA(avoidArea, cut_out_rect, EMPTY_RECT, EMPTY_RECT, EMPTY_RECT); + + avoidAreaController->ProcessWindowChange(statusbarWindowNode, AvoidControlType::AVOID_NODE_REMOVE, nullptr); + avoidAreaController->ProcessWindowChange(navigationBarWindowNode, AvoidControlType::AVOID_NODE_REMOVE, nullptr); + avoidAreaController->ProcessWindowChange(appWindow, AvoidControlType::AVOID_NODE_REMOVE, nullptr); } /** - * @tc.name: IsAvoidAreaNode03 - * @tc.desc: Create a Dock_Slice Window. Test IsAvoidAreaNode + * @tc.name: SystemBarAndCutOutAvoidArea03 + * @tc.desc: Get avoid areas with listener, TYPE_SYSTEM and TYPE_CUTOUT. * @tc.type: FUNC */ -HWTEST_F(AvoidAreaControllerTest, IsAvoidAreaNode03, Function | SmallTest | Level2) +HWTEST_F(AvoidAreaControllerTest, SystemBarAndCutOutAvoidArea03, Function | SmallTest | Level2) { - auto avoidAreaController = new AvoidAreaController(0, nullptr); - - sptr node = new WindowNode(); sptr property = new WindowProperty(); - property->SetWindowType(WindowType::WINDOW_TYPE_DOCK_SLICE); - node->SetWindowProperty(property); + property->SetWindowId(110u); + property->SetWindowName("test"); + property->SetWindowType(WindowType::APP_WINDOW_BASE); + property->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN); + property->SetWindowRect(screenRect); + sptr windowListener = new WindowListener(); + sptr appWindow = new WindowNode(property, windowListener, nullptr); + uint32_t focusedWindow = appWindow->GetWindowId(); + sptr avoidAreaController = new AvoidAreaController(focusedWindow); + avoidAreaController->ProcessWindowChange(appWindow, AvoidControlType::AVOID_NODE_ADD, nullptr); + avoidAreaController->UpdateAvoidAreaListener(appWindow, true); - ASSERT_EQ(false, avoidAreaController->IsAvoidAreaNode(node)); + // add status bar + avoidAreaController->ProcessWindowChange(statusbarWindowNode, AvoidControlType::AVOID_NODE_ADD, nullptr); + auto avoidArea = windowListener->statusBarAvoidAreaFuture_.GetResult(TIME_OUT); + windowListener->statusBarAvoidAreaFuture_.Reset(EMPTY_AVOID_AREA); + CHECK_AVOID_AREA(avoidArea, statusbarWindowNode->GetWindowRect(), EMPTY_RECT, EMPTY_RECT, EMPTY_RECT); + + // add navigation bar + avoidAreaController->ProcessWindowChange(navigationBarWindowNode, AvoidControlType::AVOID_NODE_ADD, nullptr); + avoidArea = windowListener->statusBarAvoidAreaFuture_.GetResult(TIME_OUT); + windowListener->statusBarAvoidAreaFuture_.Reset(EMPTY_AVOID_AREA); + CHECK_AVOID_AREA(avoidArea, statusbarWindowNode->GetWindowRect(), EMPTY_RECT, + EMPTY_RECT, navigationBarWindowNode->GetWindowRect()); + + // remove status bar + avoidAreaController->ProcessWindowChange(statusbarWindowNode, AvoidControlType::AVOID_NODE_REMOVE, nullptr); + avoidArea = windowListener->statusBarAvoidAreaFuture_.GetResult(TIME_OUT); + windowListener->statusBarAvoidAreaFuture_.Reset(EMPTY_AVOID_AREA); + CHECK_AVOID_AREA(avoidArea, EMPTY_RECT, EMPTY_RECT, EMPTY_RECT, navigationBarWindowNode->GetWindowRect()); + avoidArea = windowListener->cutoutAvoidAreaFuture_.GetResult(TIME_OUT); + windowListener->cutoutAvoidAreaFuture_.Reset(EMPTY_AVOID_AREA); + CHECK_AVOID_AREA(avoidArea, EMPTY_RECT, EMPTY_RECT, EMPTY_RECT, EMPTY_RECT); + + // remove navigation bar + avoidAreaController->ProcessWindowChange(navigationBarWindowNode, AvoidControlType::AVOID_NODE_REMOVE, nullptr); + avoidArea = windowListener->statusBarAvoidAreaFuture_.GetResult(TIME_OUT); + windowListener->statusBarAvoidAreaFuture_.Reset(EMPTY_AVOID_AREA); + CHECK_AVOID_AREA(avoidArea, EMPTY_RECT, EMPTY_RECT, EMPTY_RECT, EMPTY_RECT); + avoidAreaController->ProcessWindowChange(appWindow, AvoidControlType::AVOID_NODE_REMOVE, nullptr); } /** - * @tc.name: IsAvoidAreaNode04 - * @tc.desc: Create a Dock_Slice Window. Test IsAvoidAreaNode + * @tc.name: SystemBarAvoidArea01 + * @tc.desc: Get avoid areas with listener, TYPE_SYSTEM. * @tc.type: FUNC */ -HWTEST_F(AvoidAreaControllerTest, IsAvoidAreaNode04, Function | SmallTest | Level2) +HWTEST_F(AvoidAreaControllerTest, SystemBarAvoidArea01, Function | SmallTest | Level2) { - auto avoidAreaController = new AvoidAreaController(0, nullptr); - - ASSERT_EQ(false, avoidAreaController->IsAvoidAreaNode(nullptr)); -} - -/** - * @tc.name: AddAvoidAreaNode01 - * @tc.desc: Add a new avoid area Node - * @tc.type: FUNC - */ -HWTEST_F(AvoidAreaControllerTest, AddAvoidAreaNode01, Function | SmallTest | Level2) -{ - sptr node = new WindowNode(); - sptr property = new WindowProperty(); - property->SetWindowId(100u); - property->SetWindowType(WindowType::WINDOW_TYPE_STATUS_BAR); - node->SetWindowProperty(property); - node->SetWindowRect(topAvoidRect_); + property->SetWindowId(110u); + property->SetWindowName("test"); + property->SetWindowType(WindowType::APP_WINDOW_BASE); + property->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN); + property->SetWindowRect(screenRect); + sptr windowListener = new WindowListener(); + sptr appWindow = new WindowNode(property, windowListener, nullptr); + uint32_t focusedWindow = appWindow->GetWindowId(); + sptr avoidAreaController = new AvoidAreaController(focusedWindow); + avoidAreaController->ProcessWindowChange(statusbarWindowNode, AvoidControlType::AVOID_NODE_ADD, nullptr); + avoidAreaController->ProcessWindowChange(navigationBarWindowNode, AvoidControlType::AVOID_NODE_ADD, nullptr); + avoidAreaController->ProcessWindowChange(appWindow, AvoidControlType::AVOID_NODE_ADD, nullptr); + avoidAreaController->UpdateAvoidAreaListener(appWindow, true); - sptr avoidAreaController = new AvoidAreaController(0, nullptr); - ASSERT_EQ(WMError::WM_OK, avoidAreaController->AvoidControl(node, AvoidControlType::AVOID_NODE_ADD)); + // update status bar window Rect + Rect statusbarWindowNodeRect = statusbarWindowNode->GetWindowRect(); + statusbarWindowNode->SetWindowRect(EMPTY_RECT); + avoidAreaController->ProcessWindowChange(statusbarWindowNode, AvoidControlType::AVOID_NODE_UPDATE, + [](sptr windowNode) { return true; }); + auto avoidArea = windowListener->statusBarAvoidAreaFuture_.GetResult(TIME_OUT); + windowListener->statusBarAvoidAreaFuture_.Reset(EMPTY_AVOID_AREA); + CHECK_AVOID_AREA(avoidArea, EMPTY_RECT, EMPTY_RECT, EMPTY_RECT, navigationBarWindowNode->GetWindowRect()); + + // update navigation bar window Rect + Rect navigationBarWindowNodeRect = navigationBarWindowNode->GetWindowRect(); + navigationBarWindowNode->SetWindowRect(EMPTY_RECT); + avoidAreaController->ProcessWindowChange(navigationBarWindowNode, AvoidControlType::AVOID_NODE_UPDATE, + [](sptr windowNode) { return true; }); + avoidArea = windowListener->statusBarAvoidAreaFuture_.GetResult(TIME_OUT); + windowListener->statusBarAvoidAreaFuture_.Reset(EMPTY_AVOID_AREA); + CHECK_AVOID_AREA(avoidArea, EMPTY_RECT, EMPTY_RECT, EMPTY_RECT, EMPTY_RECT); + + // restore status bar window Rect + statusbarWindowNode->SetWindowRect(statusbarWindowNodeRect); + avoidAreaController->ProcessWindowChange(appWindow, AvoidControlType::AVOID_NODE_UPDATE, nullptr); + avoidArea = windowListener->statusBarAvoidAreaFuture_.GetResult(TIME_OUT); + windowListener->statusBarAvoidAreaFuture_.Reset(EMPTY_AVOID_AREA); + CHECK_AVOID_AREA(avoidArea, statusbarWindowNode->GetWindowRect(), EMPTY_RECT, EMPTY_RECT, EMPTY_RECT); + + // restore navigation bar window Rect + navigationBarWindowNode->SetWindowRect(navigationBarWindowNodeRect); + avoidAreaController->ProcessWindowChange(appWindow, AvoidControlType::AVOID_NODE_UPDATE, nullptr); + avoidArea = windowListener->statusBarAvoidAreaFuture_.GetResult(TIME_OUT); + windowListener->statusBarAvoidAreaFuture_.Reset(EMPTY_AVOID_AREA); + CHECK_AVOID_AREA(avoidArea, statusbarWindowNode->GetWindowRect(), EMPTY_RECT, + EMPTY_RECT, navigationBarWindowNode->GetWindowRect()); + + // remove status bar + avoidAreaController->ProcessWindowChange(statusbarWindowNode, AvoidControlType::AVOID_NODE_REMOVE, nullptr); + avoidArea = windowListener->statusBarAvoidAreaFuture_.GetResult(TIME_OUT); + windowListener->statusBarAvoidAreaFuture_.Reset(EMPTY_AVOID_AREA); + CHECK_AVOID_AREA(avoidArea, EMPTY_RECT, EMPTY_RECT, EMPTY_RECT, navigationBarWindowNode->GetWindowRect()); + + // remove navigation bar + avoidAreaController->ProcessWindowChange(navigationBarWindowNode, AvoidControlType::AVOID_NODE_REMOVE, nullptr); + avoidArea = windowListener->statusBarAvoidAreaFuture_.GetResult(TIME_OUT); + windowListener->statusBarAvoidAreaFuture_.Reset(EMPTY_AVOID_AREA); + CHECK_AVOID_AREA(avoidArea, EMPTY_RECT, EMPTY_RECT, EMPTY_RECT, EMPTY_RECT); } /** - * @tc.name: AddAvoidAreaNode02 - * @tc.desc: Add a exist avoid area Node + * @tc.name: KeyboardAvoidArea01 + * @tc.desc: Get avoid areas with TYPE_KEYBOARD. * @tc.type: FUNC */ -HWTEST_F(AvoidAreaControllerTest, AddAvoidAreaNode02, Function | SmallTest | Level2) +HWTEST_F(AvoidAreaControllerTest, KeyboardAvoidArea01, Function | SmallTest | Level2) { - sptr avoidAreaController = new AvoidAreaController(0, nullptr); - - sptr node1 = new WindowNode(); - sptr property1 = new WindowProperty(); - property1->SetWindowId(100u); - property1->SetWindowType(WindowType::WINDOW_TYPE_STATUS_BAR); - property1->SetWindowRect(topAvoidRect_); - node1->SetWindowProperty(property1); - node1->SetWindowRect(topAvoidRect_); - ASSERT_EQ(WMError::WM_OK, avoidAreaController->AvoidControl(node1, AvoidControlType::AVOID_NODE_ADD)); - - sptr node2 = new WindowNode(); - sptr property2 = new WindowProperty(); - property2->SetWindowId(100u); - property2->SetWindowType(WindowType::WINDOW_TYPE_STATUS_BAR); - node2->SetWindowProperty(property2); - node2->SetWindowRect(topAvoidRect_); - ASSERT_EQ(WMError::WM_ERROR_INVALID_PARAM, - avoidAreaController->AvoidControl(node2, AvoidControlType::AVOID_NODE_ADD)); -} - -/** - * @tc.name: AddAvoidAreaNode03 - * @tc.desc: Add two new avoid area Nodes - * @tc.type: FUNC - */ -HWTEST_F(AvoidAreaControllerTest, AddAvoidAreaNode03, Function | SmallTest | Level2) -{ - sptr avoidAreaController = new AvoidAreaController(0, nullptr); - - sptr node1 = new WindowNode(); - sptr property1 = new WindowProperty(); - property1->SetWindowId(100u); - property1->SetWindowType(WindowType::WINDOW_TYPE_STATUS_BAR); - node1->SetWindowProperty(property1); - node1->SetWindowRect(topAvoidRect_); - ASSERT_EQ(WMError::WM_OK, avoidAreaController->AvoidControl(node1, AvoidControlType::AVOID_NODE_ADD)); - - sptr node2 = new WindowNode(); - sptr property2 = new WindowProperty(); - property2->SetWindowId(101u); - property2->SetWindowType(WindowType::WINDOW_TYPE_STATUS_BAR); - node2->SetWindowProperty(property2); - node2->SetWindowRect(leftAvoidRect_); - ASSERT_EQ(WMError::WM_OK, avoidAreaController->AvoidControl(node2, AvoidControlType::AVOID_NODE_ADD)); -} - -/** - * @tc.name: AddAvoidAreaNode04 - * @tc.desc: Add nullptr - * @tc.type: FUNC - */ -HWTEST_F(AvoidAreaControllerTest, AddAvoidAreaNode04, Function | SmallTest | Level2) -{ - sptr avoidAreaController = new AvoidAreaController(0, nullptr); - ASSERT_EQ(WMError::WM_ERROR_INVALID_PARAM, - avoidAreaController->AvoidControl(nullptr, AvoidControlType::AVOID_NODE_ADD)); -} - -/** - * @tc.name: RemoveAvoidAreaNode01 - * @tc.desc: Add a new avoid area. And Remove this. - * @tc.type: FUNC - */ -HWTEST_F(AvoidAreaControllerTest, RemoveAvoidAreaNode01, Function | SmallTest | Level2) -{ - sptr avoidAreaController = new AvoidAreaController(0, nullptr); - - sptr node1 = new WindowNode(); - sptr property1 = new WindowProperty(); - property1->SetWindowId(100u); - property1->SetWindowType(WindowType::WINDOW_TYPE_STATUS_BAR); - node1->SetWindowProperty(property1); - node1->SetWindowRect(leftAvoidRect_); - ASSERT_EQ(WMError::WM_OK, avoidAreaController->AvoidControl(node1, AvoidControlType::AVOID_NODE_ADD)); - - ASSERT_EQ(WMError::WM_OK, avoidAreaController->AvoidControl(node1, AvoidControlType::AVOID_NODE_REMOVE)); -} - -/** - * @tc.name: RemoveAvoidAreaNode02 - * @tc.desc: Remove a unexist avoid area. - * @tc.type: FUNC - */ -HWTEST_F(AvoidAreaControllerTest, RemoveAvoidAreaNode02, Function | SmallTest | Level2) -{ - sptr avoidAreaController = new AvoidAreaController(0, nullptr); - - sptr node = new WindowNode(); sptr property = new WindowProperty(); - property->SetWindowId(100u); - property->SetWindowType(WindowType::WINDOW_TYPE_STATUS_BAR); - node->SetWindowRect(topAvoidRect_); - node->SetWindowProperty(property); - ASSERT_EQ(WMError::WM_ERROR_INVALID_PARAM, - avoidAreaController->AvoidControl(node, AvoidControlType::AVOID_NODE_REMOVE)); + property->SetWindowId(110u); + property->SetWindowName("test"); + property->SetWindowType(WindowType::APP_WINDOW_BASE); + property->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN); + property->SetWindowRect(screenRect); + sptr listener = new WindowListener(); + sptr appWindow = new WindowNode(property, listener, nullptr); + uint32_t focusedWindow = 0u; + sptr avoidAreaController = new AvoidAreaController(focusedWindow); + avoidAreaController->ProcessWindowChange(appWindow, AvoidControlType::AVOID_NODE_ADD, nullptr); + + uint32_t start = static_cast(WindowMode::WINDOW_MODE_FULLSCREEN); + uint32_t end = static_cast(WindowMode::WINDOW_MODE_FLOATING); + for (uint32_t i = start; i <= end; i++) { + focusedWindow = 0u; + appWindow->SetWindowMode(static_cast(i)); + avoidAreaController->ProcessWindowChange(keyboardWindowNode, AvoidControlType::AVOID_NODE_ADD, nullptr); + auto avoidArea = avoidAreaController->GetAvoidAreaByType(appWindow, AvoidAreaType::TYPE_KEYBOARD); + CHECK_AVOID_AREA(avoidArea, EMPTY_RECT, EMPTY_RECT, EMPTY_RECT, EMPTY_RECT); + + keyboardWindowNode->SetCallingWindow(appWindow->GetWindowId()); + avoidArea = avoidAreaController->GetAvoidAreaByType(appWindow, AvoidAreaType::TYPE_KEYBOARD); + CHECK_AVOID_AREA(avoidArea, EMPTY_RECT, EMPTY_RECT, EMPTY_RECT, keyboardWindowNode->GetWindowRect()); + + keyboardWindowNode->SetCallingWindow(0); + focusedWindow = appWindow->GetWindowId(); + avoidArea = avoidAreaController->GetAvoidAreaByType(appWindow, AvoidAreaType::TYPE_KEYBOARD); + CHECK_AVOID_AREA(avoidArea, EMPTY_RECT, EMPTY_RECT, EMPTY_RECT, keyboardWindowNode->GetWindowRect()); + + avoidAreaController->ProcessWindowChange(keyboardWindowNode, AvoidControlType::AVOID_NODE_REMOVE, nullptr); + avoidArea = avoidAreaController->GetAvoidAreaByType(appWindow, AvoidAreaType::TYPE_KEYBOARD); + CHECK_AVOID_AREA(avoidArea, EMPTY_RECT, EMPTY_RECT, EMPTY_RECT, EMPTY_RECT); + } } /** - * @tc.name: RemoveAvoidAreaNode03 - * @tc.desc: Remove nullptr + * @tc.name: KeyboardAvoidArea02 + * @tc.desc: Get avoid areas with listener, TYPE_KEYBOARD. * @tc.type: FUNC */ -HWTEST_F(AvoidAreaControllerTest, RemoveAvoidAreaNode03, Function | SmallTest | Level2) +HWTEST_F(AvoidAreaControllerTest, KeyboardAvoidArea02, Function | SmallTest | Level2) { - sptr avoidAreaController = new AvoidAreaController(0, nullptr); - ASSERT_EQ(WMError::WM_ERROR_INVALID_PARAM, - avoidAreaController->AvoidControl(nullptr, AvoidControlType::AVOID_NODE_REMOVE)); -} - -/** - * @tc.name: UpdateAvoidAreaNode01 - * @tc.desc: Add a new avoid area node and update this - * @tc.type: FUNC - */ -HWTEST_F(AvoidAreaControllerTest, UpdateAvoidAreaNode01, Function | SmallTest | Level2) -{ - sptr avoidAreaController = new AvoidAreaController(0, nullptr); - - sptr node = new WindowNode(); sptr property = new WindowProperty(); - property->SetWindowId(100u); - property->SetWindowType(WindowType::WINDOW_TYPE_STATUS_BAR); - node->SetWindowProperty(property); - node->SetWindowRect(topAvoidRect_); - ASSERT_EQ(WMError::WM_OK, avoidAreaController->AvoidControl(node, AvoidControlType::AVOID_NODE_ADD)); - - property->SetWindowRect(leftAvoidRect_); - ASSERT_EQ(WMError::WM_OK, avoidAreaController->AvoidControl(node, AvoidControlType::AVOID_NODE_UPDATE)); -} - -/** - * @tc.name: UpdateAvoidAreaNode02 - * @tc.desc: update a unexist avoid area node - * @tc.type: FUNC - */ -HWTEST_F(AvoidAreaControllerTest, UpdateAvoidAreaNode02, Function | SmallTest | Level2) -{ - sptr avoidAreaController = new AvoidAreaController(0, nullptr); - - sptr node = new WindowNode(); - sptr property = new WindowProperty(); - property->SetWindowId(100u); - property->SetWindowType(WindowType::WINDOW_TYPE_STATUS_BAR); - node->SetWindowProperty(property); - node->SetWindowRect(topAvoidRect_); - - ASSERT_EQ(WMError::WM_ERROR_INVALID_PARAM, - avoidAreaController->AvoidControl(node, AvoidControlType::AVOID_NODE_UPDATE)); -} - -/** - * @tc.name: UpdateAvoidAreaNode03 - * @tc.desc: Update nullptr - * @tc.type: FUNC - */ -HWTEST_F(AvoidAreaControllerTest, UpdateAvoidAreaNode03, Function | SmallTest | Level2) -{ - sptr avoidAreaController = new AvoidAreaController(0, nullptr); - ASSERT_EQ(WMError::WM_ERROR_INVALID_PARAM, - avoidAreaController->AvoidControl(nullptr, AvoidControlType::AVOID_NODE_UPDATE)); -} - -/** - * @tc.name: GetAvoidAreaByType01 - * @tc.desc: Search a unexist AvoidAreaType. And GetAvoidAreaByType - * @tc.type: FUNC - */ -HWTEST_F(AvoidAreaControllerTest, GetAvoidAreaByType01, Function | SmallTest | Level2) -{ - sptr avoidAreaController = new AvoidAreaController(0, nullptr); - std::vector avoidArea = avoidAreaController->GetAvoidAreaByType(AvoidAreaType::TYPE_CUTOUT, displayId_); - - ASSERT_EQ(4u, static_cast(avoidArea.size())); - ASSERT_TRUE(RectEqualToRect(EMPTY_RECT, avoidArea[LEFT])); - ASSERT_TRUE(RectEqualToRect(EMPTY_RECT, avoidArea[TOP])); - ASSERT_TRUE(RectEqualToRect(EMPTY_RECT, avoidArea[RIGHT])); - ASSERT_TRUE(RectEqualToRect(EMPTY_RECT, avoidArea[BOTTOM])); + property->SetWindowId(110u); + property->SetWindowName("test"); + property->SetWindowType(WindowType::APP_WINDOW_BASE); + property->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN); + property->SetWindowRect(screenRect); + sptr listener = new WindowListener(); + sptr appWindow = new WindowNode(property, listener, nullptr); + uint32_t focusedWindow = appWindow->GetWindowId(); + sptr avoidAreaController = new AvoidAreaController(focusedWindow); + avoidAreaController->ProcessWindowChange(appWindow, AvoidControlType::AVOID_NODE_ADD, nullptr); + avoidAreaController->UpdateAvoidAreaListener(appWindow, true); + uint32_t start = static_cast(WindowMode::WINDOW_MODE_FULLSCREEN); + uint32_t end = static_cast(WindowMode::WINDOW_MODE_FLOATING); + for (uint32_t i = start; i <= end; i++) { + avoidAreaController->ProcessWindowChange(keyboardWindowNode, AvoidControlType::AVOID_NODE_ADD, nullptr); + auto avoidArea = listener->keyboardAvoidAreaFuture_.GetResult(TIME_OUT); + listener->keyboardAvoidAreaFuture_.Reset(EMPTY_AVOID_AREA); + CHECK_AVOID_AREA(avoidArea, EMPTY_RECT, EMPTY_RECT, EMPTY_RECT, keyboardWindowNode->GetWindowRect()); + avoidAreaController->ProcessWindowChange(keyboardWindowNode, AvoidControlType::AVOID_NODE_REMOVE, nullptr); + avoidArea = listener->keyboardAvoidAreaFuture_.GetResult(TIME_OUT); + listener->keyboardAvoidAreaFuture_.Reset(EMPTY_AVOID_AREA); + CHECK_AVOID_AREA(avoidArea, EMPTY_RECT, EMPTY_RECT, EMPTY_RECT, EMPTY_RECT); + } + avoidAreaController->ProcessWindowChange(appWindow, AvoidControlType::AVOID_NODE_REMOVE, nullptr); } } } // namespace Rosen diff --git a/wm/test/unittest/avoid_area_controller_test.h b/wm/test/unittest/avoid_area_controller_test.h index 91ed6623..4d5f6fed 100644 --- a/wm/test/unittest/avoid_area_controller_test.h +++ b/wm/test/unittest/avoid_area_controller_test.h @@ -17,6 +17,7 @@ #define FRAMEWORKS_WM_TEST_UT_AVOID_AREA_CONTROLLER_TEST_H #include +#include "window_node.h" #include "wm_common.h" namespace OHOS { @@ -28,12 +29,11 @@ public: virtual void SetUp() override; virtual void TearDown() override; - static Rect topAvoidRect_; - static Rect leftAvoidRect_; - -private: - static void InitByScreenRect(const Rect& screenRect); - DisplayId displayId_ = 0; + static sptr statusbarWindowNode; + static sptr navigationBarWindowNode; + static sptr keyboardWindowNode; + static Rect screenRect; + static Rect cut_out_rect; }; } // namespace ROSEN } // namespace OHOS diff --git a/wmserver/src/avoid_area_controller.cpp b/wmserver/src/avoid_area_controller.cpp index a173696c..40a8869f 100644 --- a/wmserver/src/avoid_area_controller.cpp +++ b/wmserver/src/avoid_area_controller.cpp @@ -121,10 +121,8 @@ void AvoidAreaController::AddOrRemoveKeyboard(const sptr& keyboardNo } if (lastKeyboardAreaUpdatedWindow != nullptr && lastKeyboardAreaUpdatedWindow != callingWindow) { const WindowMode windowMode = lastKeyboardAreaUpdatedWindow->GetWindowMode(); - if (windowMode == WindowMode::WINDOW_MODE_FULLSCREEN || - windowMode == WindowMode::WINDOW_MODE_SPLIT_PRIMARY || - windowMode == WindowMode::WINDOW_MODE_SPLIT_SECONDARY || - windowMode == WindowMode::WINDOW_MODE_FLOATING) { + if (windowMode == WindowMode::WINDOW_MODE_FULLSCREEN || windowMode == WindowMode::WINDOW_MODE_SPLIT_PRIMARY || + windowMode == WindowMode::WINDOW_MODE_SPLIT_SECONDARY || windowMode == WindowMode::WINDOW_MODE_FLOATING) { auto avoidArea = GetAvoidAreaByType(lastKeyboardAreaUpdatedWindow, AvoidAreaType::TYPE_KEYBOARD); UpdateAvoidAreaIfNeed(avoidArea, lastKeyboardAreaUpdatedWindow, AvoidAreaType::TYPE_KEYBOARD); } @@ -171,7 +169,7 @@ void AvoidAreaController::UpdateOverlayWindowIfNeed(const sptr& node } uint32_t start = static_cast(AvoidAreaType::TYPE_SYSTEM); uint32_t end = static_cast(AvoidAreaType::TYPE_KEYBOARD); - for (int type = start; type <= end; type++) { + for (uint32_t type = start; type <= end; type++) { AvoidArea systemAvoidArea = GetAvoidAreaByType(node, static_cast(type)); bool res = UpdateAvoidAreaIfNeed(systemAvoidArea, node, static_cast(type)); if (res && type == static_cast(AvoidAreaType::TYPE_KEYBOARD)) { @@ -292,6 +290,7 @@ AvoidArea AvoidAreaController::GetAvoidAreaByType(const sptr& node, case AvoidAreaType::TYPE_CUTOUT : { auto numbersConfig = DisplayManagerConfig::GetIntNumbersConfig(); if (numbersConfig.count("cutoutArea") == 0) { + WLOGFE("there is no cutout"); return {}; } std::vector cutoutArea = numbersConfig["cutoutArea"]; @@ -335,10 +334,6 @@ AvoidArea AvoidAreaController::GetAvoidAreaSystemType(const sptr& no AvoidArea AvoidAreaController::GetAvoidAreaKeyboardType(const sptr& node) const { - if (focusedWindow_ != node->GetWindowId()) { - WLOGFI("focusedWindow: %{public}u is not windowId: %{public}u", focusedWindow_, node->GetWindowId()); - return {}; - } for (auto& iter : overlayWindowMap_) { if (iter.second != nullptr && iter.second->GetWindowType() == WindowType::WINDOW_TYPE_INPUT_METHOD_FLOAT) { @@ -348,7 +343,7 @@ AvoidArea AvoidAreaController::GetAvoidAreaKeyboardType(const sptr& node->GetWindowId(), focusedWindow_, callingWindowId); continue; } - Rect avoidAreaRect; + Rect avoidAreaRect { 0, 0, 0, 0 }; AvoidPosType avoidPosType = CalculateOverlayRect(node, iter.second, avoidAreaRect); AvoidArea avoidArea; SetAvoidAreaRect(avoidArea, avoidAreaRect, avoidPosType);