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