adapter window interface change

Signed-off-by: yichengzhao <yichengzhao1@huawei.com>
Change-Id: I5a685c42cfa93cd7623afcc405ee51e2dc3705af

services/aams/include/accessibility_window_manager.h

@@ -29,9 +29,9 @@ class AccessibilityWindowManager {
     DECLARE_SINGLETON(AccessibilityWindowManager)
 public:
     bool Init();
-    static AccessibilityWindowInfo CreateAccessibilityWindowInfo(const sptr<Rosen::WindowInfo> windowInfo);
+    static AccessibilityWindowInfo CreateAccessibilityWindowInfo(const sptr<Rosen::AccessibilityWindowInfo> windowInfo);
     static void UpdateAccessibilityWindowInfo(AccessibilityWindowInfo &accWindowInfo,
-        const sptr<Rosen::WindowInfo> windowInfo);
+        const sptr<Rosen::AccessibilityWindowInfo> windowInfo);
     int32_t ConvertToRealWindowId(int32_t windowId, int32_t focusType);
     void RegisterWindowListener(const std::shared_ptr<AppExecFwk::EventHandler> &handler);
     void DeregisterWindowListener();
@@ -43,9 +43,8 @@ public:
 
     // test for ut to resize a window
     void SetWindowSize(int32_t windowId, Rect rect);
-    void UpdateWindowLayer(const sptr<Rosen::AccessibilityWindowInfo>& windowInfo);
 
-    void OnWindowUpdate(const sptr<Rosen::AccessibilityWindowInfo>& windowInfo, Rosen::WindowUpdateType type);
+    void OnWindowUpdate(const std::vector<sptr<Rosen::AccessibilityWindowInfo>>& infos, Rosen::WindowUpdateType type);
 
     std::map<int32_t, AccessibilityWindowInfo> a11yWindows_ {};
     int32_t activeWindowId_ = INVALID_WINDOW_ID;
@@ -58,18 +57,22 @@ private:
             : windInfoMgr_(windInfoMgr) {}
         ~AccessibilityWindowListener() = default;
 
-        virtual void OnWindowUpdate(const sptr<Rosen::AccessibilityWindowInfo>& windowInfo,
+        virtual void OnWindowUpdate(const std::vector<sptr<Rosen::AccessibilityWindowInfo>>& infos,
             Rosen::WindowUpdateType type) override
         {
-            windInfoMgr_.OnWindowUpdate(windowInfo, type);
+            windInfoMgr_.OnWindowUpdate(infos, type);
         }
 
     private:
         AccessibilityWindowManager &windInfoMgr_;
     };
 
-    void WindowUpdateAdded(const sptr<Rosen::AccessibilityWindowInfo>& windowInfo);
-    void WindowUpdateRemoved(const sptr<Rosen::AccessibilityWindowInfo>& windowInfo);
+    void WindowUpdateAdded(const std::vector<sptr<Rosen::AccessibilityWindowInfo>>& infos);
+    void WindowUpdateRemoved(const std::vector<sptr<Rosen::AccessibilityWindowInfo>>& infos);
+    void WindowUpdateBounds(const std::vector<sptr<Rosen::AccessibilityWindowInfo>>& infos);
+    void WindowUpdateActive(const std::vector<sptr<Rosen::AccessibilityWindowInfo>>& infos);
+    void WindowUpdateFocused(const std::vector<sptr<Rosen::AccessibilityWindowInfo>>& infos);
+    void WindowUpdateProperty(const std::vector<sptr<Rosen::AccessibilityWindowInfo>>& infos);
 
     sptr<AccessibilityWindowListener> windowListener_ = nullptr;
     std::shared_ptr<AppExecFwk::EventHandler> eventHandler_ = nullptr;

services/aams/src/accessibility_dumper.cpp

@@ -92,6 +92,19 @@ int AccessibilityDumper::DumpAccessibilityWindowInfo(std::string& dumpInfo) cons
         }
     }
 
+    index = 0;
+    const std::map<int32_t, AccessibilityWindowInfo> &windows = Singleton<AccessibilityWindowManager>::
+        GetInstance().a11yWindows_;
+    oss << std::endl << "a11yWindows_ id: ";
+    for (auto &iter : windows) {
+        index++;
+        oss << iter.first;
+
+        if (index != connectedWindowList.size()) {
+            oss << ", ";
+        }
+    }
+
     oss << std::endl << "active window id: " <<
         Singleton<AccessibilityWindowManager>::GetInstance().activeWindowId_ << std::endl;
     oss << "accessibility focused window id: " <<

services/aams/src/accessibility_window_manager.cpp

@@ -31,21 +31,15 @@ bool AccessibilityWindowManager::Init()
 {
     HILOG_DEBUG("start");
     HITRACE_METER_NAME(HITRACE_TAG_ACCESSIBILITY_MANAGER, "QueryWindowInfo");
-    sptr<Rosen::AccessibilityWindowInfo> windowInfo = new(std::nothrow) Rosen::AccessibilityWindowInfo();
-    if (!windowInfo) {
-        Utils::RecordUnavailableEvent(A11yUnavailableEvent::QUERY_EVENT, A11yError::ERROR_QUERY_WINDOW_INFO_FAILED);
-        HILOG_ERROR("Create window info failed.");
-        return false;
-    }
-    Rosen::WMError err = OHOS::Rosen::WindowManager::GetInstance().GetAccessibilityWindowInfo(windowInfo);
-    if (err != Rosen::WMError::WM_OK || !windowInfo) {
+    std::vector<sptr<Rosen::AccessibilityWindowInfo>> windowInfos;
+    Rosen::WMError err = OHOS::Rosen::WindowManager::GetInstance().GetAccessibilityWindowInfo(windowInfos);
+    if (err != Rosen::WMError::WM_OK) {
         Utils::RecordUnavailableEvent(A11yUnavailableEvent::QUERY_EVENT, A11yError::ERROR_QUERY_WINDOW_INFO_FAILED);
         HILOG_ERROR("get window info from wms failed. err[%{public}d]", err);
         return false;
     }
-    std::vector<sptr<Rosen::WindowInfo>> windows = windowInfo->windowList_;
-    HILOG_DEBUG("window list is %{public}zu", windows.size());
-    for (auto &window : windows) {
+    HILOG_DEBUG("windowInfos size is %{public}zu", windowInfos.size());
+    for (auto &window : windowInfos) {
         if (!window) {
             HILOG_ERROR("window is nullptr");
             continue;
@@ -58,7 +52,6 @@ bool AccessibilityWindowManager::Init()
             SetActiveWindow(window->wid_);
         }
     }
-    UpdateWindowLayer(windowInfo);
     return true;
 }
 
@@ -92,7 +85,7 @@ void AccessibilityWindowManager::DeregisterWindowListener()
     }
 }
 
