diff --git a/interfaces/innerkits/wm/window_manager.h b/interfaces/innerkits/wm/window_manager.h
index 8e1978d5f5228edd563a40d055d2caaa473269c5..da4c701d0aa7cf257b0bd75f4abd0776b15f93f3 100644
--- a/interfaces/innerkits/wm/window_manager.h
+++ b/interfaces/innerkits/wm/window_manager.h
@@ -227,6 +227,8 @@ public:
     float scaleVal_;
     float scaleX_;
     float scaleY_;
+    std::string bundleName_;
+    std::vector<Rect> touchHotAreas_;
 };
 
 /**
diff --git a/interfaces/innerkits/wm/wm_common.h b/interfaces/innerkits/wm/wm_common.h
index 36f5940ea37005d4d14858945861da7d5055556e..467e65c6e12b70ef915a4e469752b61334b8fb30 100644
--- a/interfaces/innerkits/wm/wm_common.h
+++ b/interfaces/innerkits/wm/wm_common.h
@@ -649,6 +649,7 @@ enum class WindowUpdateType : int32_t {
     WINDOW_UPDATE_BOUNDS,
     WINDOW_UPDATE_ACTIVE,
     WINDOW_UPDATE_PROPERTY,
+    WINDOW_UPDATE_ALL,
 };
 
 /**
diff --git a/window_scene/session_manager/include/scene_session_manager.h b/window_scene/session_manager/include/scene_session_manager.h
index 9d1e72faa6d4da405f20872b148848c162ca1f81..da703cdc17d9f2e70ba24314ad3b25bee3af40d6 100644
--- a/window_scene/session_manager/include/scene_session_manager.h
+++ b/window_scene/session_manager/include/scene_session_manager.h
@@ -446,6 +446,12 @@ private:
     WSError DestroyAndDisconnectSpecificSessionInner(const int32_t persistentId);
     void UpdateCameraWindowStatus(uint32_t accessTokenId, bool isShowing);
     void ReportWindowProfileInfos();
+    void GetAllSceneSessionForAccessibility(std::vector<sptr<SceneSession>>& sceneSessionList);
+    bool IsCovered(const sptr<SceneSession>& session, const std::vector<sptr<SceneSession>>& sceneSessionList);
+    void FillAccessibilityInfo(std::vector<sptr<SceneSession>>& sceneSessionList,
+        std::vector<sptr<AccessibilityWindowInfo>>& accessibilityInfo);
+    void FilterSceneSessionForAccessibility(std::vector<sptr<SceneSession>>& sceneSessionList);
+    void NotifyAllAccessibilityInfo();
 
     sptr<RootSceneSession> rootSceneSession_;
     std::weak_ptr<AbilityRuntime::Context> rootSceneContextWeak_;
diff --git a/window_scene/session_manager/src/scene_session_manager.cpp b/window_scene/session_manager/src/scene_session_manager.cpp
index 8a9fc26c673ad37aab44939da54292ed5fa8358f..f3892109595b4a9cb2a7b3c1d21ce64c774a08d5 100644
--- a/window_scene/session_manager/src/scene_session_manager.cpp
+++ b/window_scene/session_manager/src/scene_session_manager.cpp
@@ -5662,11 +5662,8 @@ void SceneSessionManager::NotifyWindowInfoChange(int32_t persistentId, WindowUpd
     }
     wptr<SceneSession> weakSceneSession(sceneSession);
     auto task = [this, weakSceneSession, type]() {
-        std::vector<sptr<AccessibilityWindowInfo>> infos;
         auto scnSession = weakSceneSession.promote();
-        if (FillWindowInfo(infos, scnSession)) {
-            SessionManagerAgentController::GetInstance().NotifyAccessibilityWindowInfo(infos, type);
-        }
+        NotifyAllAccessibilityInfo();
         if (WindowChangedFunc_ != nullptr && scnSession != nullptr &&
             scnSession->GetWindowType() == WindowType::WINDOW_TYPE_APP_MAIN_WINDOW) {
             WindowChangedFunc_(scnSession->GetPersistentId(), type);
@@ -5717,13 +5714,16 @@ bool SceneSessionManager::FillWindowInfo(std::vector<sptr<AccessibilityWindowInf
     info->scaleVal_ = sceneSession->GetFloatingScale();
     info->scaleX_ = sceneSession->GetScaleX();
     info->scaleY_ = sceneSession->GetScaleY();
+    info->bundleName_ = sceneSession->GetSessionInfo().bundleName_;
+    info->touchHotAreas_ = sceneSession->GetTouchHotAreas();
     auto property = sceneSession->GetSessionProperty();
     if (property != nullptr) {
         info->displayId_ = property->GetDisplayId();
         info->isDecorEnable_ = property->IsDecorEnable();
     }
     infos.emplace_back(info);
-    WLOGFD("wid = %{public}d, inWid = %{public}d, uiNId = %{public}d", info->wid_, info->innerWid_, info->uiNodeId_);
+    TLOGD(WmsLogTag::WMS_MAIN, "wid = %{public}d, inWid = %{public}d, uiNId = %{public}d, bundleName = %{public}s",
+        info->wid_, info->innerWid_, info->uiNodeId_, info->bundleName_.c_str());
     return true;
 }
 
@@ -7683,6 +7683,97 @@ WSError SceneSessionManager::GetHostWindowRect(int32_t hostWindowId, Rect& rect)
     return WSError::WS_OK;
 }
 
+void SceneSessionManager::GetAllSceneSessionForAccessibility(std::vector<sptr<SceneSession>>& sceneSessionList)
+{
+    std::shared_lock<std::shared_mutex> lock(sceneSessionMapMutex_);
+    for (const auto& item : sceneSessionMap_) {
+        auto sceneSession = item.second;
+        if (sceneSession == nullptr) {
+            continue;
+        }
+        if (!sceneSession->IsVisibleForAccessibility()) {
+            continue;
+        }
+        if (sceneSession->GetSessionInfo().bundleName_.find("SCBGestureBack") != std::string::npos
+            || sceneSession->GetSessionInfo().bundleName_.find("SCBGestureNavBar") != std::string::npos) {
+            continue;
+        }
+        sceneSessionList.push_back(sceneSession);
+    }
+}
+
+void SceneSessionManager::FillAccessibilityInfo(std::vector<sptr<SceneSession>>& sceneSessionList,
+    std::vector<sptr<AccessibilityWindowInfo>>& accessibilityInfo)
+{
+    for (const auto& sceneSession : sceneSessionList) {
+        if (!FillWindowInfo(accessibilityInfo, sceneSession)) {
+            TLOGW(WmsLogTag::WMS_MAIN, "fill accessibilityInfo failed");
+        }
+    }
+}
+
+bool SceneSessionManager::IsCovered(const sptr<SceneSession>& sceneSession,
+                                    const std::vector<sptr<SceneSession>>& sceneSessionList)
+{
+    if (sceneSession == nullptr) {
+        TLOGE(WmsLogTag::WMS_MAIN, "invalid parameter, scene session is nullptr.");
+        return true;
+    }
+
+    WSRect windowWSRect = sceneSession->GetSessionRect();
+    Rect windowRect = {windowWSRect.posX_, windowWSRect.posY_,
+                       windowWSRect.width_, windowWSRect.height_};
+    for (const auto& item : sceneSessionList) {
+        if (item == nullptr) {
+            continue;
+        }
+        if (item->GetWindowId() == sceneSession->GetWindowId()) {
+            continue;
+        }
+        if (sceneSession->GetZOrder() > item->GetZOrder()) {
+            continue;
+        }
+        WSRect itemWSRect = item->GetSessionRect();
+        Rect itemRect = {itemWSRect.posX_, itemWSRect.posY_, itemWSRect.width_, itemWSRect.height_};
+        if (windowRect.IsInsideOf(itemRect) && sceneSession->GetZOrder() < item->GetZOrder()) {
+            return true;
+        }
+    }
+    return false;
+}
+
+
+void SceneSessionManager::FilterSceneSessionForAccessibility(std::vector<sptr<SceneSession>>& sceneSessionList)
+{
+    for (auto it = sceneSessionList.begin(); it != sceneSessionList.end();) {
+        if (IsCovered(it->GetRefPtr(), sceneSessionList)) {
+            it = sceneSessionList.erase(it);
+            continue;
+        }
+        it++;
+    }
+}
+
+void SceneSessionManager::NotifyAllAccessibilityInfo()
+{
+    std::vector<sptr<SceneSession>> sceneSessionList;
+    GetAllSceneSessionForAccessibility(sceneSessionList);
+    FilterSceneSessionForAccessibility(sceneSessionList);
+
+    std::vector<sptr<AccessibilityWindowInfo>> accessibilityInfo;
+    FillAccessibilityInfo(sceneSessionList, accessibilityInfo);
+
+    for (const auto& item : accessibilityInfo) {
+        TLOGD(WmsLogTag::WMS_MAIN, "notify accessibilityWindow wid = %{public}d, inWid = %{public}d, \
+            bundle=%{public}s,bounds=(x = %{public}d, y = %{public}d, w = %{public}d, h = %{public}d)",
+            item->wid_, item->innerWid_, item->bundleName_.c_str(),
+            item->windowRect_.posX_, item->windowRect_.posY_, item->windowRect_.width_, item->windowRect_.height_);
+    }
+
+    SessionManagerAgentController::GetInstance().NotifyAccessibilityWindowInfo(accessibilityInfo,
+        WindowUpdateType::WINDOW_UPDATE_ALL);
+}
+
 int32_t SceneSessionManager::ReclaimPurgeableCleanMem()
 {
 #ifdef MEMMGR_WINDOW_ENABLE
diff --git a/window_scene/test/unittest/scene_session_manager_test.cpp b/window_scene/test/unittest/scene_session_manager_test.cpp
index 22e8d44b5222a596007866f57d72e7097d37d9f7..8f6e0552eed11da5c1a659dbb0f6ba71dc043c4a 100644
--- a/window_scene/test/unittest/scene_session_manager_test.cpp
+++ b/window_scene/test/unittest/scene_session_manager_test.cpp
@@ -69,6 +69,8 @@ public:
 
     void TearDown() override;
 
+    static void SetVisibleForAccessibility(sptr<SceneSession>& sceneSession);
+
     static bool gestureNavigationEnabled_;
     static bool statusBarEnabled_;
     static ProcessGestureNavigationEnabledChangeFunc callbackFunc_;
@@ -117,6 +119,15 @@ void SceneSessionManagerTest::TearDown()
     ssm_ = nullptr;
 }
 
+void SceneSessionManagerTest::SetVisibleForAccessibility(sptr<SceneSession>& sceneSession)
+{
+    sceneSession->SetTouchable(true);
+    sceneSession->forceTouchable_ = true;
+    sceneSession->systemTouchable_ = true;
+    sceneSession->state_ = SessionState::STATE_FOREGROUND;
+    sceneSession->foregroundInteractiveStatus_.store(true);
+}
+
 namespace {
 /**
  * @tc.name: SetBrightness
@@ -3251,6 +3262,343 @@ HWTEST_F(SceneSessionManagerTest, AddOrRemoveSecureExtSession, Function | SmallT
     EXPECT_EQ(ret, WSError::WS_OK);
 }
 
+/**
+ * @tc.name: AccessibilityFillEmptySceneSessionListToNotifyList
+ * @tc.desc: SceneSesionManager fill empty scene session list to accessibilityList;
+ * @tc.type: FUNC
+*/
+HWTEST_F(SceneSessionManagerTest, AccessibilityFillEmptySceneSessionListToNotifyList, Function | SmallTest | Level3)
+{
+    std::vector<sptr<SceneSession>> sceneSessionList;
+    std::vector<sptr<AccessibilityWindowInfo>> accessibilityInfo;
+
+    ssm_->FillAccessibilityInfo(sceneSessionList, accessibilityInfo);
+    EXPECT_EQ(accessibilityInfo.size(), 0);
+}
+
+/**
+ * @tc.name: AccessibilityFillOneSceneSessionListToNotifyList
+ * @tc.desc: SceneSesionManager fill one sceneSession to accessibilityList;
+ * @tc.type: FUNC
+*/
+HWTEST_F(SceneSessionManagerTest, AccessibilityFillOneSceneSessionListToNotifyList, Function | SmallTest | Level3)
+{
+    SessionInfo sessionInfo;
+    sessionInfo.bundleName_ = "accessibilityNotifyTesterBundleName";
+    sessionInfo.abilityName_ = "accessibilityNotifyTesterAbilityName";
+
+    sptr<SceneSession> sceneSession = ssm_->CreateSceneSession(sessionInfo, nullptr);
+    ASSERT_NE(sceneSession, nullptr);
+    SetVisibleForAccessibility(sceneSession);
+    ssm_->sceneSessionMap_.insert({sceneSession->GetPersistentId(), sceneSession});
+
+    std::vector<sptr<SceneSession>> sceneSessionList;
+    ssm_->GetAllSceneSessionForAccessibility(sceneSessionList);
+    ASSERT_EQ(sceneSessionList.size(), 1);
+
+    std::vector<sptr<AccessibilityWindowInfo>> accessibilityInfo;
+    ssm_->FillAccessibilityInfo(sceneSessionList, accessibilityInfo);
+    ASSERT_EQ(accessibilityInfo.size(), 1);
+}
+
+/**
+ * @tc.name: AccessibilityFillTwoSceneSessionListToNotifyList
+ * @tc.desc: SceneSesionManager fill two sceneSessions to accessibilityList;
+ * @tc.type: FUNC
+*/
+HWTEST_F(SceneSessionManagerTest, AccessibilityFillTwoSceneSessionListToNotifyList, Function | SmallTest | Level3)
+{
+    SessionInfo sessionInfo;
+    sessionInfo.bundleName_ = "accessibilityNotifyTesterBundleName";
+    sessionInfo.abilityName_ = "accessibilityNotifyTesterAbilityName";
+
+    sptr<SceneSession> sceneSessionFirst = ssm_->CreateSceneSession(sessionInfo, nullptr);
+    ASSERT_NE(sceneSessionFirst, nullptr);
+    SetVisibleForAccessibility(sceneSessionFirst);
+
+    sptr<SceneSession> sceneSessionSecond = ssm_->CreateSceneSession(sessionInfo, nullptr);
+    ASSERT_NE(sceneSessionSecond, nullptr);
+    SetVisibleForAccessibility(sceneSessionSecond);
+
+    ssm_->sceneSessionMap_.insert({sceneSessionFirst->GetPersistentId(), sceneSessionFirst});
+    ssm_->sceneSessionMap_.insert({sceneSessionSecond->GetPersistentId(), sceneSessionSecond});
+
+    std::vector<sptr<SceneSession>> sceneSessionList;
+    ssm_->GetAllSceneSessionForAccessibility(sceneSessionList);
+    ASSERT_EQ(sceneSessionList.size(), 2);
+
+    std::vector<sptr<AccessibilityWindowInfo>> accessibilityInfo;
+    ssm_->FillAccessibilityInfo(sceneSessionList, accessibilityInfo);
+    ASSERT_EQ(accessibilityInfo.size(), 2);
+}
+
+/**
+ * @tc.name: AccessibilityFillEmptyBundleName
+ * @tc.desc: SceneSesionManager fill empty bundle name to accessibilityInfo;
+ * @tc.type: FUNC
+*/
+HWTEST_F(SceneSessionManagerTest, AccessibilityFillEmptyBundleName, Function | SmallTest | Level3)
+{
+    SessionInfo sessionInfo;
+    sessionInfo.abilityName_ = "accessibilityNotifyTesterAbilityName";
+
+    sptr<SceneSession> sceneSession = ssm_->CreateSceneSession(sessionInfo, nullptr);
+    ASSERT_NE(sceneSession, nullptr);
+    SetVisibleForAccessibility(sceneSession);
+    ssm_->sceneSessionMap_.insert({sceneSession->GetPersistentId(), sceneSession});
+
+    std::vector<sptr<SceneSession>> sceneSessionList;
+    ssm_->GetAllSceneSessionForAccessibility(sceneSessionList);
+    ASSERT_EQ(sceneSessionList.size(), 1);
+
+    std::vector<sptr<AccessibilityWindowInfo>> accessibilityInfo;
+    ssm_->FillAccessibilityInfo(sceneSessionList, accessibilityInfo);
+    ASSERT_EQ(accessibilityInfo.size(), 1);
+
+    ASSERT_EQ(accessibilityInfo.at(0)->bundleName_, "");
+    ASSERT_EQ(sceneSessionList.at(0)->GetSessionInfo().bundleName_, "");
+    ASSERT_EQ(accessibilityInfo.at(0)->bundleName_, sceneSessionList.at(0)->GetSessionInfo().bundleName_);
+}
+
+/**
+ * @tc.name: AccessibilityFillBundleName
+ * @tc.desc: SceneSesionManager fill bundle name to accessibilityInfo;
+ * @tc.type: FUNC
+*/
+HWTEST_F(SceneSessionManagerTest, AccessibilityFillBundleName, Function | SmallTest | Level3)
+{
+    SessionInfo sessionInfo;
+    sessionInfo.bundleName_ = "accessibilityNotifyTesterBundleName";
+    sessionInfo.abilityName_ = "accessibilityNotifyTesterAbilityName";
+
+    sptr<SceneSession> sceneSession = ssm_->CreateSceneSession(sessionInfo, nullptr);
+    ASSERT_NE(sceneSession, nullptr);
+    SetVisibleForAccessibility(sceneSession);
+    ssm_->sceneSessionMap_.insert({sceneSession->GetPersistentId(), sceneSession});
+
+    std::vector<sptr<SceneSession>> sceneSessionList;
+    ssm_->GetAllSceneSessionForAccessibility(sceneSessionList);
+    ASSERT_EQ(sceneSessionList.size(), 1);
+
+    std::vector<sptr<AccessibilityWindowInfo>> accessibilityInfo;
+    ssm_->FillAccessibilityInfo(sceneSessionList, accessibilityInfo);
+    ASSERT_EQ(accessibilityInfo.size(), 1);
+
+    ASSERT_EQ(accessibilityInfo.at(0)->bundleName_, "accessibilityNotifyTesterBundleName");
+    ASSERT_EQ(sceneSessionList.at(0)->GetSessionInfo().bundleName_, "accessibilityNotifyTesterBundleName");
+    ASSERT_EQ(accessibilityInfo.at(0)->bundleName_, sceneSessionList.at(0)->GetSessionInfo().bundleName_);
+}
+
+/**
+ * @tc.name: AccessibilityFillEmptyHotAreas
+ * @tc.desc: SceneSesionManager fill empty hot areas to accessibilityInfo;
+ * @tc.type: FUNC
+*/
+HWTEST_F(SceneSessionManagerTest, AccessibilityFillEmptyHotAreas, Function | SmallTest | Level3)
+{
+    SessionInfo sessionInfo;
+    sessionInfo.bundleName_ = "accessibilityNotifyTesterBundleName";
+    sessionInfo.abilityName_ = "accessibilityNotifyTesterAbilityName";
+
+    sptr<SceneSession> sceneSession = ssm_->CreateSceneSession(sessionInfo, nullptr);
+    ASSERT_NE(sceneSession, nullptr);
+    SetVisibleForAccessibility(sceneSession);
+    ssm_->sceneSessionMap_.insert({sceneSession->GetPersistentId(), sceneSession});
+
+    std::vector<sptr<SceneSession>> sceneSessionList;
+    std::vector<sptr<AccessibilityWindowInfo>> accessibilityInfo;
+
+    ssm_->GetAllSceneSessionForAccessibility(sceneSessionList);
+    ssm_->FillAccessibilityInfo(sceneSessionList, accessibilityInfo);
+    ASSERT_EQ(accessibilityInfo.size(), 1);
+
+    ASSERT_EQ(accessibilityInfo.at(0)->touchHotAreas_.size(), sceneSessionList.at(0)->GetTouchHotAreas().size());
+    ASSERT_EQ(accessibilityInfo.at(0)->touchHotAreas_.size(), 0);
+}
+
+/**
+ * @tc.name: AccessibilityFillOneHotAreas
+ * @tc.desc: SceneSesionManager fill one hot areas to accessibilityInfo;
+ * @tc.type: FUNC
+*/
+HWTEST_F(SceneSessionManagerTest, AccessibilityFillOneHotAreas, Function | SmallTest | Level3)
+{
+    SessionInfo sessionInfo;
+    sessionInfo.bundleName_ = "accessibilityNotifyTesterBundleName";
+    sessionInfo.abilityName_ = "accessibilityNotifyTesterAbilityName";
+
+    Rect rect = {100, 200, 100, 200};
+    std::vector<Rect> hotAreas;
+    hotAreas.push_back(rect);
+    sptr<SceneSession> sceneSession = ssm_->CreateSceneSession(sessionInfo, nullptr);
+    ASSERT_NE(sceneSession, nullptr);
+    sceneSession->SetTouchHotAreas(hotAreas);
+    SetVisibleForAccessibility(sceneSession);
+    ssm_->sceneSessionMap_.insert({sceneSession->GetPersistentId(), sceneSession});
+
+    std::vector<sptr<SceneSession>> sceneSessionList;
+    std::vector<sptr<AccessibilityWindowInfo>> accessibilityInfo;
+
+    ssm_->GetAllSceneSessionForAccessibility(sceneSessionList);
+    ssm_->FillAccessibilityInfo(sceneSessionList, accessibilityInfo);
+    ASSERT_EQ(accessibilityInfo.size(), 1);
+
+    ASSERT_EQ(accessibilityInfo.at(0)->touchHotAreas_.size(), sceneSessionList.at(0)->GetTouchHotAreas().size());
+    ASSERT_EQ(accessibilityInfo.at(0)->touchHotAreas_.size(), 1);
+
+    ASSERT_EQ(rect.posX_, sceneSessionList.at(0)->GetTouchHotAreas().at(0).posX_);
+    ASSERT_EQ(rect.posY_, sceneSessionList.at(0)->GetTouchHotAreas().at(0).posY_);
+    ASSERT_EQ(rect.width_, sceneSessionList.at(0)->GetTouchHotAreas().at(0).width_);
+    ASSERT_EQ(rect.height_, sceneSessionList.at(0)->GetTouchHotAreas().at(0).height_);
+
+    ASSERT_EQ(accessibilityInfo.at(0)->touchHotAreas_.at(0).posX_, rect.posX_);
+    ASSERT_EQ(accessibilityInfo.at(0)->touchHotAreas_.at(0).posY_, rect.posY_);
+    ASSERT_EQ(accessibilityInfo.at(0)->touchHotAreas_.at(0).width_, rect.width_);
+    ASSERT_EQ(accessibilityInfo.at(0)->touchHotAreas_.at(0).height_, rect.height_);
+}
+
+/**
+ * @tc.name: AccessibilityFillTwoHotAreas
+ * @tc.desc: SceneSesionManager fill two hot areas to accessibilityInfo;
+ * @tc.type: FUNC
+*/
+HWTEST_F(SceneSessionManagerTest, AccessibilityFillTwoHotAreas, Function | SmallTest | Level3)
+{
+    SessionInfo sessionInfo;
+    sessionInfo.bundleName_ = "accessibilityNotifyTesterBundleName";
+    sessionInfo.abilityName_ = "accessibilityNotifyTesterAbilityName";
+
+    sptr<WindowSessionProperty> property = new WindowSessionProperty();
+    std::vector<Rect> hotAreas;
+    Rect rectFitst = {100, 200, 100, 200};
+    Rect rectSecond = {50, 50, 20, 30};
+    hotAreas.push_back(rectFitst);
+    hotAreas.push_back(rectSecond);
+    sptr<SceneSession> sceneSession = ssm_->CreateSceneSession(sessionInfo, nullptr);
+    ASSERT_NE(sceneSession, nullptr);
+    sceneSession->SetTouchHotAreas(hotAreas);
+    SetVisibleForAccessibility(sceneSession);
+    ssm_->sceneSessionMap_.insert({sceneSession->GetPersistentId(), sceneSession});
+
+    std::vector<sptr<SceneSession>> sceneSessionList;
+    std::vector<sptr<AccessibilityWindowInfo>> accessibilityInfo;
+
+    ssm_->GetAllSceneSessionForAccessibility(sceneSessionList);
+    ssm_->FillAccessibilityInfo(sceneSessionList, accessibilityInfo);
+    ASSERT_EQ(accessibilityInfo.size(), 1);
+
+    ASSERT_EQ(accessibilityInfo.at(0)->touchHotAreas_.size(), sceneSessionList.at(0)->GetTouchHotAreas().size());
+    ASSERT_EQ(accessibilityInfo.at(0)->touchHotAreas_.size(), 2);
+
+    ASSERT_EQ(accessibilityInfo.at(0)->touchHotAreas_.at(0).posX_, rectFitst.posX_);
+    ASSERT_EQ(accessibilityInfo.at(0)->touchHotAreas_.at(0).posY_, rectFitst.posY_);
+    ASSERT_EQ(accessibilityInfo.at(0)->touchHotAreas_.at(0).width_, rectFitst.width_);
+    ASSERT_EQ(accessibilityInfo.at(0)->touchHotAreas_.at(0).height_, rectFitst.height_);
+
+    ASSERT_EQ(accessibilityInfo.at(0)->touchHotAreas_.at(1).posX_, rectSecond.posX_);
+    ASSERT_EQ(accessibilityInfo.at(0)->touchHotAreas_.at(1).posY_, rectSecond.posY_);
+    ASSERT_EQ(accessibilityInfo.at(0)->touchHotAreas_.at(1).width_, rectSecond.width_);
+    ASSERT_EQ(accessibilityInfo.at(0)->touchHotAreas_.at(1).height_, rectSecond.height_);
+}
+
+/**
+ * @tc.name: AccessibilityFilterEmptySceneSessionList
+ * @tc.desc: SceneSesionManager filter empty scene session list;
+ * @tc.type: FUNC
+*/
+HWTEST_F(SceneSessionManagerTest, AccessibilityFilterEmptySceneSessionList, Function | SmallTest | Level3)
+{
+    std::vector<sptr<SceneSession>> sceneSessionList;
+
+    ssm_->FilterSceneSessionForAccessibility(sceneSessionList);
+    ASSERT_EQ(sceneSessionList.size(), 0);
+}
+
+/**
+ * @tc.name: AccessibilityFilterOneWindow
+ * @tc.desc: SceneSesionManager filter one window;
+ * @tc.type: FUNC
+*/
+HWTEST_F(SceneSessionManagerTest, AccessibilityFilterOneWindow, Function | SmallTest | Level3)
+{
+    SessionInfo sessionInfo;
+    sessionInfo.bundleName_ = "accessibilityNotifyTesterBundleName";
+    sessionInfo.abilityName_ = "accessibilityNotifyTesterAbilityName";
+
+    sptr<SceneSession> sceneSession = ssm_->CreateSceneSession(sessionInfo, nullptr);
+    ASSERT_NE(sceneSession, nullptr);
+    sceneSession->SetSessionRect({100, 100, 200, 200});
+    SetVisibleForAccessibility(sceneSession);
+    ssm_->sceneSessionMap_.insert({sceneSession->GetPersistentId(), sceneSession});
+
+    std::vector<sptr<SceneSession>> sceneSessionList;
+    std::vector<sptr<AccessibilityWindowInfo>> accessibilityInfo;
+    ssm_->GetAllSceneSessionForAccessibility(sceneSessionList);
+    ssm_->FilterSceneSessionForAccessibility(sceneSessionList);
+    ssm_->FillAccessibilityInfo(sceneSessionList, accessibilityInfo);
+    ASSERT_EQ(accessibilityInfo.size(), 1);
+}
+
+/**
+ * @tc.name: AccessibilityFilterTwoWindowNotCovered
+ * @tc.desc: SceneSesionManager filter two windows that not covered each other;
+ * @tc.type: FUNC
+*/
+HWTEST_F(SceneSessionManagerTest, AccessibilityFilterTwoWindowNotCovered, Function | SmallTest | Level3)
+{
+    SessionInfo sessionInfo;
+    sessionInfo.bundleName_ = "accessibilityNotifyTesterBundleName";
+    sessionInfo.abilityName_ = "accessibilityNotifyTesterAbilityName";
+
+    sptr<SceneSession> sceneSessionFirst = ssm_->CreateSceneSession(sessionInfo, nullptr);
+    sceneSessionFirst->SetSessionRect({0, 0, 200, 200});
+    SetVisibleForAccessibility(sceneSessionFirst);
+    ssm_->sceneSessionMap_.insert({sceneSessionFirst->GetPersistentId(), sceneSessionFirst});
+
+    sptr<SceneSession> sceneSessionSecond = ssm_->CreateSceneSession(sessionInfo, nullptr);
+    sceneSessionSecond->SetSessionRect({300, 300, 200, 200});
+    SetVisibleForAccessibility(sceneSessionSecond);
+    ssm_->sceneSessionMap_.insert({sceneSessionSecond->GetPersistentId(), sceneSessionSecond});
+
+    std::vector<sptr<SceneSession>> sceneSessionList;
+    std::vector<sptr<AccessibilityWindowInfo>> accessibilityInfo;
+    ssm_->GetAllSceneSessionForAccessibility(sceneSessionList);
+    ssm_->FilterSceneSessionForAccessibility(sceneSessionList);
+    ssm_->FillAccessibilityInfo(sceneSessionList, accessibilityInfo);
+    ASSERT_EQ(accessibilityInfo.size(), 2);
+}
+
+/**
+ * @tc.name: AccessibilityFilterTwoWindowCovered
+ * @tc.desc: SceneSesionManager filter two windows that covered each other;
+ * @tc.type: FUNC
+*/
+HWTEST_F(SceneSessionManagerTest, AccessibilityFilterTwoWindowCovered, Function | SmallTest | Level3)
+{
+    SessionInfo sessionInfo;
+    sessionInfo.bundleName_ = "accessibilityNotifyTesterBundleName";
+    sessionInfo.abilityName_ = "accessibilityNotifyTesterAbilityName";
+
+    sptr<SceneSession> sceneSessionFirst = ssm_->CreateSceneSession(sessionInfo, nullptr);
+    sceneSessionFirst->SetSessionRect({0, 0, 200, 200});
+    SetVisibleForAccessibility(sceneSessionFirst);
+    sceneSessionFirst->SetZOrder(20);
+    ssm_->sceneSessionMap_.insert({sceneSessionFirst->GetPersistentId(), sceneSessionFirst});
+
+    sptr<SceneSession> sceneSessionSecond = ssm_->CreateSceneSession(sessionInfo, nullptr);
+    sceneSessionSecond->SetSessionRect({50, 50, 50, 50});
+    SetVisibleForAccessibility(sceneSessionSecond);
+    sceneSessionFirst->SetZOrder(10);
+    ssm_->sceneSessionMap_.insert({sceneSessionSecond->GetPersistentId(), sceneSessionSecond});
+
+    std::vector<sptr<SceneSession>> sceneSessionList;
+    std::vector<sptr<AccessibilityWindowInfo>> accessibilityInfo;
+    ssm_->GetAllSceneSessionForAccessibility(sceneSessionList);
+    ssm_->FilterSceneSessionForAccessibility(sceneSessionList);
+    ssm_->FillAccessibilityInfo(sceneSessionList, accessibilityInfo);
+    ASSERT_EQ(accessibilityInfo.size(), 1);
+}
+
 }
 } // namespace Rosen
 } // namespace OHOS