fix avoid_area_controller_test bug

Signed-off-by: xiaojianfeng <xiaojianfeng3@huawei.com> Change-Id: I85e37864aeb8a2d5402fd3704d05b03317165928
2026-07-20 01:13:32 -04:00 · 2022-06-29 20:05:18 +08:00
parent 103316c999
commit 94b8845aba
5 changed files with 378 additions and 274 deletions
@@ -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<int32_t>(rect1.width_),
+            rect2.posX_ + static_cast<int32_t>(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<int32_t>(rect1.height_),
+            rect2.posY_ + static_cast<int32_t>(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<uint32_t>(x_end - x_begin), static_cast<uint32_t>(y_end - y_begin) };
    }

    static bool IsWindowModeSupported(uint32_t modeSupportInfo, WindowMode mode)
@@ -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",
@@ -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<WindowNode> AvoidAreaControllerTest::statusbarWindowNode = nullptr;
+sptr<WindowNode> AvoidAreaControllerTest::navigationBarWindowNode = nullptr;
+sptr<WindowNode> 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>& 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<OccupiedAreaChangeInfo>& info) override {}
+    void UpdateActiveStatus(bool isActive) override {}
+    sptr<WindowProperty> GetWindowProperty() override
+    {
+        return nullptr;
+    }
+    void NotifyTouchOutside() override {}
+    void DumpInfo(const std::vector<std::string>& params, std::vector<std::string>& info) override {}
+    RunnableFuture<AvoidArea> statusBarAvoidAreaFuture_;
+    RunnableFuture<AvoidArea> keyboardAvoidAreaFuture_;
+    RunnableFuture<AvoidArea> cutoutAvoidAreaFuture_;

