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