-void AccessibilityWindowManager::OnWindowUpdate(const sptr<Rosen::AccessibilityWindowInfo>& windowInfo,
+void AccessibilityWindowManager::OnWindowUpdate(const std::vector<sptr<Rosen::AccessibilityWindowInfo>>& infos,
     Rosen::WindowUpdateType type)
 {
     HILOG_DEBUG("start");
@@ -100,53 +93,34 @@ void AccessibilityWindowManager::OnWindowUpdate(const sptr<Rosen::AccessibilityW
         HILOG_ERROR("eventHandler_ is nullptr.");
         return;
     }
-    if (!windowInfo || !windowInfo->currentWindowInfo_) {
+    if (infos.size() == 0) {
         HILOG_ERROR("window info is err");
         return;
     }
     eventHandler_->PostTask(std::bind([=]() -> void {
-        HILOG_DEBUG("windowId[%{public}d] type[%{public}d]", windowInfo->currentWindowInfo_->wid_, type);
-        auto &aams = Singleton<AccessibleAbilityManagerService>::GetInstance();
+        HILOG_DEBUG("windowId[%{public}d] type[%{public}d]", infos[0]->wid_, type);
         switch (type) {
             case Rosen::WindowUpdateType::WINDOW_UPDATE_ADDED:
-                WindowUpdateAdded(windowInfo);
+                WindowUpdateAdded(infos);
                 break;
             case Rosen::WindowUpdateType::WINDOW_UPDATE_REMOVED:
-                WindowUpdateRemoved(windowInfo);
+                WindowUpdateRemoved(infos);
                 break;
-            case Rosen::WindowUpdateType::WINDOW_UPDATE_BOUNDS: {
-                AccessibilityEventInfo evtInfBounds(windowInfo->currentWindowInfo_->wid_, WINDOW_UPDATE_BOUNDS);
-                aams.SendEvent(evtInfBounds);
+            case Rosen::WindowUpdateType::WINDOW_UPDATE_BOUNDS:
+                WindowUpdateBounds(infos);
                 break;
-            }
             case Rosen::WindowUpdateType::WINDOW_UPDATE_ACTIVE:
-                if (!a11yWindows_.count(windowInfo->currentWindowInfo_->wid_)) {
-                    auto a11yWindowInfoActive = CreateAccessibilityWindowInfo(windowInfo->currentWindowInfo_);
-                    a11yWindows_.emplace(windowInfo->currentWindowInfo_->wid_, a11yWindowInfoActive);
-                }
-                SetActiveWindow(windowInfo->currentWindowInfo_->wid_);
+                WindowUpdateActive(infos);
                 break;
-            case Rosen::WindowUpdateType::WINDOW_UPDATE_FOCUSED: {
-                if (!a11yWindows_.count(windowInfo->currentWindowInfo_->wid_)) {
-                    auto a11yWindowInfoFocused = CreateAccessibilityWindowInfo(windowInfo->currentWindowInfo_);
-                    a11yWindows_.emplace(windowInfo->currentWindowInfo_->wid_, a11yWindowInfoFocused);
-                }
-                SetActiveWindow(windowInfo->currentWindowInfo_->wid_);
-                AccessibilityEventInfo evtInfFocused(windowInfo->currentWindowInfo_->wid_, WINDOW_UPDATE_FOCUSED);
-                aams.SendEvent(evtInfFocused);
+            case Rosen::WindowUpdateType::WINDOW_UPDATE_FOCUSED:
+                WindowUpdateFocused(infos);
                 break;
-            }
-            case Rosen::WindowUpdateType::WINDOW_UPDATE_PROPERTY: {
-                if (a11yWindows_.count(windowInfo->currentWindowInfo_->wid_)) {
-                    UpdateAccessibilityWindowInfo(a11yWindows_[windowInfo->currentWindowInfo_->wid_],
-                        windowInfo->currentWindowInfo_);
-                }
+            case Rosen::WindowUpdateType::WINDOW_UPDATE_PROPERTY:
+                WindowUpdateProperty(infos);
                 break;
-            }
             default:
                 break;
         }
-        UpdateWindowLayer(windowInfo);
         HILOG_DEBUG("a11yWindows[%{public}zu]", a11yWindows_.size());
         }), "TASK_ON_WINDOW_UPDATE");
 }
@@ -187,13 +161,14 @@ AccessibilityWindowType ConvertWindowType(Rosen::WindowType type)
 }
 
 void AccessibilityWindowManager::UpdateAccessibilityWindowInfo(AccessibilityWindowInfo &accWindowInfo,
-    const sptr<Rosen::WindowInfo> windowInfo)
+    const sptr<Rosen::AccessibilityWindowInfo> windowInfo)
 {
     accWindowInfo.SetWindowId(windowInfo->wid_);
     accWindowInfo.SetWindowType(static_cast<uint32_t>(windowInfo->type_));
     accWindowInfo.SetWindowMode(static_cast<uint32_t>(windowInfo->mode_));
     accWindowInfo.SetAccessibilityWindowType(ConvertWindowType(windowInfo->type_));
     accWindowInfo.SetFocused(windowInfo->focused_);
+    accWindowInfo.SetWindowLayer(windowInfo->layer_);
     Rect bound;
     bound.SetLeftTopScreenPostion(windowInfo->windowRect_.posX_, windowInfo->windowRect_.posY_);
     bound.SetRightBottomScreenPostion(
@@ -205,7 +180,7 @@ void AccessibilityWindowManager::UpdateAccessibilityWindowInfo(AccessibilityWind
 }
 
 AccessibilityWindowInfo AccessibilityWindowManager::CreateAccessibilityWindowInfo(
-    const sptr<Rosen::WindowInfo> windowInfo)
+    const sptr<Rosen::AccessibilityWindowInfo> windowInfo)
 {
     AccessibilityWindowInfo info;
     UpdateAccessibilityWindowInfo(info, windowInfo);
@@ -275,7 +250,18 @@ void AccessibilityWindowManager::SetAccessibilityFocusedWindow(int32_t windowId)
 std::vector<AccessibilityWindowInfo> AccessibilityWindowManager::GetAccessibilityWindows()
 {
     HILOG_DEBUG("a11yWindows_ size[%{public}zu]", a11yWindows_.size());
+    std::vector<sptr<Rosen::AccessibilityWindowInfo>> windowInfos;
     std::vector<AccessibilityWindowInfo> windows;
+    Rosen::WMError err = OHOS::Rosen::WindowManager::GetInstance().GetAccessibilityWindowInfo(windowInfos);
+    if (err != Rosen::WMError::WM_OK) {
+        HILOG_ERROR("get window info from wms failed. err[%{public}d]", err);
+        return windows;
+    }
+    for (auto &info : windowInfos) {
+        if (info != nullptr && a11yWindows_.count(info->wid_)) {
+            UpdateAccessibilityWindowInfo(a11yWindows_[info->wid_], info);
+        }
+    }
     for (auto &window : a11yWindows_) {
         windows.emplace_back(window.second);
     }
@@ -289,6 +275,18 @@ std::vector<AccessibilityWindowInfo> AccessibilityWindowManager::GetAccessibilit
 bool AccessibilityWindowManager::GetAccessibilityWindow(int32_t windowId, AccessibilityWindowInfo &window)
 {
     HILOG_DEBUG("start windowId(%{public}d)", windowId);
+    std::vector<sptr<Rosen::AccessibilityWindowInfo>> windowInfos;
+    std::vector<AccessibilityWindowInfo> windows;
+    Rosen::WMError err = OHOS::Rosen::WindowManager::GetInstance().GetAccessibilityWindowInfo(windowInfos);
+    if (err != Rosen::WMError::WM_OK) {
+        HILOG_ERROR("get window info from wms failed. err[%{public}d]", err);
+        return false;
+    }
+    for (auto &info : windowInfos) {
+        if (info != nullptr && a11yWindows_.count(info->wid_)) {
+            UpdateAccessibilityWindowInfo(a11yWindows_[info->wid_], info);
+        }
+    }
     if (a11yWindows_.count(windowId)) {
         window = a11yWindows_[windowId];
         return true;
@@ -316,57 +314,114 @@ void AccessibilityWindowManager::SetWindowSize(int32_t windowId, Rect rect)
     }
 }
 
-void AccessibilityWindowManager::UpdateWindowLayer(const sptr<Rosen::AccessibilityWindowInfo> &windowInfo)
+void AccessibilityWindowManager::WindowUpdateAdded(const std::vector<sptr<Rosen::AccessibilityWindowInfo>>& infos)
 {
     HILOG_DEBUG("start");
-    int32_t layer = 0;
-    for (auto& window : windowInfo->windowList_) {
-        if (!window) {
-            HILOG_ERROR("window is nullptr");
-            continue;
+    for (auto &windowInfo : infos) {
+        if (!windowInfo) {
+            HILOG_ERROR("invalid windowInfo");
+            return;
         }
-
-        auto it = a11yWindows_.find(window->wid_);
-        if (it == a11yWindows_.end()) {
-            HILOG_ERROR("The window(%{public}d) not in a11yWindows_", window->wid_);
-            layer++;
+        if (!a11yWindows_.count(windowInfo->wid_)) {
+            auto a11yWindowInfoAdded = CreateAccessibilityWindowInfo(windowInfo);
+            a11yWindows_.emplace(windowInfo->wid_, a11yWindowInfoAdded);
         } else {
-            it->second.SetWindowLayer(layer);
-            layer++;
+            UpdateAccessibilityWindowInfo(a11yWindows_[windowInfo->wid_], windowInfo);
+        }
+        AccessibilityEventInfo evtInfAdded(windowInfo->wid_, WINDOW_UPDATE_ADDED);
+        Singleton<AccessibleAbilityManagerService>::GetInstance().SendEvent(evtInfAdded);
+        if (a11yWindows_[windowInfo->wid_].IsFocused()) {
+            SetActiveWindow(windowInfo->wid_);
         }
     }
 }
 
-void AccessibilityWindowManager::WindowUpdateAdded(const sptr<Rosen::AccessibilityWindowInfo> &windowInfo)
-{
-    HILOG_DEBUG("start");
-    if (!a11yWindows_.count(windowInfo->currentWindowInfo_->wid_)) {
-        auto a11yWindowInfoAdded = CreateAccessibilityWindowInfo(windowInfo->currentWindowInfo_);
-        a11yWindows_.emplace(windowInfo->currentWindowInfo_->wid_, a11yWindowInfoAdded);
-    }
-    AccessibilityEventInfo evtInfAdded(windowInfo->currentWindowInfo_->wid_, WINDOW_UPDATE_ADDED);
-    Singleton<AccessibleAbilityManagerService>::GetInstance().SendEvent(evtInfAdded);
-    if (a11yWindows_[windowInfo->currentWindowInfo_->wid_].IsFocused()) {
-        SetActiveWindow(windowInfo->currentWindowInfo_->wid_);
-    }
-}
-
-void AccessibilityWindowManager::WindowUpdateRemoved(const sptr<Rosen::AccessibilityWindowInfo> &windowInfo)
+void AccessibilityWindowManager::WindowUpdateRemoved(const std::vector<sptr<Rosen::AccessibilityWindowInfo>>& infos)
 {
     HILOG_DEBUG("start");
     auto &aams = Singleton<AccessibleAbilityManagerService>::GetInstance();
-    if (!a11yWindows_.count(windowInfo->currentWindowInfo_->wid_)) {
-        return;
+    for (auto &windowInfo : infos) {
+        if (!windowInfo) {
+            HILOG_ERROR("invalid windowInfo");
+            return;
+        }
+        if (!a11yWindows_.count(windowInfo->wid_)) {
+            return;
+        }
+        if (windowInfo->wid_ == activeWindowId_) {
+            SetActiveWindow(INVALID_WINDOW_ID);
+        }
+        if (windowInfo->wid_ == a11yFocusedWindowId_) {
+            SetAccessibilityFocusedWindow(INVALID_WINDOW_ID);
+        }
+        a11yWindows_.erase(windowInfo->wid_);
+        AccessibilityEventInfo evtInfRemoved(windowInfo->wid_, WINDOW_UPDATE_REMOVED);
+        aams.SendEvent(evtInfRemoved);
     }
-    if (windowInfo->currentWindowInfo_->wid_ == activeWindowId_) {
-        SetActiveWindow(INVALID_WINDOW_ID);
+}
+
+void AccessibilityWindowManager::WindowUpdateFocused(const std::vector<sptr<Rosen::AccessibilityWindowInfo>>& infos)
+{
+    HILOG_DEBUG("start");
+    auto &aams = Singleton<AccessibleAbilityManagerService>::GetInstance();
+    for (auto &windowInfo : infos) {
+        if (!windowInfo) {
+            HILOG_ERROR("invalid windowInfo");
+            return;
+        }
+        if (!a11yWindows_.count(windowInfo->wid_)) {
+            HILOG_WARN("window not created");
+            auto a11yWindowInfoFocused = CreateAccessibilityWindowInfo(windowInfo);
+            a11yWindows_.emplace(windowInfo->wid_, a11yWindowInfoFocused);
+        }
+        SetActiveWindow(windowInfo->wid_);
+        AccessibilityEventInfo evtInfFocused(windowInfo->wid_, WINDOW_UPDATE_FOCUSED);
+        aams.SendEvent(evtInfFocused);
     }
-    if (windowInfo->currentWindowInfo_->wid_ == a11yFocusedWindowId_) {
-        SetAccessibilityFocusedWindow(INVALID_WINDOW_ID);
+}
+
+void AccessibilityWindowManager::WindowUpdateBounds(const std::vector<sptr<Rosen::AccessibilityWindowInfo>>& infos)
+{
+    HILOG_DEBUG("start");
+    auto &aams = Singleton<AccessibleAbilityManagerService>::GetInstance();
+    for (auto &windowInfo : infos) {
+        if (!windowInfo) {
+            HILOG_ERROR("invalid windowInfo");
+            return;
+        }
+        AccessibilityEventInfo evtInfBounds(windowInfo->wid_, WINDOW_UPDATE_BOUNDS);
+        aams.SendEvent(evtInfBounds);
+    }
+}
+
+void AccessibilityWindowManager::WindowUpdateActive(const std::vector<sptr<Rosen::AccessibilityWindowInfo>>& infos)
+{
+    HILOG_DEBUG("start");
+    for (auto &windowInfo : infos) {
+        if (!windowInfo) {
+            HILOG_ERROR("invalid windowInfo");
+            return;
+        }
+        if (!a11yWindows_.count(windowInfo->wid_)) {
+            auto a11yWindowInfoActive = CreateAccessibilityWindowInfo(windowInfo);
+            a11yWindows_.emplace(windowInfo->wid_, a11yWindowInfoActive);
+        }
+        SetActiveWindow(windowInfo->wid_);
+    }
+}
+
+void AccessibilityWindowManager::WindowUpdateProperty(const std::vector<sptr<Rosen::AccessibilityWindowInfo>>& infos)
+{
+    HILOG_DEBUG("start");
+    for (auto &windowInfo : infos) {
+        if (!windowInfo) {
+            HILOG_ERROR("invalid windowInfo");
+            return;
+        }
+        if (a11yWindows_.count(windowInfo->wid_)) {
+            UpdateAccessibilityWindowInfo(a11yWindows_[windowInfo->wid_], windowInfo);
+        }
     }
-    a11yWindows_.erase(windowInfo->currentWindowInfo_->wid_);
-    AccessibilityEventInfo evtInfRemoved(windowInfo->currentWindowInfo_->wid_, WINDOW_UPDATE_REMOVED);
-    aams.SendEvent(evtInfRemoved);
 }
 } // namespace Accessibility
 } // namespace OHOS

services/aams/test/mock/include/mock_accessibility_window_manager.h

@@ -23,13 +23,15 @@ namespace OHOS {
 namespace Accessibility {
 class MockAccessibilityWindowListener : public AccessibilityWindowListener {
 public:
-    MOCK_METHOD2(OnWindowUpdate, void(const sptr<Rosen::WindowInfo>& windowInfo, Rosen::WindowUpdateType type));
+    MOCK_METHOD2(OnWindowUpdate, void(const sptr<Rosen::AccessibilityWindowInfo>& windowInfo,
+        Rosen::WindowUpdateType type));
 };
 
 class MockAccessibilityWindowInfoManager : public AccessibilityWindowManager {
 public:
     ~MockAccessibilityWindowInfoManager() = default;
-    MOCK_METHOD1(CreateAccessibilityWindowInfo, AccessibilityWindowInfo(sptr<Rosen::WindowInfo> windowInfo));
+    MOCK_METHOD1(CreateAccessibilityWindowInfo, AccessibilityWindowInfo(
+        sptr<Rosen::AccessibilityWindowInfo> windowInfo));
     MOCK_METHOD2(ConvertToRealWindowId, int32_t(int32_t windowId, int32_t focusType));
     MOCK_METHOD1(RegisterWindowListener, void(const std::shared_ptr<AppExecFwk::EventHandler> &handler));
     MOCK_METHOD0(DeregisterWindowListener, void());

services/aams/test/mock/src/mock_accessibility_window_manager.cpp

@@ -48,11 +48,11 @@ void AccessibilityWindowManager::DeregisterWindowListener()
 {
 }
 
-void AccessibilityWindowManager::OnWindowUpdate(const sptr<Rosen::AccessibilityWindowInfo>& windowInfo,
+void AccessibilityWindowManager::OnWindowUpdate(const std::vector<sptr<Rosen::AccessibilityWindowInfo>>& infos,
     Rosen::WindowUpdateType type)
 {
     HILOG_DEBUG("start");
-    (void)windowInfo;
+    (void)infos;
     (void)type;
 }
 
@@ -79,7 +79,7 @@ AccessibilityWindowType ConvertWindowType(Rosen::WindowType type)
 }
 
 AccessibilityWindowInfo AccessibilityWindowManager::CreateAccessibilityWindowInfo(
-    const sptr<Rosen::WindowInfo> windowInfo)
+    const sptr<Rosen::AccessibilityWindowInfo> windowInfo)
 {
     (void)windowInfo;
     AccessibilityWindowInfo info;
@@ -133,21 +133,5 @@ void AccessibilityWindowManager::SetWindowSize(int32_t windowId, Rect rect)
         }
     }
 }
-
-void AccessibilityWindowManager::UpdateWindowLayer(const sptr<Rosen::AccessibilityWindowInfo>& windowInfo)
-{
-    HILOG_DEBUG("start");
-    int32_t layer = 0;
-    for (auto& window : windowInfo->windowList_) {
-        auto it = a11yWindows_.find(window->wid_);
-        if (it == a11yWindows_.end()) {
-            HILOG_ERROR("The window(%{public}d) not in a11yWindows_", window->wid_);
-            layer++;
-        } else {
-            it->second.SetWindowLayer(layer);
-            layer++;
-        }
-    }
-}
 } // namespace Accessibility
 } // namespace OHOS

services/aams/test/unittest/accessibility_window_manager_test.cpp

@@ -73,9 +73,9 @@ void AccessibilityWindowManagerTest::TearDown()
     Singleton<AccessibleAbilityManagerService>::GetInstance().OnStop();
 }
 
-sptr<Rosen::WindowInfo> GetRosenWindowInfo(Rosen::WindowType windowType)
+sptr<Rosen::AccessibilityWindowInfo> GetRosenWindowInfo(Rosen::WindowType windowType)
 {
-    sptr<Rosen::WindowInfo> rosen_winInfo = new(std::nothrow) Rosen::WindowInfo();
+    sptr<Rosen::AccessibilityWindowInfo> rosen_winInfo = new(std::nothrow) Rosen::AccessibilityWindowInfo();
     if (rosen_winInfo != nullptr) {
         rosen_winInfo->type_ = windowType;
         rosen_winInfo->wid_ = 1;
@@ -148,14 +148,14 @@ HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_Cre
     TestSize.Level1)
 {
     GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_CreateAccessibilityWindowInfo001 start";
-    sptr<Rosen::WindowInfo> rosen_winInfo = GetRosenWindowInfo(Rosen::WindowType::APP_MAIN_WINDOW_BASE);
+    sptr<Rosen::AccessibilityWindowInfo> rosen_winInfo = GetRosenWindowInfo(Rosen::WindowType::APP_MAIN_WINDOW_BASE);
     EXPECT_TRUE(rosen_winInfo != nullptr);
     
-    sptr<Rosen::AccessibilityWindowInfo> winInfo = new Rosen::AccessibilityWindowInfo();
-    winInfo->currentWindowInfo_ = rosen_winInfo;
+    std::vector<sptr<Rosen::AccessibilityWindowInfo>> infos;
+    infos.emplace_back(rosen_winInfo);
 
     AccessibilityWindowManager& windowInfoManager = Singleton<AccessibilityWindowManager>::GetInstance();
-    AccessibilityWindowInfo info = windowInfoManager.CreateAccessibilityWindowInfo(winInfo->currentWindowInfo_);
+    AccessibilityWindowInfo info = windowInfoManager.CreateAccessibilityWindowInfo(rosen_winInfo);
 
     EXPECT_EQ(TYPE_APPLICATION, info.GetAccessibilityWindowType());
     GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_CreateAccessibilityWindowInfo001 end";
@@ -170,14 +170,15 @@ HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_Cre
     TestSize.Level1)
 {
     GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_CreateAccessibilityWindowInfo002 start";
-    sptr<Rosen::WindowInfo> rosen_winInfo = GetRosenWindowInfo(Rosen::WindowType::WINDOW_TYPE_LAUNCHER_RECENT);
+    sptr<Rosen::AccessibilityWindowInfo> rosen_winInfo = GetRosenWindowInfo(
+        Rosen::WindowType::WINDOW_TYPE_LAUNCHER_RECENT);
     EXPECT_TRUE(rosen_winInfo != nullptr);
 
-    sptr<Rosen::AccessibilityWindowInfo> winInfo = new Rosen::AccessibilityWindowInfo();
-    winInfo->currentWindowInfo_ = rosen_winInfo;
+    std::vector<sptr<Rosen::AccessibilityWindowInfo>> infos;
+    infos.emplace_back(rosen_winInfo);
 
     AccessibilityWindowManager& windowInfoManager = Singleton<AccessibilityWindowManager>::GetInstance();
-    AccessibilityWindowInfo info = windowInfoManager.CreateAccessibilityWindowInfo(winInfo->currentWindowInfo_);
+    AccessibilityWindowInfo info = windowInfoManager.CreateAccessibilityWindowInfo(rosen_winInfo);
 
     EXPECT_EQ(TYPE_SYSTEM, info.GetAccessibilityWindowType());
     GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_CreateAccessibilityWindowInfo002 end";
@@ -193,14 +194,15 @@ HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_Cre
 {
     GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_CreateAccessibilityWindowInfo003 start";
 
-    sptr<Rosen::WindowInfo> rosen_winInfo = GetRosenWindowInfo(static_cast<OHOS::Rosen::WindowType>(0xFFFFFFFF));
+    sptr<Rosen::AccessibilityWindowInfo> rosen_winInfo = GetRosenWindowInfo(
+        static_cast<OHOS::Rosen::WindowType>(0xFFFFFFFF));
     EXPECT_TRUE(rosen_winInfo != nullptr);
 
-    sptr<Rosen::AccessibilityWindowInfo> winInfo = new Rosen::AccessibilityWindowInfo();
-    winInfo->currentWindowInfo_ = rosen_winInfo;
+    std::vector<sptr<Rosen::AccessibilityWindowInfo>> infos;
+    infos.emplace_back(rosen_winInfo);
 
     AccessibilityWindowManager& windowInfoManager = Singleton<AccessibilityWindowManager>::GetInstance();
-    AccessibilityWindowInfo info = windowInfoManager.CreateAccessibilityWindowInfo(winInfo->currentWindowInfo_);
+    AccessibilityWindowInfo info = windowInfoManager.CreateAccessibilityWindowInfo(rosen_winInfo);
 
     EXPECT_EQ(TYPE_WINDOW_INVALID, info.GetAccessibilityWindowType());
     GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_CreateAccessibilityWindowInfo003 end";
@@ -244,19 +246,18 @@ HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_Der
 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_OnWindowChange001, TestSize.Level1)
 {
     GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_OnWindowChange001 start";
-    sptr<Rosen::WindowInfo> rosen_winInfo = GetRosenWindowInfo(Rosen::WindowType::APP_WINDOW_BASE);
+    sptr<Rosen::AccessibilityWindowInfo> rosen_winInfo = GetRosenWindowInfo(Rosen::WindowType::APP_WINDOW_BASE);
     EXPECT_TRUE(rosen_winInfo != nullptr);
     rosen_winInfo->focused_ = false;
 
-    sptr<Rosen::AccessibilityWindowInfo> winInfo = new Rosen::AccessibilityWindowInfo();
-    winInfo->currentWindowInfo_ = rosen_winInfo;
-    winInfo->windowList_.push_back(rosen_winInfo);
+    std::vector<sptr<Rosen::AccessibilityWindowInfo>> infos;
+    infos.emplace_back(rosen_winInfo);
 
     AccessibilityWindowManager& windowInfoManager = Singleton<AccessibilityWindowManager>::GetInstance();
     windowInfoManager.a11yWindows_.clear();
     EXPECT_TRUE(!windowInfoManager.a11yWindows_.size());
 
-    windowInfoManager.OnWindowUpdate(winInfo, Rosen::WindowUpdateType::WINDOW_UPDATE_ADDED);
+    windowInfoManager.OnWindowUpdate(infos, Rosen::WindowUpdateType::WINDOW_UPDATE_ADDED);
     int retryCount = 0;
     while (retryCount < RETRY_TIMES) {
         sleep(1);
@@ -282,22 +283,21 @@ HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_OnW
 HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_OnWindowChange002, TestSize.Level1)
 {
     GTEST_LOG_(INFO) << "AccessibilityWindowManager_Unittest_OnWindowChange002 start";
-    sptr<Rosen::WindowInfo> rosen_winInfo = new(std::nothrow) Rosen::WindowInfo();;
+    sptr<Rosen::AccessibilityWindowInfo> rosen_winInfo = new(std::nothrow) Rosen::AccessibilityWindowInfo();;
     EXPECT_TRUE(rosen_winInfo != nullptr);
     rosen_winInfo->type_ = Rosen::WindowType::APP_WINDOW_BASE;
     rosen_winInfo->wid_ = 1;
     rosen_winInfo->focused_ = true;
 
-    sptr<Rosen::AccessibilityWindowInfo> winInfo = new Rosen::AccessibilityWindowInfo();
-    winInfo->currentWindowInfo_ = rosen_winInfo;
-    winInfo->windowList_.push_back(rosen_winInfo);
+    std::vector<sptr<Rosen::AccessibilityWindowInfo>> infos;
+    infos.emplace_back(rosen_winInfo);
 
     AccessibilityWindowManager& windowInfoManager = Singleton<AccessibilityWindowManager>::GetInstance();
     windowInfoManager.a11yWindows_.clear();
     EXPECT_TRUE(!windowInfoManager.a11yWindows_.size());
     EXPECT_EQ(windowInfoManager.activeWindowId_, INVALID_WINDOW_ID);
 
-    windowInfoManager.OnWindowUpdate(winInfo, Rosen::WindowUpdateType::WINDOW_UPDATE_ACTIVE);
+    windowInfoManager.OnWindowUpdate(infos, Rosen::WindowUpdateType::WINDOW_UPDATE_ACTIVE);
     int retryCount = 0;
     while (retryCount < RETRY_TIMES) {
         sleep(1);
@@ -330,7 +330,7 @@ HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_OnW
     EXPECT_TRUE(!windowInfoManager.a11yWindows_.size());
 
     // Add a window
-    sptr<Rosen::WindowInfo> rosenWinInfoFirst = new Rosen::WindowInfo();
+    sptr<Rosen::AccessibilityWindowInfo> rosenWinInfoFirst = new Rosen::AccessibilityWindowInfo();
     rosenWinInfoFirst->type_ = Rosen::WindowType::WINDOW_TYPE_APP_MAIN_WINDOW;
     rosenWinInfoFirst->wid_ = 1;
     rosenWinInfoFirst->focused_ = false;
@@ -348,7 +348,7 @@ HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_OnW
     EXPECT_EQ(windowInfoManager.a11yWindows_.size(), 1);
 
     // Add another window
-    sptr<Rosen::WindowInfo> rosenWinInfoSecond = new Rosen::WindowInfo();
+    sptr<Rosen::AccessibilityWindowInfo> rosenWinInfoSecond = new Rosen::AccessibilityWindowInfo();
     rosenWinInfoSecond->type_ = Rosen::WindowType::APP_WINDOW_BASE;
     rosenWinInfoSecond->wid_ = WINDOW_ID;
     rosenWinInfoSecond->focused_ = false;
@@ -361,11 +361,9 @@ HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_OnW
     EXPECT_EQ(windowInfoManager.a11yWindows_.size(), WINDOWS_SIZE);
 
     // Remove the first window
-    sptr<Rosen::AccessibilityWindowInfo> winInfo = new Rosen::AccessibilityWindowInfo();
-    winInfo->currentWindowInfo_ = rosenWinInfoFirst;
-    winInfo->windowList_.push_back(rosenWinInfoFirst);
-    winInfo->windowList_.push_back(rosenWinInfoSecond);
-    windowInfoManager.OnWindowUpdate(winInfo, Rosen::WindowUpdateType::WINDOW_UPDATE_REMOVED);
+    std::vector<sptr<Rosen::AccessibilityWindowInfo>> infos;
+    infos.emplace_back(rosenWinInfoFirst);
+    windowInfoManager.OnWindowUpdate(infos, Rosen::WindowUpdateType::WINDOW_UPDATE_REMOVED);
 
     int retryCount = 0;
     while (retryCount < RETRY_TIMES) {
@@ -400,7 +398,7 @@ HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_OnW
     EXPECT_EQ(windowInfoManager.activeWindowId_, INVALID_WINDOW_ID);
 
     // Add an active window
-    sptr<Rosen::WindowInfo> rosenWinInfoFirst = new Rosen::WindowInfo();
+    sptr<Rosen::AccessibilityWindowInfo> rosenWinInfoFirst = new Rosen::AccessibilityWindowInfo();
     rosenWinInfoFirst->type_ = Rosen::WindowType::WINDOW_TYPE_APP_MAIN_WINDOW;
     rosenWinInfoFirst->wid_ = 1;
     rosenWinInfoFirst->focused_ = false;
@@ -420,7 +418,7 @@ HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_OnW
     EXPECT_EQ(windowInfoManager.activeWindowId_, rosenWinInfoFirst->wid_);
 
     // Add another normal window
-    sptr<Rosen::WindowInfo> rosenWinInfoSecond = new Rosen::WindowInfo();
+    sptr<Rosen::AccessibilityWindowInfo> rosenWinInfoSecond = new Rosen::AccessibilityWindowInfo();
     rosenWinInfoSecond->type_ = Rosen::WindowType::APP_WINDOW_BASE;
     rosenWinInfoSecond->wid_ = WINDOW_ID;
     rosenWinInfoSecond->focused_ = false;
@@ -433,11 +431,9 @@ HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_OnW
     EXPECT_EQ(windowInfoManager.a11yWindows_.size(), WINDOWS_SIZE);
 
     // Remove the active window
-    sptr<Rosen::AccessibilityWindowInfo> winInfo = new Rosen::AccessibilityWindowInfo();
-    winInfo->currentWindowInfo_ = rosenWinInfoFirst;
-    winInfo->windowList_.push_back(rosenWinInfoFirst);
-    winInfo->windowList_.push_back(rosenWinInfoSecond);
-    windowInfoManager.OnWindowUpdate(winInfo, Rosen::WindowUpdateType::WINDOW_UPDATE_REMOVED);
+    std::vector<sptr<Rosen::AccessibilityWindowInfo>> infos;
+    infos.emplace_back(rosenWinInfoFirst);
+    windowInfoManager.OnWindowUpdate(infos, Rosen::WindowUpdateType::WINDOW_UPDATE_REMOVED);
 
     int retryCount = 0;
     while (retryCount < RETRY_TIMES) {
@@ -730,14 +726,15 @@ HWTEST_F(
     /* map insert value */
     int32_t windowId = ANY_WINDOW_ID;
 
-    sptr<Rosen::WindowInfo> rosen_winInfo = GetRosenWindowInfo(Rosen::WindowType::BELOW_APP_SYSTEM_WINDOW_BASE);
+    sptr<Rosen::AccessibilityWindowInfo> rosen_winInfo = GetRosenWindowInfo(
+        Rosen::WindowType::BELOW_APP_SYSTEM_WINDOW_BASE);
     EXPECT_TRUE(rosen_winInfo != nullptr);
 
-    sptr<Rosen::AccessibilityWindowInfo> winInfo = new Rosen::AccessibilityWindowInfo();
-    winInfo->currentWindowInfo_ = rosen_winInfo;
+    std::vector<sptr<Rosen::AccessibilityWindowInfo>> infos;
+    infos.emplace_back(rosen_winInfo);
 
     AccessibilityWindowManager& mgr = Singleton<AccessibilityWindowManager>::GetInstance();
-    AccessibilityWindowInfo info = mgr.CreateAccessibilityWindowInfo(winInfo->currentWindowInfo_);
+    AccessibilityWindowInfo info = mgr.CreateAccessibilityWindowInfo(rosen_winInfo);
     info.SetAccessibilityWindowType(AccessibilityWindowType::TYPE_APPLICATION);
     EXPECT_EQ(0, (int)mgr.a11yWindows_.size());
     mgr.a11yWindows_.insert(std::make_pair(windowId, info));
@@ -767,14 +764,15 @@ HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_Get
     /* map insert value */
     int32_t windowId = ANY_WINDOW_ID;
 
-    sptr<Rosen::WindowInfo> rosen_winInfo = GetRosenWindowInfo(Rosen::WindowType::BELOW_APP_SYSTEM_WINDOW_BASE);
+    sptr<Rosen::AccessibilityWindowInfo> rosen_winInfo = GetRosenWindowInfo(
+        Rosen::WindowType::BELOW_APP_SYSTEM_WINDOW_BASE);
     EXPECT_TRUE(rosen_winInfo != nullptr);
 
-    sptr<Rosen::AccessibilityWindowInfo> winInfo = new Rosen::AccessibilityWindowInfo();
-    winInfo->currentWindowInfo_ = rosen_winInfo;
+    std::vector<sptr<Rosen::AccessibilityWindowInfo>> infos;
+    infos.emplace_back(rosen_winInfo);
 
     AccessibilityWindowManager& mgr = Singleton<AccessibilityWindowManager>::GetInstance();
-    AccessibilityWindowInfo info = mgr.CreateAccessibilityWindowInfo(winInfo->currentWindowInfo_);
+    AccessibilityWindowInfo info = mgr.CreateAccessibilityWindowInfo(rosen_winInfo);
     info.SetAccessibilityWindowType(AccessibilityWindowType::TYPE_APPLICATION);
     EXPECT_EQ(0, (int)mgr.a11yWindows_.size());
     mgr.a11yWindows_.insert(std::make_pair(windowId, info));
@@ -799,14 +797,15 @@ HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_Get
     /* map insert value */
     int32_t windowId = ANY_WINDOW_ID;
 
-    sptr<Rosen::WindowInfo> rosen_winInfo = GetRosenWindowInfo(Rosen::WindowType::BELOW_APP_SYSTEM_WINDOW_BASE);
+    sptr<Rosen::AccessibilityWindowInfo> rosen_winInfo = GetRosenWindowInfo(
+        Rosen::WindowType::BELOW_APP_SYSTEM_WINDOW_BASE);
     EXPECT_TRUE(rosen_winInfo != nullptr);
 
-    sptr<Rosen::AccessibilityWindowInfo> winInfo = new Rosen::AccessibilityWindowInfo();
-    winInfo->currentWindowInfo_ = rosen_winInfo;
+    std::vector<sptr<Rosen::AccessibilityWindowInfo>> infos;
+    infos.emplace_back(rosen_winInfo);
 
     AccessibilityWindowManager& mgr = Singleton<AccessibilityWindowManager>::GetInstance();
-    AccessibilityWindowInfo info = mgr.CreateAccessibilityWindowInfo(winInfo->currentWindowInfo_);
+    AccessibilityWindowInfo info = mgr.CreateAccessibilityWindowInfo(rosen_winInfo);
     info.SetAccessibilityWindowType(AccessibilityWindowType::TYPE_APPLICATION);
     EXPECT_EQ(0, (int)mgr.a11yWindows_.size());
     mgr.a11yWindows_.insert(std::make_pair(windowId, info));
@@ -831,14 +830,15 @@ HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_IsV
     /* map insert value */
     int32_t windowId = ANY_WINDOW_ID;
 
-    sptr<Rosen::WindowInfo> rosen_winInfo = GetRosenWindowInfo(Rosen::WindowType::BELOW_APP_SYSTEM_WINDOW_BASE);
+    sptr<Rosen::AccessibilityWindowInfo> rosen_winInfo = GetRosenWindowInfo(
+        Rosen::WindowType::BELOW_APP_SYSTEM_WINDOW_BASE);
     EXPECT_TRUE(rosen_winInfo != nullptr);
 
-    sptr<Rosen::AccessibilityWindowInfo> winInfo = new Rosen::AccessibilityWindowInfo();
-    winInfo->currentWindowInfo_ = rosen_winInfo;
+    std::vector<sptr<Rosen::AccessibilityWindowInfo>> infos;
+    infos.emplace_back(rosen_winInfo);
 
     AccessibilityWindowManager& mgr = Singleton<AccessibilityWindowManager>::GetInstance();
-    AccessibilityWindowInfo info = mgr.CreateAccessibilityWindowInfo(winInfo->currentWindowInfo_);
+    AccessibilityWindowInfo info = mgr.CreateAccessibilityWindowInfo(rosen_winInfo);
     info.SetAccessibilityWindowType(AccessibilityWindowType::TYPE_APPLICATION);
     EXPECT_EQ(0, (int)mgr.a11yWindows_.size());
     mgr.a11yWindows_.insert(std::make_pair(windowId, info));
@@ -863,14 +863,15 @@ HWTEST_F(AccessibilityWindowManagerTest, AccessibilityWindowManager_Unittest_IsV
     /* map insert value */
     int32_t windowId = ANY_WINDOW_ID;
 
-    sptr<Rosen::WindowInfo> rosen_winInfo = GetRosenWindowInfo(Rosen::WindowType::BELOW_APP_SYSTEM_WINDOW_BASE);
+    sptr<Rosen::AccessibilityWindowInfo> rosen_winInfo = GetRosenWindowInfo(
+        Rosen::WindowType::BELOW_APP_SYSTEM_WINDOW_BASE);
     EXPECT_TRUE(rosen_winInfo != nullptr);
 
-    sptr<Rosen::AccessibilityWindowInfo> winInfo = new Rosen::AccessibilityWindowInfo();
-    winInfo->currentWindowInfo_ = rosen_winInfo;
+    std::vector<sptr<Rosen::AccessibilityWindowInfo>> infos;
+    infos.emplace_back(rosen_winInfo);
 
     AccessibilityWindowManager& mgr = Singleton<AccessibilityWindowManager>::GetInstance();
-    AccessibilityWindowInfo info = mgr.CreateAccessibilityWindowInfo(winInfo->currentWindowInfo_);
+    AccessibilityWindowInfo info = mgr.CreateAccessibilityWindowInfo(rosen_winInfo);
     info.SetAccessibilityWindowType(AccessibilityWindowType::TYPE_APPLICATION);
     EXPECT_EQ(0, (int)mgr.a11yWindows_.size());
     mgr.a11yWindows_.insert(std::make_pair(windowId, info));