-void AvoidAreaControllerTest::InitByScreenRect(const Rect& screenRect)
-{
-    topAvoidRect_ = {0, 0, screenRect.width_,
-        std::min(static_cast<uint32_t>(screenRect.height_), static_cast<uint32_t>(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<uint32_t>(screenRect.width_), static_cast<uint32_t>(screenRect.height_ * BARRATIO)),
-        screenRect.height_};
-}
+    sptr<IRemoteObject> 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<int> 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<uint32_t>(display->GetWidth()), static_cast<uint32_t>(display->GetHeight()) };
+    auto barHeight = static_cast<uint32_t>(screenRect.height_ * BARRATIO);
+    Rect statusBarRect = { 0, 0, screenRect.width_, barHeight };
+    Rect navigationRect = { 0, static_cast<int32_t>(screenRect.height_ - barHeight), screenRect.width_, barHeight };
+
+    sptr<WindowProperty> 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> windowListener = new WindowListener();
+    statusbarWindowNode = new WindowNode(statusbarProperty, windowListener, nullptr);
+
+    sptr<WindowProperty> 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<WindowProperty> 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<int32_t>(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<WindowNode> node = new WindowNode();
    sptr<WindowProperty> 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<WindowListener> listener = new WindowListener();
+    sptr<WindowNode> appWindow = new WindowNode(property, listener, nullptr);
+    uint32_t focusedWindow = appWindow->GetWindowId();
+    sptr<AvoidAreaController> 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<int32_t>(statusBarRect.height_), statusBarRect.width_,
+        static_cast<uint32_t>(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<WindowNode> node = new WindowNode();
    sptr<WindowProperty> 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> windowListener = new WindowListener();
+    sptr<WindowNode> appWindow = new WindowNode(property, windowListener, nullptr);
+    uint32_t focusedWindow = appWindow->GetWindowId();
+    sptr<AvoidAreaController> 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<int32_t>(statusBarRect.height_), statusBarRect.width_,
+        static_cast<uint32_t>(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<WindowNode> node = new WindowNode();
    sptr<WindowProperty> 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> windowListener = new WindowListener();
+    sptr<WindowNode> appWindow = new WindowNode(property, windowListener, nullptr);
+    uint32_t focusedWindow = appWindow->GetWindowId();
+    sptr<AvoidAreaController> 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<WindowNode> node = new WindowNode();
-
    sptr<WindowProperty> 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> windowListener = new WindowListener();
+    sptr<WindowNode> appWindow = new WindowNode(property, windowListener, nullptr);
+    uint32_t focusedWindow = appWindow->GetWindowId();
+    sptr<AvoidAreaController> 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> 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> 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> 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> avoidAreaController = new AvoidAreaController(0, nullptr);
-
-    sptr<WindowNode> node1 = new WindowNode();
-    sptr<WindowProperty> 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<WindowNode> node2 = new WindowNode();
-    sptr<WindowProperty> 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> avoidAreaController = new AvoidAreaController(0, nullptr);
-
-    sptr<WindowNode> node1 = new WindowNode();
-    sptr<WindowProperty> 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<WindowNode> node2 = new WindowNode();
-    sptr<WindowProperty> 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> 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> avoidAreaController = new AvoidAreaController(0, nullptr);
-
-    sptr<WindowNode> node1 = new WindowNode();
-    sptr<WindowProperty> 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> avoidAreaController = new AvoidAreaController(0, nullptr);
-
-    sptr<WindowNode> node = new WindowNode();
    sptr<WindowProperty> 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<WindowListener> listener = new WindowListener();
+    sptr<WindowNode> appWindow = new WindowNode(property, listener, nullptr);
+    uint32_t focusedWindow = 0u;
+    sptr<AvoidAreaController> avoidAreaController = new AvoidAreaController(focusedWindow);
+    avoidAreaController->ProcessWindowChange(appWindow, AvoidControlType::AVOID_NODE_ADD, nullptr);
+
+    uint32_t start = static_cast<uint32_t>(WindowMode::WINDOW_MODE_FULLSCREEN);
+    uint32_t end = static_cast<uint32_t>(WindowMode::WINDOW_MODE_FLOATING);
+    for (uint32_t i = start; i <= end; i++) {
+        focusedWindow = 0u;
+        appWindow->SetWindowMode(static_cast<WindowMode>(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> 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> avoidAreaController = new AvoidAreaController(0, nullptr);
-
-    sptr<WindowNode> node = new WindowNode();
    sptr<WindowProperty> 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> avoidAreaController = new AvoidAreaController(0, nullptr);
-
-    sptr<WindowNode> node = new WindowNode();
-    sptr<WindowProperty> 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> 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> avoidAreaController = new AvoidAreaController(0, nullptr);
-    std::vector<Rect> avoidArea = avoidAreaController->GetAvoidAreaByType(AvoidAreaType::TYPE_CUTOUT, displayId_);
-
-    ASSERT_EQ(4u, static_cast<uint32_t>(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<WindowListener> listener = new WindowListener();
+    sptr<WindowNode> appWindow = new WindowNode(property, listener, nullptr);
+    uint32_t focusedWindow = appWindow->GetWindowId();
+    sptr<AvoidAreaController> avoidAreaController = new AvoidAreaController(focusedWindow);
+    avoidAreaController->ProcessWindowChange(appWindow, AvoidControlType::AVOID_NODE_ADD, nullptr);
+    avoidAreaController->UpdateAvoidAreaListener(appWindow, true);
+    uint32_t start = static_cast<uint32_t>(WindowMode::WINDOW_MODE_FULLSCREEN);
+    uint32_t end = static_cast<uint32_t>(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
@@ -17,6 +17,7 @@
 #define FRAMEWORKS_WM_TEST_UT_AVOID_AREA_CONTROLLER_TEST_H

 #include <gtest/gtest.h>
+#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<WindowNode> statusbarWindowNode;
+    static sptr<WindowNode> navigationBarWindowNode;
+    static sptr<WindowNode> keyboardWindowNode;
+    static Rect screenRect;
+    static Rect cut_out_rect;
 };
 } // namespace ROSEN
 } // namespace OHOS
@@ -121,10 +121,8 @@ void AvoidAreaController::AddOrRemoveKeyboard(const sptr<WindowNode>& 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<WindowNode>& node
        }
        uint32_t start = static_cast<uint32_t>(AvoidAreaType::TYPE_SYSTEM);
        uint32_t end = static_cast<uint32_t>(AvoidAreaType::TYPE_KEYBOARD);
-        for (int type = start; type <= end; type++) {
+        for (uint32_t type = start; type <= end; type++) {
            AvoidArea systemAvoidArea = GetAvoidAreaByType(node, static_cast<AvoidAreaType>(type));
            bool res = UpdateAvoidAreaIfNeed(systemAvoidArea, node, static_cast<AvoidAreaType>(type));
            if (res && type == static_cast<uint32_t>(AvoidAreaType::TYPE_KEYBOARD)) {
@@ -292,6 +290,7 @@ AvoidArea AvoidAreaController::GetAvoidAreaByType(const sptr<WindowNode>& node,
        case AvoidAreaType::TYPE_CUTOUT : {
            auto numbersConfig = DisplayManagerConfig::GetIntNumbersConfig();
            if (numbersConfig.count("cutoutArea") == 0) {
+                WLOGFE("there is no cutout");
                return {};
            }
            std::vector<int> cutoutArea = numbersConfig["cutoutArea"];
@@ -335,10 +334,6 @@ AvoidArea AvoidAreaController::GetAvoidAreaSystemType(const sptr<WindowNode>& no

 AvoidArea AvoidAreaController::GetAvoidAreaKeyboardType(const sptr<WindowNode>& 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<WindowNode>&
                       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);