1 /*
2  * Copyright (C) 2022 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  * http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed On an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include "accessibility_window_manager.h"
17 
18 #ifdef OHOS_BUILD_ENABLE_HITRACE
19 #include <hitrace_meter.h>
20 #endif // OHOS_BUILD_ENABLE_HITRACE
21 
22 #include "accessible_ability_manager_service.h"
23 #include "hilog_wrapper.h"
24 #include "utils.h"
25 #include "xcollie_helper.h"
26 
27 namespace OHOS {
28 namespace Accessibility {
29 namespace {
30     const std::string TIMER_GET_ACCESSIBILITY_WINDOWS = "accessibilty:getAccessibilityWindowInfo";
31     constexpr int32_t WMS_TIMEOUT = 10; // s
32 }
33 
AccessibilityWindowManager()34 AccessibilityWindowManager::AccessibilityWindowManager()
35 {
36 }
37 
Init()38 bool AccessibilityWindowManager::Init()
39 {
40     DeInit();
41     HILOG_DEBUG("deinit before start");
42 #ifdef OHOS_BUILD_ENABLE_HITRACE
43     HITRACE_METER_NAME(HITRACE_TAG_ACCESSIBILITY_MANAGER, "QueryWindowInfo");
44 #endif // OHOS_BUILD_ENABLE_HITRACE
45     std::vector<sptr<Rosen::AccessibilityWindowInfo>> windowInfos;
46     Rosen::WMError err = OHOS::Rosen::WindowManager::GetInstance().GetAccessibilityWindowInfo(windowInfos);
47     if (err != Rosen::WMError::WM_OK) {
48         Utils::RecordUnavailableEvent(A11yUnavailableEvent::QUERY_EVENT, A11yError::ERROR_QUERY_WINDOW_INFO_FAILED);
49         HILOG_ERROR("get window info from wms failed. err[%{public}d]", err);
50         return false;
51     }
52     std::lock_guard<ffrt::recursive_mutex> lock(interfaceMutex_);
53     HILOG_DEBUG("windowInfos size is %{public}zu", windowInfos.size());
54     for (auto &window : windowInfos) {
55         if (!window) {
56             HILOG_ERROR("window is nullptr");
57             continue;
58         }
59 
60         int32_t realWid = GetRealWindowId(window);
61         if (!a11yWindows_.count(realWid)) {
62             auto a11yWindowInfo = CreateAccessibilityWindowInfo(window);
63             a11yWindows_.emplace(realWid, a11yWindowInfo);
64         }
65 
66         if (IsSceneBoard(window)) {
67             subWindows_.insert(realWid);
68             sceneBoardElementIdMap_.InsertPair(realWid, window->uiNodeId_);
69         }
70 
71         if (a11yWindows_[realWid].IsFocused()) {
72             SetActiveWindow(realWid);
73         }
74     }
75     return true;
76 }
77 
DeInit()78 void AccessibilityWindowManager::DeInit()
79 {
80     HILOG_DEBUG();
81     std::lock_guard<ffrt::recursive_mutex> lock(interfaceMutex_);
82     a11yWindows_.clear();
83     subWindows_.clear();
84     sceneBoardElementIdMap_.Clear();
85     activeWindowId_ = INVALID_WINDOW_ID;
86     a11yFocusedWindowId_ = INVALID_WINDOW_ID;
87 }
88 
WinDeInit()89 void AccessibilityWindowManager::WinDeInit()
90 {
91     HILOG_DEBUG();
92     std::lock_guard<ffrt::recursive_mutex> lock(interfaceMutex_);
93     a11yWindows_.clear();
94     subWindows_.clear();
95     sceneBoardElementIdMap_.Clear();
96     activeWindowId_ = INVALID_WINDOW_ID;
97 }
98 
~AccessibilityWindowManager()99 AccessibilityWindowManager::~AccessibilityWindowManager()
100 {
101     DeregisterWindowListener();
102 }
103 
RegisterWindowListener(const std::shared_ptr<AppExecFwk::EventHandler> &handler)104 void AccessibilityWindowManager::RegisterWindowListener(const std::shared_ptr<AppExecFwk::EventHandler> &handler)
105 {
106     DeregisterWindowListener();
107     HILOG_DEBUG("deregister before register");
108     if (windowListener_) {
109         HILOG_DEBUG("Window listener is already registered!");
110         return;
111     }
112 
113     eventHandler_ = handler;
114     windowListener_ = new(std::nothrow) AccessibilityWindowListener(*this);
115     if (!windowListener_) {
116         HILOG_ERROR("Create window listener fail!");
117         return;
118     }
119     OHOS::Rosen::WindowManager::GetInstance().RegisterWindowUpdateListener(windowListener_);
120 }
121 
DeregisterWindowListener()122 void AccessibilityWindowManager::DeregisterWindowListener()
123 {
124     if (windowListener_) {
125         OHOS::Rosen::WindowManager::GetInstance().UnregisterWindowUpdateListener(windowListener_);
126         windowListener_ = nullptr;
127         eventHandler_ = nullptr;
128     }
129 }
130 
OnWindowUpdate(const std::vector<sptr<Rosen::AccessibilityWindowInfo>>& infos, Rosen::WindowUpdateType type)131 void AccessibilityWindowManager::OnWindowUpdate(const std::vector<sptr<Rosen::AccessibilityWindowInfo>>& infos,
132     Rosen::WindowUpdateType type)
133 {
134     HILOG_DEBUG("WindowUpdateType type[%{public}d]", type);
135     if (!eventHandler_) {
136         HILOG_ERROR("eventHandler_ is nullptr.");
137         return;
138     }
139     if (infos.size() == 0) {
140         HILOG_ERROR("window info is err");
141         return;
142     }
143     eventHandler_->PostTask([=]() {
144         switch (type) {
145             case Rosen::WindowUpdateType::WINDOW_UPDATE_ADDED: // 1
146                 WindowUpdateAdded(infos);
147                 break;
148             case Rosen::WindowUpdateType::WINDOW_UPDATE_REMOVED: // 2
149                 WindowUpdateRemoved(infos);
150                 break;
151             case Rosen::WindowUpdateType::WINDOW_UPDATE_BOUNDS: // 4
152                 WindowUpdateBounds(infos);
153                 break;
154             case Rosen::WindowUpdateType::WINDOW_UPDATE_ACTIVE: // 5
155                 WindowUpdateActive(infos);
156                 break;
157             case Rosen::WindowUpdateType::WINDOW_UPDATE_FOCUSED: // 3
158                 WindowUpdateFocused(infos);
159                 break;
160             case Rosen::WindowUpdateType::WINDOW_UPDATE_PROPERTY: // 6
161                 WindowUpdateProperty(infos);
162                 break;
163             case Rosen::WindowUpdateType::WINDOW_UPDATE_ALL:
164                 WindowUpdateAll(infos);
165                 break;
166             default:
167                 break;
168         }
169         HILOG_DEBUG("a11yWindows[%{public}zu]", a11yWindows_.size());
170         }, "TASK_ON_WINDOW_UPDATE");
171 }
172 
ConvertToRealWindowId(int32_t windowId, int32_t focusType)173 int32_t AccessibilityWindowManager::ConvertToRealWindowId(int32_t windowId, int32_t focusType)
174 {
175     std::lock_guard<ffrt::recursive_mutex> lock(interfaceMutex_);
176     int32_t winId = windowId;
177     HILOG_DEBUG("ConvertToRealWindowId called, windowId[%{public}d], focusType[%{public}d]", windowId, focusType);
178     if (windowId == ACTIVE_WINDOW_ID) {
179         HILOG_DEBUG("After convert active windowId[%{public}d]", activeWindowId_);
180         winId = activeWindowId_;
181     }
182 
183     if (windowId == ANY_WINDOW_ID) {
184         if (focusType == FOCUS_TYPE_ACCESSIBILITY) {
185             HILOG_DEBUG("After convert a11yFocused windowId[%{public}d] by accessibility type", a11yFocusedWindowId_);
186             winId = a11yFocusedWindowId_;
187         } else if (focusType == FOCUS_TYPE_INPUT) {
188             HILOG_DEBUG("After convert active windowId[%{public}d] by input type", activeWindowId_);
189             winId = activeWindowId_;
190         }
191     }
192 
193     if (subWindows_.count(winId)) {
194         HILOG_DEBUG("After convert normal windowId[%{public}d]", SCENE_BOARD_WINDOW_ID);
195         return SCENE_BOARD_WINDOW_ID;
196     }
197     HILOG_DEBUG("After convert windowId[%{public}d] and activeId[%{public}d]", winId, activeWindowId_);
198     return winId;
199 }
200 
ConvertWindowType(Rosen::WindowType type)201 AccessibilityWindowType ConvertWindowType(Rosen::WindowType type)
202 {
203     AccessibilityWindowType winType = TYPE_WINDOW_INVALID;
204 
205     if (type < Rosen::WindowType::SYSTEM_WINDOW_BASE) {
206         winType = TYPE_APPLICATION;
207     } else if ((type >= Rosen::WindowType::SYSTEM_WINDOW_BASE) && (type <= Rosen::WindowType::SYSTEM_WINDOW_END)) {
208         winType = TYPE_SYSTEM;
209     } else {
210         HILOG_ERROR("Unknown windowType[%{public}d]", type);
211     }
212     return winType;
213 }
214 
CheckIntegerOverflow(const Rosen::Rect& rect)215 bool AccessibilityWindowManager::CheckIntegerOverflow(const Rosen::Rect& rect)
216 {
217     if ((rect.posX_ > 0) && (static_cast<int32_t>(rect.width_) > 0)) {
218         int32_t leftX = INT32_MAX - rect.posX_;
219         if (leftX < static_cast<int32_t>(rect.width_)) {
220             HILOG_ERROR("input parameter invalid posX %{public}d, width_ %{public}u", rect.posX_,
221                 rect.width_);
222             return false;
223         }
224     }
225 
226     if ((rect.posX_ < 0) && (static_cast<int32_t>(rect.width_) < 0)) {
227         int32_t leftX = INT32_MIN - rect.posX_;
228         if (leftX > static_cast<int32_t>(rect.width_)) {
229             HILOG_ERROR("input parameter invalid posX %{public}d, width_ %{public}u", rect.posX_,
230                 rect.width_);
231             return false;
232         }
233     }
234 
235     if ((rect.posY_ > 0) && (static_cast<int32_t>(rect.height_) > 0)) {
236         int32_t leftY = INT32_MAX - rect.posY_;
237         if (leftY < static_cast<int32_t>(rect.height_)) {
238             HILOG_ERROR("input parameter invalid posX %{public}d, height_ %{public}u", rect.posY_,
239                 rect.height_);
240             return false;
241         }
242     }
243 
244     if ((rect.posY_ < 0) && (static_cast<int32_t>(rect.height_) < 0)) {
245         int32_t leftY = INT32_MIN - rect.posY_;
246         if (leftY > static_cast<int32_t>(rect.height_)) {
247             HILOG_ERROR("input parameter invalid posX %{public}d, height_ %{public}u", rect.posY_,
248                 rect.height_);
249             return false;
250         }
251     }
252     return true;
253 }
254 
UpdateAccessibilityWindowInfo(AccessibilityWindowInfo &accWindowInfo, const sptr<Rosen::AccessibilityWindowInfo> windowInfo)255 void AccessibilityWindowManager::UpdateAccessibilityWindowInfo(AccessibilityWindowInfo &accWindowInfo,
256     const sptr<Rosen::AccessibilityWindowInfo> windowInfo)
257 {
258     accWindowInfo.SetScaleVal(windowInfo->scaleVal_);
259     accWindowInfo.SetScaleX(windowInfo->scaleX_);
260     accWindowInfo.SetScaleY(windowInfo->scaleY_);
261     accWindowInfo.SetWindowId(windowInfo->wid_);
262     accWindowInfo.SetMainWindowId(windowInfo->wid_);
263     accWindowInfo.SetWindowType(static_cast<uint32_t>(windowInfo->type_));
264     accWindowInfo.SetWindowMode(static_cast<uint32_t>(windowInfo->mode_));
265     accWindowInfo.SetAccessibilityWindowType(ConvertWindowType(windowInfo->type_));
266     accWindowInfo.SetFocused(windowInfo->focused_);
267     accWindowInfo.SetWindowLayer(windowInfo->layer_);
268     if (static_cast<int32_t>(windowInfo->type_) == 1 && (static_cast<int32_t>(windowInfo->windowRect_.width_) == 0 ||
269         static_cast<int32_t>(windowInfo->windowRect_.height_) == 0)) {
270         HILOG_WARN("invalid window parameters, windowId(%{public}d), posX(%{public}d, posY(%{public}d))",
271             windowInfo->wid_, windowInfo->windowRect_.posX_, windowInfo->windowRect_.posY_);
272     } else {
273         Rect bound;
274         bound.SetLeftTopScreenPostion(windowInfo->windowRect_.posX_, windowInfo->windowRect_.posY_);
275         if (!CheckIntegerOverflow(windowInfo->windowRect_)) {
276             bound.SetRightBottomScreenPostion(windowInfo->windowRect_.posX_, windowInfo->windowRect_.posY_);
277         } else {
278             bound.SetRightBottomScreenPostion(
279                 windowInfo->windowRect_.posX_ + static_cast<int32_t>(windowInfo->windowRect_.width_),
280                 windowInfo->windowRect_.posY_ + static_cast<int32_t>(windowInfo->windowRect_.height_));
281         }
282         accWindowInfo.SetRectInScreen(bound);
283     }
284     accWindowInfo.SetDisplayId(windowInfo->displayId_);
285     accWindowInfo.SetDecorEnable(windowInfo->isDecorEnable_);
286     accWindowInfo.SetUiNodeId(windowInfo->uiNodeId_);
287     accWindowInfo.SetInnerWid(windowInfo->innerWid_);
288     if (accWindowInfo.GetWindowId() == SCENE_BOARD_WINDOW_ID) {
289         accWindowInfo.SetWindowId(windowInfo->innerWid_);
290         HILOG_DEBUG("scene board window id 1 convert inner window id[%{public}d]", windowInfo->innerWid_);
291     }
292     HILOG_DEBUG("bundle name is [%{public}s] , touchHotAreas size(%{public}zu)",
293         windowInfo->bundleName_.c_str(), windowInfo->touchHotAreas_.size());
294     accWindowInfo.SetBundleName(windowInfo->bundleName_);
295     HILOG_DEBUG("UpdateAccessibilityWindowInfo is set bundlename is [%{public}s]",
296         accWindowInfo.GetBundleName().c_str());
297     std::vector<Rect> tempTouchHotAreas = {};
298     for (auto &rect : windowInfo->touchHotAreas_) {
299         HILOG_DEBUG("Rosen::windowinfo x:[%{public}d], y:[%{public}d]; width:[%{public}d], height:[%{public}d]",
300             rect.posX_, rect.posY_, rect.width_, rect.height_);
301         Rect rectTemp;
302         rectTemp.SetLeftTopScreenPostion(rect.posX_, rect.posY_);
303         if (!CheckIntegerOverflow(rect)) {
304             rectTemp.SetRightBottomScreenPostion(rect.posX_, rect.posY_);
305         } else {
306             rectTemp.SetRightBottomScreenPostion(
307                 rect.posX_ + static_cast<int32_t>(rect.width_),
308                 rect.posY_ + static_cast<int32_t>(rect.height_));
309         }
310         tempTouchHotAreas.push_back(rectTemp);
311     }
312     accWindowInfo.SetTouchHotAreas(tempTouchHotAreas);
313     for (auto &outRect : accWindowInfo.GetTouchHotAreas()) {
314         HILOG_DEBUG("left_x:[%{public}d], left_y:[%{public}d]; right_x:[%{public}d], right_y:[%{public}d]",
315             outRect.GetLeftTopXScreenPostion(), outRect.GetLeftTopYScreenPostion(),
316             outRect.GetRightBottomXScreenPostion(), outRect.GetRightBottomYScreenPostion());
317     }
318 }
319 
GetRealWindowId(const sptr<Rosen::AccessibilityWindowInfo> windowInfo)320 int32_t AccessibilityWindowManager::GetRealWindowId(const sptr<Rosen::AccessibilityWindowInfo> windowInfo)
321 {
322     if (windowInfo->wid_ == SCENE_BOARD_WINDOW_ID) {
323         return windowInfo->innerWid_;
324     }
325     return windowInfo->wid_;
326 }
327 
IsSceneBoard(const sptr<Rosen::AccessibilityWindowInfo> windowInfo)328 bool AccessibilityWindowManager::IsSceneBoard(const sptr<Rosen::AccessibilityWindowInfo> windowInfo)
329 {
330     if (windowInfo->wid_ == SCENE_BOARD_WINDOW_ID) {
331         return true;
332     }
333     return false;
334 }
335 
CreateAccessibilityWindowInfo( const sptr<Rosen::AccessibilityWindowInfo> windowInfo)336 AccessibilityWindowInfo AccessibilityWindowManager::CreateAccessibilityWindowInfo(
337     const sptr<Rosen::AccessibilityWindowInfo> windowInfo)
338 {
339     AccessibilityWindowInfo info;
340     UpdateAccessibilityWindowInfo(info, windowInfo);
341     HILOG_DEBUG("Create WindowInfo Id(%{public}d) type(%{public}d) posX(%{public}d) posY(%{public}d)"
342         "witdth(%{public}d) height(%{public}d) display id(%{public}" PRIu64 ") isDecorEnable(%{public}d)"
343         "innerWid(%{public}d), uiNodeId(%{public}d)",
344         windowInfo->wid_, windowInfo->type_, windowInfo->windowRect_.posX_, windowInfo->windowRect_.posY_,
345         windowInfo->windowRect_.width_, windowInfo->windowRect_.height_, windowInfo->displayId_,
346         windowInfo->isDecorEnable_, windowInfo->innerWid_, windowInfo->uiNodeId_);
347     return info;
348 }
349 
SetActiveWindow(int32_t windowId, bool isSendEvent)350 void AccessibilityWindowManager::SetActiveWindow(int32_t windowId, bool isSendEvent)
351 {
352     HILOG_DEBUG("windowId is %{public}d", windowId);
353     std::lock_guard<ffrt::recursive_mutex> lock(interfaceMutex_);
354     if (windowId == INVALID_WINDOW_ID) {
355         ClearOldActiveWindow();
356         activeWindowId_ = INVALID_WINDOW_ID;
357         return;
358     }
359 
360     if (!a11yWindows_.count(windowId)) {
361         HILOG_WARN("Window id is not found");
362         return;
363     }
364 
365     if (activeWindowId_ != windowId) {
366         ClearOldActiveWindow();
367         activeWindowId_ = windowId;
368         a11yWindows_[activeWindowId_].SetActive(true);
369         if (!isSendEvent) {
370             HILOG_DEBUG("not send event, activeWindowId is %{public}d", activeWindowId_);
371             return;
372         }
373         auto &aams = Singleton<AccessibleAbilityManagerService>::GetInstance();
374         AccessibilityEventInfo evtInf(activeWindowId_, WINDOW_UPDATE_ACTIVE);
375         int32_t winId = windowId;
376         if (sceneBoardElementIdMap_.CheckWindowIdPair(windowId)) {
377             winId = SCENE_BOARD_WINDOW_ID;
378         }
379         if (aams.CheckWindowRegister(winId)) {
380             HILOG_DEBUG("send active event, windowId: %{public}d", winId);
381             aams.SendEvent(evtInf);
382         } else {
383             HILOG_DEBUG("wait for window register to process event, windowId: %{public}d", winId);
384             aams.InsertWindowIdEventPair(winId, evtInf);
385         }
386     }
387     HILOG_DEBUG("activeWindowId is %{public}d", activeWindowId_);
388 }
389 
GetActiveWindowId()390 int32_t AccessibilityWindowManager::GetActiveWindowId()
391 {
392     std::lock_guard<ffrt::recursive_mutex> lock(interfaceMutex_);
393     HILOG_DEBUG("activeWindowId_ is %{public}d", activeWindowId_);
394     return activeWindowId_;
395 }
396 
SetAccessibilityFocusedWindow(int32_t windowId)397 void AccessibilityWindowManager::SetAccessibilityFocusedWindow(int32_t windowId)
398 {
399     HILOG_DEBUG("windowId is %{public}d", windowId);
400     std::lock_guard<ffrt::recursive_mutex> lock(interfaceMutex_);
401     if (windowId == INVALID_WINDOW_ID) {
402         ClearAccessibilityFocused();
403         a11yFocusedWindowId_ = INVALID_WINDOW_ID;
404         return;
405     }
406 
407     if (!a11yWindows_.count(windowId)) {
408         HILOG_ERROR("Window id[%{public}d] is not found", windowId);
409         return;
410     }
411 
412     if (a11yFocusedWindowId_ != windowId) {
413         ClearAccessibilityFocused();
414         a11yFocusedWindowId_ = windowId;
415         a11yWindows_[a11yFocusedWindowId_].SetAccessibilityFocused(true);
416     }
417     HILOG_DEBUG("a11yFocusedWindowId_ is %{public}d", a11yFocusedWindowId_);
418 }
419 
GetAccessibilityWindows()420 std::vector<AccessibilityWindowInfo> AccessibilityWindowManager::GetAccessibilityWindows()
421 {
422     HILOG_DEBUG("a11yWindows_ size[%{public}zu]", a11yWindows_.size());
423     XCollieHelper timer(TIMER_GET_ACCESSIBILITY_WINDOWS, WMS_TIMEOUT);
424     std::lock_guard<ffrt::recursive_mutex> lock(interfaceMutex_);
425     std::vector<sptr<Rosen::AccessibilityWindowInfo>> windowInfos;
426     std::vector<AccessibilityWindowInfo> windows;
427     Rosen::WMError err = OHOS::Rosen::WindowManager::GetInstance().GetAccessibilityWindowInfo(windowInfos);
428     if (err != Rosen::WMError::WM_OK) {
429         HILOG_ERROR("get window info from wms failed. err[%{public}d]", err);
430         return windows;
431     }
432     for (auto &info : windowInfos) {
433         if (info == nullptr) {
434             continue;
435         }
436         AccessibilityWindowInfo tmpWindowInfo;
437         UpdateAccessibilityWindowInfo(tmpWindowInfo, info);
438         if (tmpWindowInfo.IsFocused()) {
439             HILOG_DEBUG("set active windowId: %{public}d", tmpWindowInfo.GetWindowId());
440             tmpWindowInfo.SetActive(true);
441         }
442         windows.push_back(tmpWindowInfo);
443     }
444     return windows;
445 }
446 
GetAccessibilityWindow(int32_t windowId, AccessibilityWindowInfo &window)447 bool AccessibilityWindowManager::GetAccessibilityWindow(int32_t windowId, AccessibilityWindowInfo &window)
448 {
449     HILOG_DEBUG("start windowId(%{public}d)", windowId);
450     XCollieHelper timer(TIMER_GET_ACCESSIBILITY_WINDOWS, WMS_TIMEOUT);
451     std::lock_guard<ffrt::recursive_mutex> lock(interfaceMutex_);
452     std::vector<sptr<Rosen::AccessibilityWindowInfo>> windowInfos;
453     Rosen::WMError err = OHOS::Rosen::WindowManager::GetInstance().GetAccessibilityWindowInfo(windowInfos);
454     if (err != Rosen::WMError::WM_OK) {
455         HILOG_ERROR("get window info from wms failed. err[%{public}d]", err);
456         return false;
457     }
458     for (auto &info : windowInfos) {
459         if (info == nullptr) {
460             continue;
461         }
462 
463         int32_t realWidId = GetRealWindowId(info);
464         if (a11yWindows_.count(realWidId)) {
465             UpdateAccessibilityWindowInfo(a11yWindows_[realWidId], info);
466         } else {
467             AccessibilityWindowInfo tmpWindowInfo;
468             UpdateAccessibilityWindowInfo(tmpWindowInfo, info);
469             a11yWindows_[realWidId] = tmpWindowInfo;
470         }
471     }
472     if (a11yWindows_.count(windowId)) {
473         window = a11yWindows_[windowId];
474         return true;
475     }
476     return false;
477 }
478 
IsValidWindow(int32_t windowId)479 bool AccessibilityWindowManager::IsValidWindow(int32_t windowId)
480 {
481     HILOG_DEBUG("start windowId(%{public}d)", windowId);
482     std::lock_guard<ffrt::recursive_mutex> lock(interfaceMutex_);
483     auto it = std::find_if(a11yWindows_.begin(), a11yWindows_.end(),
484         [windowId](const std::map<int32_t, AccessibilityWindowInfo>::value_type &window) {
485             return window.first == windowId;
486         });
487     if (it == a11yWindows_.end()) {
488         return false;
489     }
490     return true;
491 }
492 
SetWindowSize(int32_t windowId, Rect rect)493 void AccessibilityWindowManager::SetWindowSize(int32_t windowId, Rect rect)
494 {
495     HILOG_DEBUG("start windowId(%{public}d)", windowId);
496     std::lock_guard<ffrt::recursive_mutex> lock(interfaceMutex_);
497     auto it = std::find_if(a11yWindows_.begin(), a11yWindows_.end(),
498         [windowId](const std::map<int32_t, AccessibilityWindowInfo>::value_type &window) {
499             return window.first == windowId;
500         });
501     if (it != a11yWindows_.end()) {
502         it->second.SetRectInScreen(rect);
503     }
504 }
505 
CompareRect(const Rect &rectAccessibility, const Rosen::Rect &rectWindow)506 bool AccessibilityWindowManager::CompareRect(const Rect &rectAccessibility, const Rosen::Rect &rectWindow)
507 {
508     HILOG_DEBUG();
509     int32_t leftTopX_ = rectWindow.posX_;
510     int32_t leftTopY_ = rectWindow.posY_;
511     int32_t rightBottomX_ = 0;
512     int32_t rightBottomY_ = 0;
513 
514     if (!CheckIntegerOverflow(rectWindow)) {
515         rightBottomX_ = rectWindow.posX_;
516         rightBottomY_ = rectWindow.posY_;
517     } else {
518         rightBottomX_ = rectWindow.posX_ + static_cast<int32_t>(rectWindow.width_);
519         rightBottomY_ = rectWindow.posY_ + static_cast<int32_t>(rectWindow.height_);
520     }
521 
522     if (rectAccessibility.GetLeftTopXScreenPostion() == leftTopX_ &&
523         rectAccessibility.GetLeftTopYScreenPostion() == leftTopY_ &&
524         rectAccessibility.GetRightBottomXScreenPostion() == rightBottomX_ &&
525         rectAccessibility.GetRightBottomYScreenPostion() == rightBottomY_) {
526         HILOG_DEBUG("rect values are the same");
527         return false;
528     }
529     return true;
530 }
531 
EqualFocus(const Accessibility::AccessibilityWindowInfo &accWindowInfo, const sptr<Rosen::AccessibilityWindowInfo> &windowInfo)532 bool AccessibilityWindowManager::EqualFocus(const Accessibility::AccessibilityWindowInfo &accWindowInfo,
533     const sptr<Rosen::AccessibilityWindowInfo> &windowInfo)
534 {
535     HILOG_DEBUG();
536     if (accWindowInfo.IsFocused() == windowInfo->focused_) {
537         HILOG_DEBUG("focus values are the same");
538         return false;
539     }
540     return true;
541 }
542 
EqualBound(const Accessibility::AccessibilityWindowInfo &accWindowInfo, const sptr<Rosen::AccessibilityWindowInfo> &windowInfo)543 bool AccessibilityWindowManager::EqualBound(const Accessibility::AccessibilityWindowInfo &accWindowInfo,
544     const sptr<Rosen::AccessibilityWindowInfo> &windowInfo)
545 {
546     HILOG_DEBUG();
547     if (static_cast<int32_t>(windowInfo->type_) == 1 && (static_cast<int32_t>(windowInfo->windowRect_.width_) == 0 ||
548         static_cast<int32_t>(windowInfo->windowRect_.height_) == 0)) {
549         HILOG_ERROR("invalid window parameters, windowId(%{public}d), posX(%{public}d, posY(%{public}d))",
550             windowInfo->wid_, windowInfo->windowRect_.posX_, windowInfo->windowRect_.posY_);
551         return false;
552     }
553     return CompareRect(accWindowInfo.GetRectInScreen(), windowInfo->windowRect_);
554 }
555 
EqualProperty(Accessibility::AccessibilityWindowInfo &accWindowInfo, const sptr<Rosen::AccessibilityWindowInfo> &windowInfo)556 bool AccessibilityWindowManager::EqualProperty(Accessibility::AccessibilityWindowInfo &accWindowInfo,
557     const sptr<Rosen::AccessibilityWindowInfo> &windowInfo)
558 {
559     HILOG_DEBUG();
560     std::ostringstream  accInfoStr;
561     std::ostringstream  winInfoStr;
562 
563     accInfoStr << accWindowInfo.GetWindowMode()
564                << accWindowInfo.GetWindowLayer()
565                << accWindowInfo.IsDecorEnable()
566                << accWindowInfo.GetWindowType()
567                << accWindowInfo.GetDisplayId()
568                << accWindowInfo.GetScaleVal()
569                << accWindowInfo.GetScaleX()
570                << accWindowInfo.GetScaleY();
571     HILOG_DEBUG("Create accinfoStr windowMode_[%{public}d] Layer_[%{public}d] isDecorEnable_[%{public}d]"
572         "windowType_[%{public}d] displayId:%{public}" PRIu64 " get scaleVal_ [%{public}f]"
573         "get scaleX_ [%{public}f] get scaleY_ [%{public}f]",
574         accWindowInfo.GetWindowMode(), accWindowInfo.GetWindowLayer(), accWindowInfo.IsDecorEnable(),
575         accWindowInfo.GetWindowType(), accWindowInfo.GetDisplayId(), accWindowInfo.GetScaleVal(),
576         accWindowInfo.GetScaleX(), accWindowInfo.GetScaleY());
577 
578     winInfoStr << static_cast<uint32_t>(windowInfo->mode_)
579                << windowInfo->layer_
580                << windowInfo->isDecorEnable_
581                << static_cast<uint32_t>(windowInfo->type_)
582                << windowInfo->displayId_
583                << windowInfo->scaleVal_
584                << windowInfo->scaleX_
585                << windowInfo->scaleY_;
586     HILOG_DEBUG("Create wininfoStr Mode_[%{public}d] Layer_[%{public}d] isDecorEnable_[%{public}d]"
587         "Type_[%{public}d] displayId:%{public}" PRIu64 " scaleVal_ [%{public}f]"
588         "scaleX_ [%{public}f] scaleY_ [%{public}f]",
589         static_cast<uint32_t>(windowInfo->mode_), windowInfo->layer_, windowInfo->isDecorEnable_,
590         static_cast<uint32_t>(windowInfo->type_), windowInfo->displayId_, windowInfo->scaleVal_,
591         windowInfo->scaleX_, windowInfo->scaleY_);
592 
593     if (accInfoStr.str() != winInfoStr.str() ||
594         windowInfo->touchHotAreas_.size() != accWindowInfo.GetTouchHotAreas().size()) {
595         HILOG_DEBUG("Property different");
596         return true;
597     }
598     for (uint32_t i = 0; i < accWindowInfo.GetTouchHotAreas().size(); i++) {
599         if (CompareRect(accWindowInfo.GetTouchHotAreas()[i], windowInfo->touchHotAreas_[i])) {
600             HILOG_DEBUG("touchHotAreas different");
601             return true;
602         }
603     }
604     return false;
605 }
606 
WindowUpdateAdded(const std::vector<sptr<Rosen::AccessibilityWindowInfo>>& infos)607 void AccessibilityWindowManager::WindowUpdateAdded(const std::vector<sptr<Rosen::AccessibilityWindowInfo>>& infos)
608 {
609     HILOG_DEBUG();
610     std::lock_guard<ffrt::recursive_mutex> lock(interfaceMutex_);
611     for (auto &windowInfo : infos) {
612         if (!windowInfo) {
613             HILOG_ERROR("invalid windowInfo");
614             return;
615         }
616 
617         int32_t realWidId = GetRealWindowId(windowInfo);
618         if (!a11yWindows_.count(realWidId)) {
619             auto a11yWindowInfoAdded = CreateAccessibilityWindowInfo(windowInfo);
620             a11yWindows_.emplace(realWidId, a11yWindowInfoAdded);
621         } else {
622             UpdateAccessibilityWindowInfo(a11yWindows_[realWidId], windowInfo);
623         }
624 
625         if (IsSceneBoard(windowInfo)) {
626             subWindows_.insert(realWidId);
627             sceneBoardElementIdMap_.InsertPair(realWidId, windowInfo->uiNodeId_);
628         }
629         AccessibilityEventInfo evtInfAdded(realWidId, WINDOW_UPDATE_ADDED);
630         Singleton<AccessibleAbilityManagerService>::GetInstance().SendEvent(evtInfAdded);
631         if (a11yWindows_[realWidId].IsFocused()) {
632             SetActiveWindow(realWidId);
633         }
634     }
635 }
636 
WindowUpdateRemoved(const std::vector<sptr<Rosen::AccessibilityWindowInfo>>& infos)637 void AccessibilityWindowManager::WindowUpdateRemoved(const std::vector<sptr<Rosen::AccessibilityWindowInfo>>& infos)
638 {
639     HILOG_DEBUG();
640     std::lock_guard<ffrt::recursive_mutex> lock(interfaceMutex_);
641     auto &aams = Singleton<AccessibleAbilityManagerService>::GetInstance();
642     for (auto &windowInfo : infos) {
643         if (!windowInfo) {
644             HILOG_ERROR("invalid windowInfo");
645             return;
646         }
647 
648         int32_t realWidId = GetRealWindowId(windowInfo);
649         if (!a11yWindows_.count(realWidId)) {
650             return;
651         }
652         if (realWidId == activeWindowId_) {
653             SetActiveWindow(INVALID_WINDOW_ID);
654         }
655         if (realWidId == a11yFocusedWindowId_) {
656             SetAccessibilityFocusedWindow(INVALID_WINDOW_ID);
657         }
658         a11yWindows_.erase(realWidId);
659         subWindows_.erase(realWidId);
660         sceneBoardElementIdMap_.RemovePair(realWidId);
661         AccessibilityEventInfo evtInfRemoved(realWidId, WINDOW_UPDATE_REMOVED);
662         aams.SendEvent(evtInfRemoved);
663     }
664 }
665 
WindowUpdateFocused(const std::vector<sptr<Rosen::AccessibilityWindowInfo>>& infos)666 void AccessibilityWindowManager::WindowUpdateFocused(const std::vector<sptr<Rosen::AccessibilityWindowInfo>>& infos)
667 {
668     HILOG_DEBUG();
669     std::lock_guard<ffrt::recursive_mutex> lock(interfaceMutex_);
670     auto &aams = Singleton<AccessibleAbilityManagerService>::GetInstance();
671     for (auto &windowInfo : infos) {
672         if (!windowInfo) {
673             HILOG_ERROR("invalid windowInfo");
674             return;
675         }
676 
677         int32_t realWidId = GetRealWindowId(windowInfo);
678         if (!a11yWindows_.count(realWidId)) {
679             HILOG_DEBUG("window not created");
680             auto a11yWindowInfoFocused = CreateAccessibilityWindowInfo(windowInfo);
681             a11yWindows_.emplace(realWidId, a11yWindowInfoFocused);
682         }
683 
684         if (IsSceneBoard(windowInfo)) {
685             subWindows_.insert(realWidId);
686             sceneBoardElementIdMap_.InsertPair(realWidId, windowInfo->uiNodeId_);
687         }
688         SetActiveWindow(realWidId);
689         AccessibilityEventInfo evtInfFocused(realWidId, WINDOW_UPDATE_FOCUSED);
690         aams.SendEvent(evtInfFocused);
691     }
692 }
693 
WindowUpdateBounds(const std::vector<sptr<Rosen::AccessibilityWindowInfo>>& infos)694 void AccessibilityWindowManager::WindowUpdateBounds(const std::vector<sptr<Rosen::AccessibilityWindowInfo>>& infos)
695 {
696     HILOG_DEBUG();
697     std::lock_guard<ffrt::recursive_mutex> lock(interfaceMutex_);
698     auto &aams = Singleton<AccessibleAbilityManagerService>::GetInstance();
699     for (auto &windowInfo : infos) {
700         if (!windowInfo) {
701             HILOG_ERROR("invalid windowInfo");
702             return;
703         }
704 
705         int32_t realWidId = GetRealWindowId(windowInfo);
706         if (a11yWindows_.count(realWidId)) {
707             UpdateAccessibilityWindowInfo(a11yWindows_[realWidId], windowInfo);
708         }
709 
710         AccessibilityEventInfo evtInfBounds(realWidId, WINDOW_UPDATE_BOUNDS);
711         aams.SendEvent(evtInfBounds);
712     }
713 }
714 
WindowUpdateActive(const std::vector<sptr<Rosen::AccessibilityWindowInfo>>& infos)715 void AccessibilityWindowManager::WindowUpdateActive(const std::vector<sptr<Rosen::AccessibilityWindowInfo>>& infos)
716 {
717     HILOG_DEBUG();
718     std::lock_guard<ffrt::recursive_mutex> lock(interfaceMutex_);
719     for (auto &windowInfo : infos) {
720         if (!windowInfo) {
721             HILOG_ERROR("invalid windowInfo");
722             return;
723         }
724 
725         int32_t realWidId = GetRealWindowId(windowInfo);
726         if (!a11yWindows_.count(realWidId)) {
727             auto a11yWindowInfoActive = CreateAccessibilityWindowInfo(windowInfo);
728             a11yWindows_.emplace(realWidId, a11yWindowInfoActive);
729         }
730 
731         if (IsSceneBoard(windowInfo)) {
732             subWindows_.insert(realWidId);
733             sceneBoardElementIdMap_.InsertPair(realWidId, windowInfo->uiNodeId_);
734         }
735         SetActiveWindow(realWidId);
736     }
737 }
738 
WindowUpdateProperty(const std::vector<sptr<Rosen::AccessibilityWindowInfo>>& infos)739 void AccessibilityWindowManager::WindowUpdateProperty(const std::vector<sptr<Rosen::AccessibilityWindowInfo>>& infos)
740 {
741     HILOG_DEBUG();
742     std::lock_guard<ffrt::recursive_mutex> lock(interfaceMutex_);
743     auto &aams = Singleton<AccessibleAbilityManagerService>::GetInstance();
744     for (auto &windowInfo : infos) {
745         if (!windowInfo) {
746             HILOG_ERROR("invalid windowInfo");
747             return;
748         }
749 
750         int32_t realWidId = GetRealWindowId(windowInfo);
751         if (a11yWindows_.count(realWidId)) {
752             UpdateAccessibilityWindowInfo(a11yWindows_[realWidId], windowInfo);
753         }
754         AccessibilityEventInfo evtInfProperty(realWidId, WINDOW_UPDATE_PROPERTY);
755         aams.SendEvent(evtInfProperty);
756     }
757 }
758 
WindowUpdateTypeEvent(const int32_t realWidId, Accessibility::WindowUpdateType type)759 void AccessibilityWindowManager::WindowUpdateTypeEvent(const int32_t realWidId, Accessibility::WindowUpdateType type)
760 {
761     HILOG_DEBUG();
762     std::lock_guard<ffrt::recursive_mutex> lock(interfaceMutex_);
763     HILOG_DEBUG("WindowUpdateType type[%{public}d]", type);
764     auto &aams = Singleton<AccessibleAbilityManagerService>::GetInstance();
765     switch (type) {
766         case WindowUpdateType::WINDOW_UPDATE_ADDED: {
767             AccessibilityEventInfo evtInfAdded(realWidId, WINDOW_UPDATE_ADDED);
768             Singleton<AccessibleAbilityManagerService>::GetInstance().SendEvent(evtInfAdded);
769             if (a11yWindows_[realWidId].IsFocused()) {
770                 SetActiveWindow(realWidId);
771             }
772             break;
773             }
774         case WindowUpdateType::WINDOW_UPDATE_REMOVED: {
775             if (realWidId == activeWindowId_) {
776                 SetActiveWindow(INVALID_WINDOW_ID);
777             }
778             if (realWidId == a11yFocusedWindowId_) {
779                 SetAccessibilityFocusedWindow(INVALID_WINDOW_ID);
780             }
781 
782             AccessibilityEventInfo evtInfRemoved(realWidId, WINDOW_UPDATE_REMOVED);
783             aams.SendEvent(evtInfRemoved);
784             break;
785             }
786         case WindowUpdateType::WINDOW_UPDATE_BOUNDS: {
787             AccessibilityEventInfo evtInfBounds(realWidId, WINDOW_UPDATE_BOUNDS);
788             aams.SendEvent(evtInfBounds);
789             break;
790             }
791         case WindowUpdateType::WINDOW_UPDATE_FOCUSED: {
792             SetActiveWindow(realWidId);
793             AccessibilityEventInfo evtInfFocused(realWidId, WINDOW_UPDATE_FOCUSED);
794             aams.SendEvent(evtInfFocused);
795             break;
796             }
797         case WindowUpdateType::WINDOW_UPDATE_PROPERTY: {
798             AccessibilityEventInfo evtInfProperty(realWidId, WINDOW_UPDATE_PROPERTY);
799             aams.SendEvent(evtInfProperty);
800             break;
801             }
802         default:
803             break;
804         }
805 }
806 
WindowUpdateAll(const std::vector<sptr<Rosen::AccessibilityWindowInfo>>& infos)807 void AccessibilityWindowManager::WindowUpdateAll(const std::vector<sptr<Rosen::AccessibilityWindowInfo>>& infos)
808 {
809     HILOG_DEBUG();
810     std::lock_guard<ffrt::recursive_mutex> lock(interfaceMutex_);
811     auto oldA11yWindows_ = a11yWindows_;
812     HILOG_DEBUG("WindowUpdateAll info size(%{public}zu), oldA11yWindows_ size(%{public}zu)",
813         infos.size(), oldA11yWindows_.size());
814     WinDeInit();
815     for (auto &window : infos) {
816         if (window == nullptr) {
817             HILOG_ERROR("window is nullptr");
818             continue;
819         }
820         int32_t realWid = GetRealWindowId(window);
821         HILOG_DEBUG("windowInfo wid: %{public}d, innerWid: %{public}d, focused: %{public}d",
822             window->wid_, window->innerWid_, window->focused_);
823         if (!a11yWindows_.count(realWid)) {
824             auto a11yWindowInfo = CreateAccessibilityWindowInfo(window);
825             a11yWindows_.emplace(realWid, a11yWindowInfo);
826             HILOG_DEBUG("WindowUpdateAll a11yWindowInfo size(%{public}s)", a11yWindowInfo.GetBundleName().c_str());
827         }
828         if (IsSceneBoard(window)) {
829             subWindows_.insert(realWid);
830             sceneBoardElementIdMap_.InsertPair(realWid, window->uiNodeId_);
831         }
832 
833         if (window->focused_) {
834             SetActiveWindow(realWid);
835         }
836 
837         if (!oldA11yWindows_.count(realWid)) {
838             WindowUpdateTypeEvent(realWid, WINDOW_UPDATE_ADDED);
839         } else {
840             if (EqualFocus(oldA11yWindows_[realWid], window)) {
841                 WindowUpdateTypeEvent(realWid, WINDOW_UPDATE_FOCUSED);
842             }
843             if (EqualBound(oldA11yWindows_[realWid], window)) {
844                 WindowUpdateTypeEvent(realWid, WINDOW_UPDATE_BOUNDS);
845             }
846             if (EqualProperty(oldA11yWindows_[realWid], window)) {
847                 WindowUpdateTypeEvent(realWid, WINDOW_UPDATE_PROPERTY);
848             }
849             auto itr = oldA11yWindows_.find(realWid);
850             if (itr != oldA11yWindows_.end()) {
851                 oldA11yWindows_.erase(itr);
852             }
853         }
854     }
855 
856     for (auto it = oldA11yWindows_.begin(); it != oldA11yWindows_.end(); ++it) {
857         WindowUpdateTypeEvent(it->first, WINDOW_UPDATE_REMOVED);
858     }
859     HILOG_DEBUG("WindowUpdateAll a11yWindowInfo_ size(%{public}zu)", a11yWindows_.size());
860 }
861 
ClearOldActiveWindow()862 void AccessibilityWindowManager::ClearOldActiveWindow()
863 {
864     HILOG_DEBUG("active window id is %{public}d", activeWindowId_);
865     std::lock_guard<ffrt::recursive_mutex> lock(interfaceMutex_);
866     if (activeWindowId_ == INVALID_WINDOW_ID) {
867         HILOG_DEBUG("active window id is invalid");
868         return;
869     }
870 
871     if (a11yWindows_.count(activeWindowId_)) {
872         a11yWindows_[activeWindowId_].SetActive(false);
873     }
874     if (activeWindowId_ == a11yFocusedWindowId_) {
875         HILOG_DEBUG("Old active window is a11yFocused window.");
876         SetAccessibilityFocusedWindow(INVALID_WINDOW_ID);
877     }
878 }
879 
ClearAccessibilityFocused()880 void AccessibilityWindowManager::ClearAccessibilityFocused()
881 {
882     HILOG_DEBUG("a11yFocused window id is %{public}d", a11yFocusedWindowId_);
883     std::lock_guard<ffrt::recursive_mutex> lock(interfaceMutex_);
884     if (a11yFocusedWindowId_ == INVALID_WINDOW_ID) {
885         HILOG_DEBUG("a11yFocused window id is invalid");
886         return;
887     }
888 
889     if (a11yWindows_.count(a11yFocusedWindowId_)) {
890         a11yWindows_[a11yFocusedWindowId_].SetAccessibilityFocused(false);
891     }
892 
893     int32_t windowId = a11yFocusedWindowId_;
894     if (subWindows_.count(a11yFocusedWindowId_)) {
895         windowId = SCENE_BOARD_WINDOW_ID;
896     }
897     sptr<AccessibilityAccountData> accountData =
898         Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
899     if (!accountData) {
900         HILOG_ERROR("accountData is nullptr");
901         return;
902     }
903     sptr<AccessibilityWindowConnection> connection =
904         accountData->GetAccessibilityWindowConnection(windowId);
905     if (!connection) {
906         HILOG_ERROR("windowId[%{public}d] has no connection", windowId);
907         return;
908     }
909     if (!connection->GetProxy()) {
910         HILOG_ERROR("windowId[%{public}d] has no proxy", windowId);
911         return;
912     }
913     connection->GetProxy()->ClearFocus();
914 
915     // Send event
916     AccessibilityEventInfo eventInfo(TYPE_VIEW_ACCESSIBILITY_FOCUS_CLEARED_EVENT);
917     eventInfo.SetWindowId(a11yFocusedWindowId_);
918     Singleton<AccessibleAbilityManagerService>::GetInstance().SendEvent(eventInfo);
919 }
920 
GetSceneBoardElementId(const int32_t windowId, const int64_t elementId)921 int64_t AccessibilityWindowManager::GetSceneBoardElementId(const int32_t windowId, const int64_t elementId)
922 {
923     std::lock_guard<ffrt::recursive_mutex> lock(interfaceMutex_);
924     if (elementId != INVALID_SCENE_BOARD_ELEMENT_ID) {
925         return elementId;
926     }
927     if (subWindows_.count(windowId)) {
928         auto iter = a11yWindows_.find(windowId);
929         if (iter != a11yWindows_.end()) {
930             HILOG_DEBUG("GetSceneBoardElementId [%{public}" PRId64 "]", iter->second.GetUiNodeId());
931             return iter->second.GetUiNodeId();
932         }
933     }
934     return elementId;
935 }
936 
GetRealWindowAndElementId(int32_t& windowId, int64_t& elementId)937 void AccessibilityWindowManager::GetRealWindowAndElementId(int32_t& windowId, int64_t& elementId)
938 {
939     // sceneboard window id, element id is not equal -1
940     std::lock_guard<ffrt::recursive_mutex> lock(interfaceMutex_);
941     if (subWindows_.count(windowId) && elementId != INVALID_SCENE_BOARD_ELEMENT_ID) {
942         windowId = SCENE_BOARD_WINDOW_ID;
943         HILOG_INFO("windowId %{public}d, elementId %{public}" PRId64 "", windowId, elementId);
944         return;
945     }
946 
947     if (elementId != INVALID_SCENE_BOARD_ELEMENT_ID) {
948         return;
949     }
950 
951     if (subWindows_.count(windowId)) {
952         auto iter = a11yWindows_.find(windowId);
953         if (iter != a11yWindows_.end()) {
954             HILOG_DEBUG("GetRealWindowAndElementId [%{public}" PRId64 "]", iter->second.GetUiNodeId());
955             windowId = SCENE_BOARD_WINDOW_ID;
956             elementId = iter->second.GetUiNodeId();
957             return;
958         }
959     }
960 }
961 
GetSceneBoardInnerWinId(int32_t windowId, int64_t elementId, int32_t& innerWid)962 void AccessibilityWindowManager::GetSceneBoardInnerWinId(int32_t windowId, int64_t elementId,
963     int32_t& innerWid)
964 {
965     std::lock_guard<ffrt::recursive_mutex> lock(interfaceMutex_);
966     if (windowId != SCENE_BOARD_WINDOW_ID) {
967         return;
968     }
969 
970     for (auto iter = a11yWindows_.begin(); iter != a11yWindows_.end(); iter++) {
971         if (iter->second.GetUiNodeId() == elementId) {
972             innerWid = iter->second.GetInnerWid();
973         }
974     }
975 
976     return;
977 }
978 
InsertPair(const int32_t windowId, const int64_t elementId)979 void AccessibilityWindowManager::SceneBoardElementIdMap::InsertPair(const int32_t windowId, const int64_t elementId)
980 {
981     std::lock_guard<ffrt::mutex> lock(mapMutex_);
982     windowElementMap_[windowId] = elementId;
983 }
984 
RemovePair(const int32_t windowId)985 void AccessibilityWindowManager::SceneBoardElementIdMap::RemovePair(const int32_t windowId)
986 {
987     std::lock_guard<ffrt::mutex> lock(mapMutex_);
988     windowElementMap_.erase(windowId);
989 }
990 
CheckWindowIdPair(const int32_t windowId)991 bool AccessibilityWindowManager::SceneBoardElementIdMap::CheckWindowIdPair(const int32_t windowId)
992 {
993     std::lock_guard<ffrt::mutex> lock(mapMutex_);
994     return windowElementMap_.count(windowId);
995 }
996 
Clear()997 void AccessibilityWindowManager::SceneBoardElementIdMap::Clear()
998 {
999     std::lock_guard<ffrt::mutex> lock(mapMutex_);
1000     windowElementMap_.clear();
1001 }
1002 
GetAllPairs()1003 std::map<int32_t, int64_t> AccessibilityWindowManager::SceneBoardElementIdMap::GetAllPairs()
1004 {
1005     std::lock_guard<ffrt::mutex> lock(mapMutex_);
1006     return windowElementMap_;
1007 }
1008 
GetFocusedWindowId(int32_t &focusedWindowId)1009 RetError AccessibilityWindowManager::GetFocusedWindowId(int32_t &focusedWindowId)
1010 {
1011     HILOG_DEBUG();
1012 #ifdef OHOS_BUILD_ENABLE_HITRACE
1013     HITRACE_METER_NAME(HITRACE_TAG_ACCESSIBILITY_MANAGER, "QueryFocusedWindowInfo");
1014 #endif // OHOS_BUILD_ENABLE_HITRACE
1015     Rosen::FocusChangeInfo focusedWindowInfo;
1016     OHOS::Rosen::WindowManager::GetInstance().GetFocusWindowInfo(focusedWindowInfo);
1017     if (focusedWindowInfo.windowId_ == INVALID_WINDOW_ID) {
1018         return RET_ERR_INVALID_PARAM;
1019     }
1020     focusedWindowId = focusedWindowInfo.windowId_;
1021     return RET_OK;
1022 }
1023 
IsInnerWindowRootElement(int64_t elementId)1024 bool AccessibilityWindowManager::IsInnerWindowRootElement(int64_t elementId)
1025 {
1026     HILOG_DEBUG("IsInnerWindowRootElement elementId: %{public}" PRId64 "", elementId);
1027     auto mapTable = sceneBoardElementIdMap_.GetAllPairs();
1028     for (auto iter = mapTable.begin(); iter != mapTable.end(); iter++) {
1029         if (elementId == iter->second) {
1030             return true;
1031         }
1032     }
1033     return false;
1034 }
1035 } // namespace Accessibility
1036 } // namespace OHOS