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
24 namespace OHOS {
25 namespace Accessibility {
AccessibilityWindowManager()26 AccessibilityWindowManager::AccessibilityWindowManager()
27 {
28 }
29
Init()30 bool AccessibilityWindowManager::Init()
31 {
32 HILOG_DEBUG("start");
33 HITRACE_METER_NAME(HITRACE_TAG_ACCESSIBILITY_MANAGER, "QueryWindowInfo");
34 std::vector<sptr<Rosen::AccessibilityWindowInfo>> windowInfos;
35 Rosen::WMError err = OHOS::Rosen::WindowManager::GetInstance().GetAccessibilityWindowInfo(windowInfos);
36 if (err != Rosen::WMError::WM_OK) {
37 Utils::RecordUnavailableEvent(A11yUnavailableEvent::QUERY_EVENT, A11yError::ERROR_QUERY_WINDOW_INFO_FAILED);
38 HILOG_ERROR("get window info from wms failed. err[%{public}d]", err);
39 return false;
40 }
41 HILOG_DEBUG("windowInfos size is %{public}zu", windowInfos.size());
42 for (auto &window : windowInfos) {
43 if (!window) {
44 HILOG_ERROR("window is nullptr");
45 continue;
46 }
47
48 int32_t realWid = GetRealWindowId(window);
49 if (!a11yWindows_.count(realWid)) {
50 auto a11yWindowInfo = CreateAccessibilityWindowInfo(window);
51 a11yWindows_.emplace(realWid, a11yWindowInfo);
52 }
53
54 if (IsSceneBoard(window)) {
55 subWindows_.insert(realWid);
56 }
57
58 if (a11yWindows_[realWid].IsFocused()) {
59 SetActiveWindow(realWid);
60 }
61 }
62 return true;
63 }
64
DeInit()65 void AccessibilityWindowManager::DeInit()
66 {
67 HILOG_DEBUG("start");
68 a11yWindows_.clear();
69 subWindows_.clear();
70 activeWindowId_ = INVALID_WINDOW_ID;
71 a11yFocusedWindowId_ = INVALID_WINDOW_ID;
72 }
73
~AccessibilityWindowManager()74 AccessibilityWindowManager::~AccessibilityWindowManager()
75 {
76 DeregisterWindowListener();
77 }
78
RegisterWindowListener(const std::shared_ptr<AppExecFwk::EventHandler> & handler)79 void AccessibilityWindowManager::RegisterWindowListener(const std::shared_ptr<AppExecFwk::EventHandler> &handler)
80 {
81 if (windowListener_) {
82 HILOG_DEBUG("Window listener is already registered!");
83 return;
84 }
85
86 eventHandler_ = handler;
87 windowListener_ = new(std::nothrow) AccessibilityWindowListener(*this);
88 if (!windowListener_) {
89 HILOG_ERROR("Create window listener fail!");
90 return;
91 }
92 OHOS::Rosen::WindowManager::GetInstance().RegisterWindowUpdateListener(windowListener_);
93 }
94
DeregisterWindowListener()95 void AccessibilityWindowManager::DeregisterWindowListener()
96 {
97 if (windowListener_) {
98 OHOS::Rosen::WindowManager::GetInstance().UnregisterWindowUpdateListener(windowListener_);
99 windowListener_ = nullptr;
100 eventHandler_ = nullptr;
101 }
102 }
103
OnWindowUpdate(const std::vector<sptr<Rosen::AccessibilityWindowInfo>> & infos,Rosen::WindowUpdateType type)104 void AccessibilityWindowManager::OnWindowUpdate(const std::vector<sptr<Rosen::AccessibilityWindowInfo>>& infos,
105 Rosen::WindowUpdateType type)
106 {
107 HILOG_DEBUG("start");
108 if (!eventHandler_) {
109 HILOG_ERROR("eventHandler_ is nullptr.");
110 return;
111 }
112 if (infos.size() == 0) {
113 HILOG_ERROR("window info is err");
114 return;
115 }
116 eventHandler_->PostTask(std::bind([=]() -> void {
117 switch (type) {
118 case Rosen::WindowUpdateType::WINDOW_UPDATE_ADDED:
119 WindowUpdateAdded(infos);
120 break;
121 case Rosen::WindowUpdateType::WINDOW_UPDATE_REMOVED:
122 WindowUpdateRemoved(infos);
123 break;
124 case Rosen::WindowUpdateType::WINDOW_UPDATE_BOUNDS:
125 WindowUpdateBounds(infos);
126 break;
127 case Rosen::WindowUpdateType::WINDOW_UPDATE_ACTIVE:
128 WindowUpdateActive(infos);
129 break;
130 case Rosen::WindowUpdateType::WINDOW_UPDATE_FOCUSED:
131 WindowUpdateFocused(infos);
132 break;
133 case Rosen::WindowUpdateType::WINDOW_UPDATE_PROPERTY:
134 WindowUpdateProperty(infos);
135 break;
136 default:
137 break;
138 }
139 HILOG_DEBUG("a11yWindows[%{public}zu]", a11yWindows_.size());
140 }), "TASK_ON_WINDOW_UPDATE");
141 }
142
ConvertToRealWindowId(int32_t windowId,int32_t focusType)143 int32_t AccessibilityWindowManager::ConvertToRealWindowId(int32_t windowId, int32_t focusType)
144 {
145 int32_t winId = windowId;
146 HILOG_DEBUG("ConvertToRealWindowId called, windowId[%{public}d], focusType[%{public}d]", windowId, focusType);
147 if (windowId == ACTIVE_WINDOW_ID) {
148 HILOG_DEBUG("After convert active windowId[%{public}d]", activeWindowId_);
149 winId = activeWindowId_;
150 }
151
152 if (windowId == ANY_WINDOW_ID) {
153 if (focusType == FOCUS_TYPE_ACCESSIBILITY) {
154 HILOG_DEBUG("After convert a11yFocused windowId[%{public}d] by accessibility type", a11yFocusedWindowId_);
155 winId = a11yFocusedWindowId_;
156 } else if (focusType == FOCUS_TYPE_INPUT) {
157 HILOG_DEBUG("After convert active windowId[%{public}d] by input type", activeWindowId_);
158 winId = activeWindowId_;
159 }
160 }
161
162 if (subWindows_.count(winId)) {
163 HILOG_DEBUG("After convert normal windowId[%{public}d]", SCENE_BOARD_WINDOW_ID);
164 return SCENE_BOARD_WINDOW_ID;
165 }
166 HILOG_DEBUG("After convert windowId[%{public}d] and activeId[%{public}d]", winId, activeWindowId_);
167 return winId;
168 }
169
ConvertWindowType(Rosen::WindowType type)170 AccessibilityWindowType ConvertWindowType(Rosen::WindowType type)
171 {
172 AccessibilityWindowType winType = TYPE_WINDOW_INVALID;
173
174 if (type < Rosen::WindowType::SYSTEM_WINDOW_BASE) {
175 winType = TYPE_APPLICATION;
176 } else if ((type >= Rosen::WindowType::SYSTEM_WINDOW_BASE) && (type <= Rosen::WindowType::SYSTEM_WINDOW_END)) {
177 winType = TYPE_SYSTEM;
178 } else {
179 HILOG_ERROR("Unknown windowType[%{public}d]", type);
180 }
181 return winType;
182 }
183
UpdateAccessibilityWindowInfo(AccessibilityWindowInfo & accWindowInfo,const sptr<Rosen::AccessibilityWindowInfo> windowInfo)184 void AccessibilityWindowManager::UpdateAccessibilityWindowInfo(AccessibilityWindowInfo &accWindowInfo,
185 const sptr<Rosen::AccessibilityWindowInfo> windowInfo)
186 {
187 accWindowInfo.SetWindowId(windowInfo->wid_);
188 accWindowInfo.SetWindowType(static_cast<uint32_t>(windowInfo->type_));
189 accWindowInfo.SetWindowMode(static_cast<uint32_t>(windowInfo->mode_));
190 accWindowInfo.SetAccessibilityWindowType(ConvertWindowType(windowInfo->type_));
191 accWindowInfo.SetFocused(windowInfo->focused_);
192 accWindowInfo.SetWindowLayer(windowInfo->layer_);
193 Rect bound;
194 bound.SetLeftTopScreenPostion(windowInfo->windowRect_.posX_, windowInfo->windowRect_.posY_);
195 bound.SetRightBottomScreenPostion(
196 windowInfo->windowRect_.posX_ + static_cast<int32_t>(windowInfo->windowRect_.width_),
197 windowInfo->windowRect_.posY_ + static_cast<int32_t>(windowInfo->windowRect_.height_));
198 accWindowInfo.SetRectInScreen(bound);
199 accWindowInfo.SetDisplayId(windowInfo->displayId_);
200 accWindowInfo.SetDecorEnable(windowInfo->isDecorEnable_);
201 accWindowInfo.SetUiNodeId(windowInfo->uiNodeId_);
202 accWindowInfo.SetInnerWid(windowInfo->innerWid_);
203 if (accWindowInfo.GetWindowId() == SCENE_BOARD_WINDOW_ID) {
204 accWindowInfo.SetWindowId(windowInfo->innerWid_);
205 HILOG_INFO("scene board window id 1 convert inner window id[%{public}d]", windowInfo->innerWid_);
206 }
207 }
208
GetRealWindowId(const sptr<Rosen::AccessibilityWindowInfo> windowInfo)209 int32_t AccessibilityWindowManager::GetRealWindowId(const sptr<Rosen::AccessibilityWindowInfo> windowInfo)
210 {
211 if (windowInfo->wid_ == SCENE_BOARD_WINDOW_ID) {
212 return windowInfo->innerWid_;
213 }
214 return windowInfo->wid_;
215 }
216
IsSceneBoard(const sptr<Rosen::AccessibilityWindowInfo> windowInfo)217 bool AccessibilityWindowManager::IsSceneBoard(const sptr<Rosen::AccessibilityWindowInfo> windowInfo)
218 {
219 if (windowInfo->wid_ == SCENE_BOARD_WINDOW_ID) {
220 return true;
221 }
222 return false;
223 }
224
CreateAccessibilityWindowInfo(const sptr<Rosen::AccessibilityWindowInfo> windowInfo)225 AccessibilityWindowInfo AccessibilityWindowManager::CreateAccessibilityWindowInfo(
226 const sptr<Rosen::AccessibilityWindowInfo> windowInfo)
227 {
228 AccessibilityWindowInfo info;
229 UpdateAccessibilityWindowInfo(info, windowInfo);
230 HILOG_DEBUG("Create WindowInfo Id(%{public}d) type(%{public}d) posX(%{public}d) posY(%{public}d)"
231 "witdth(%{public}d) height(%{public}d) display id(%{public}" PRIu64 ") isDecorEnable(%{public}d)"
232 "innerWid(%{public}d), uiNodeId(%{public}d)",
233 windowInfo->wid_, windowInfo->type_, windowInfo->windowRect_.posX_, windowInfo->windowRect_.posY_,
234 windowInfo->windowRect_.width_, windowInfo->windowRect_.height_, windowInfo->displayId_,
235 windowInfo->isDecorEnable_, windowInfo->innerWid_, windowInfo->uiNodeId_);
236 return info;
237 }
238
SetActiveWindow(int32_t windowId)239 void AccessibilityWindowManager::SetActiveWindow(int32_t windowId)
240 {
241 HILOG_DEBUG("windowId(%{public}d)", windowId);
242 if (windowId == INVALID_WINDOW_ID) {
243 ClearOldActiveWindow();
244 activeWindowId_ = INVALID_WINDOW_ID;
245 return;
246 }
247
248 if (!a11yWindows_.count(windowId)) {
249 HILOG_WARN("Window id is not found");
250 return;
251 }
252
253 if (activeWindowId_ != windowId) {
254 ClearOldActiveWindow();
255 activeWindowId_ = windowId;
256 a11yWindows_[activeWindowId_].SetActive(true);
257 auto &aams = Singleton<AccessibleAbilityManagerService>::GetInstance();
258 AccessibilityEventInfo evtInf(activeWindowId_, WINDOW_UPDATE_ACTIVE);
259 aams.SendEvent(evtInf);
260 }
261 HILOG_DEBUG("activeWindowId is %{public}d", activeWindowId_);
262 }
263
SetAccessibilityFocusedWindow(int32_t windowId)264 void AccessibilityWindowManager::SetAccessibilityFocusedWindow(int32_t windowId)
265 {
266 HILOG_DEBUG("start");
267 if (windowId == INVALID_WINDOW_ID) {
268 ClearAccessibilityFocused();
269 a11yFocusedWindowId_ = INVALID_WINDOW_ID;
270 return;
271 }
272
273 if (!a11yWindows_.count(windowId)) {
274 HILOG_ERROR("Window id[%{public}d] is not found", windowId);
275 return;
276 }
277
278 if (a11yFocusedWindowId_ != windowId) {
279 ClearAccessibilityFocused();
280 a11yFocusedWindowId_ = windowId;
281 a11yWindows_[a11yFocusedWindowId_].SetAccessibilityFocused(true);
282 }
283 HILOG_DEBUG("a11yFocusedWindowId_ is %{public}d", a11yFocusedWindowId_);
284 }
285
GetAccessibilityWindows()286 std::vector<AccessibilityWindowInfo> AccessibilityWindowManager::GetAccessibilityWindows()
287 {
288 HILOG_DEBUG("a11yWindows_ size[%{public}zu]", a11yWindows_.size());
289 std::vector<sptr<Rosen::AccessibilityWindowInfo>> windowInfos;
290 std::vector<AccessibilityWindowInfo> windows;
291 Rosen::WMError err = OHOS::Rosen::WindowManager::GetInstance().GetAccessibilityWindowInfo(windowInfos);
292 if (err != Rosen::WMError::WM_OK) {
293 HILOG_ERROR("get window info from wms failed. err[%{public}d]", err);
294 return windows;
295 }
296 for (auto &info : windowInfos) {
297 if (info == nullptr) {
298 continue;
299 }
300
301 int32_t realWidId = GetRealWindowId(info);
302 if (a11yWindows_.count(realWidId)) {
303 UpdateAccessibilityWindowInfo(a11yWindows_[realWidId], info);
304 }
305 }
306 std::transform(a11yWindows_.begin(), a11yWindows_.end(), std::back_inserter(windows),
307 [](const std::map<int32_t, AccessibilityWindowInfo>::value_type &window) { return window.second; });
308
309 HILOG_DEBUG("window size[%{public}zu]", windows.size());
310 for (auto &logWindow : windows) {
311 HILOG_DEBUG("logWindow id[%{public}d]", logWindow.GetWindowId());
312 }
313 return windows;
314 }
315
GetAccessibilityWindow(int32_t windowId,AccessibilityWindowInfo & window)316 bool AccessibilityWindowManager::GetAccessibilityWindow(int32_t windowId, AccessibilityWindowInfo &window)
317 {
318 HILOG_DEBUG("start windowId(%{public}d)", windowId);
319 std::vector<sptr<Rosen::AccessibilityWindowInfo>> windowInfos;
320 Rosen::WMError err = OHOS::Rosen::WindowManager::GetInstance().GetAccessibilityWindowInfo(windowInfos);
321 if (err != Rosen::WMError::WM_OK) {
322 HILOG_ERROR("get window info from wms failed. err[%{public}d]", err);
323 return false;
324 }
325 for (auto &info : windowInfos) {
326 if (info == nullptr) {
327 continue;
328 }
329
330 int32_t realWidId = GetRealWindowId(info);
331 if (info != nullptr && a11yWindows_.count(realWidId)) {
332 UpdateAccessibilityWindowInfo(a11yWindows_[realWidId], info);
333 }
334 }
335 if (a11yWindows_.count(windowId)) {
336 window = a11yWindows_[windowId];
337 return true;
338 }
339 return false;
340 }
341
IsValidWindow(int32_t windowId)342 bool AccessibilityWindowManager::IsValidWindow(int32_t windowId)
343 {
344 HILOG_DEBUG("start windowId(%{public}d)", windowId);
345
346 auto it = std::find_if(a11yWindows_.begin(), a11yWindows_.end(),
347 [windowId](const std::map<int32_t, AccessibilityWindowInfo>::value_type &window) {
348 return window.first == windowId;
349 });
350 if (it == a11yWindows_.end()) {
351 return false;
352 }
353 return true;
354 }
355
SetWindowSize(int32_t windowId,Rect rect)356 void AccessibilityWindowManager::SetWindowSize(int32_t windowId, Rect rect)
357 {
358 HILOG_DEBUG("start windowId(%{public}d)", windowId);
359 auto it = std::find_if(a11yWindows_.begin(), a11yWindows_.end(),
360 [windowId](const std::map<int32_t, AccessibilityWindowInfo>::value_type &window) {
361 return window.first == windowId;
362 });
363 if (it != a11yWindows_.end()) {
364 it->second.SetRectInScreen(rect);
365 }
366 }
367
WindowUpdateAdded(const std::vector<sptr<Rosen::AccessibilityWindowInfo>> & infos)368 void AccessibilityWindowManager::WindowUpdateAdded(const std::vector<sptr<Rosen::AccessibilityWindowInfo>>& infos)
369 {
370 HILOG_DEBUG("start");
371 for (auto &windowInfo : infos) {
372 if (!windowInfo) {
373 HILOG_ERROR("invalid windowInfo");
374 return;
375 }
376
377 int32_t realWidId = GetRealWindowId(windowInfo);
378 if (!a11yWindows_.count(realWidId)) {
379 auto a11yWindowInfoAdded = CreateAccessibilityWindowInfo(windowInfo);
380 a11yWindows_.emplace(realWidId, a11yWindowInfoAdded);
381 } else {
382 UpdateAccessibilityWindowInfo(a11yWindows_[realWidId], windowInfo);
383 }
384
385 if (IsSceneBoard(windowInfo)) {
386 subWindows_.insert(realWidId);
387 }
388 AccessibilityEventInfo evtInfAdded(realWidId, WINDOW_UPDATE_ADDED);
389 Singleton<AccessibleAbilityManagerService>::GetInstance().SendEvent(evtInfAdded);
390 if (a11yWindows_[realWidId].IsFocused()) {
391 SetActiveWindow(realWidId);
392 }
393 }
394 }
395
WindowUpdateRemoved(const std::vector<sptr<Rosen::AccessibilityWindowInfo>> & infos)396 void AccessibilityWindowManager::WindowUpdateRemoved(const std::vector<sptr<Rosen::AccessibilityWindowInfo>>& infos)
397 {
398 HILOG_DEBUG("start");
399 auto &aams = Singleton<AccessibleAbilityManagerService>::GetInstance();
400 for (auto &windowInfo : infos) {
401 if (!windowInfo) {
402 HILOG_ERROR("invalid windowInfo");
403 return;
404 }
405
406 int32_t realWidId = GetRealWindowId(windowInfo);
407 if (!a11yWindows_.count(realWidId)) {
408 return;
409 }
410 if (realWidId == activeWindowId_) {
411 SetActiveWindow(INVALID_WINDOW_ID);
412 }
413 if (realWidId == a11yFocusedWindowId_) {
414 SetAccessibilityFocusedWindow(INVALID_WINDOW_ID);
415 }
416 a11yWindows_.erase(realWidId);
417 subWindows_.erase(realWidId);
418 AccessibilityEventInfo evtInfRemoved(realWidId, WINDOW_UPDATE_REMOVED);
419 aams.SendEvent(evtInfRemoved);
420 }
421 }
422
WindowUpdateFocused(const std::vector<sptr<Rosen::AccessibilityWindowInfo>> & infos)423 void AccessibilityWindowManager::WindowUpdateFocused(const std::vector<sptr<Rosen::AccessibilityWindowInfo>>& infos)
424 {
425 HILOG_DEBUG("start");
426 auto &aams = Singleton<AccessibleAbilityManagerService>::GetInstance();
427 for (auto &windowInfo : infos) {
428 if (!windowInfo) {
429 HILOG_ERROR("invalid windowInfo");
430 return;
431 }
432
433 int32_t realWidId = GetRealWindowId(windowInfo);
434 if (!a11yWindows_.count(realWidId)) {
435 HILOG_WARN("window not created");
436 auto a11yWindowInfoFocused = CreateAccessibilityWindowInfo(windowInfo);
437 a11yWindows_.emplace(realWidId, a11yWindowInfoFocused);
438 }
439
440 if (IsSceneBoard(windowInfo)) {
441 subWindows_.insert(realWidId);
442 }
443 SetActiveWindow(realWidId);
444 AccessibilityEventInfo evtInfFocused(realWidId, WINDOW_UPDATE_FOCUSED);
445 aams.SendEvent(evtInfFocused);
446 }
447 }
448
WindowUpdateBounds(const std::vector<sptr<Rosen::AccessibilityWindowInfo>> & infos)449 void AccessibilityWindowManager::WindowUpdateBounds(const std::vector<sptr<Rosen::AccessibilityWindowInfo>>& infos)
450 {
451 HILOG_DEBUG("start");
452 auto &aams = Singleton<AccessibleAbilityManagerService>::GetInstance();
453 for (auto &windowInfo : infos) {
454 if (!windowInfo) {
455 HILOG_ERROR("invalid windowInfo");
456 return;
457 }
458
459 int32_t realWidId = GetRealWindowId(windowInfo);
460 if (a11yWindows_.count(realWidId)) {
461 UpdateAccessibilityWindowInfo(a11yWindows_[realWidId], windowInfo);
462 }
463
464 AccessibilityEventInfo evtInfBounds(realWidId, WINDOW_UPDATE_BOUNDS);
465 aams.SendEvent(evtInfBounds);
466 }
467 }
468
WindowUpdateActive(const std::vector<sptr<Rosen::AccessibilityWindowInfo>> & infos)469 void AccessibilityWindowManager::WindowUpdateActive(const std::vector<sptr<Rosen::AccessibilityWindowInfo>>& infos)
470 {
471 HILOG_DEBUG("start");
472 for (auto &windowInfo : infos) {
473 if (!windowInfo) {
474 HILOG_ERROR("invalid windowInfo");
475 return;
476 }
477
478 int32_t realWidId = GetRealWindowId(windowInfo);
479 if (!a11yWindows_.count(realWidId)) {
480 auto a11yWindowInfoActive = CreateAccessibilityWindowInfo(windowInfo);
481 a11yWindows_.emplace(realWidId, a11yWindowInfoActive);
482 }
483
484 if (IsSceneBoard(windowInfo)) {
485 subWindows_.insert(realWidId);
486 }
487 SetActiveWindow(realWidId);
488 }
489 }
490
WindowUpdateProperty(const std::vector<sptr<Rosen::AccessibilityWindowInfo>> & infos)491 void AccessibilityWindowManager::WindowUpdateProperty(const std::vector<sptr<Rosen::AccessibilityWindowInfo>>& infos)
492 {
493 HILOG_DEBUG("start");
494 auto &aams = Singleton<AccessibleAbilityManagerService>::GetInstance();
495 for (auto &windowInfo : infos) {
496 if (!windowInfo) {
497 HILOG_ERROR("invalid windowInfo");
498 return;
499 }
500
501 int32_t realWidId = GetRealWindowId(windowInfo);
502 if (a11yWindows_.count(realWidId)) {
503 UpdateAccessibilityWindowInfo(a11yWindows_[realWidId], windowInfo);
504 }
505 AccessibilityEventInfo evtInfProperty(realWidId, WINDOW_UPDATE_PROPERTY);
506 aams.SendEvent(evtInfProperty);
507 }
508 }
509
ClearOldActiveWindow()510 void AccessibilityWindowManager::ClearOldActiveWindow()
511 {
512 HILOG_DEBUG("active window id is %{public}d", activeWindowId_);
513 if (activeWindowId_ == INVALID_WINDOW_ID) {
514 HILOG_DEBUG("active window id is invalid");
515 return;
516 }
517
518 if (a11yWindows_.count(activeWindowId_)) {
519 a11yWindows_[activeWindowId_].SetActive(false);
520 }
521 if (activeWindowId_ == a11yFocusedWindowId_) {
522 HILOG_DEBUG("Old active window is a11yFocused window.");
523 SetAccessibilityFocusedWindow(INVALID_WINDOW_ID);
524 }
525 }
526
ClearAccessibilityFocused()527 void AccessibilityWindowManager::ClearAccessibilityFocused()
528 {
529 HILOG_DEBUG("a11yFocused window id is %{public}d", a11yFocusedWindowId_);
530 if (a11yFocusedWindowId_ == INVALID_WINDOW_ID) {
531 HILOG_DEBUG("a11yFocused window id is invalid");
532 return;
533 }
534
535 if (a11yWindows_.count(a11yFocusedWindowId_)) {
536 a11yWindows_[a11yFocusedWindowId_].SetAccessibilityFocused(false);
537 }
538
539 int32_t windowId = a11yFocusedWindowId_;
540 if (subWindows_.count(a11yFocusedWindowId_)) {
541 windowId = SCENE_BOARD_WINDOW_ID;
542 }
543 sptr<AccessibilityAccountData> accountData =
544 Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
545 if (!accountData) {
546 HILOG_ERROR("accountData is nullptr");
547 return;
548 }
549 sptr<AccessibilityWindowConnection> connection =
550 accountData->GetAccessibilityWindowConnection(windowId);
551 if (!connection) {
552 HILOG_ERROR("windowId[%{public}d] has no connection", windowId);
553 return;
554 }
555 if (!connection->GetProxy()) {
556 HILOG_ERROR("windowId[%{public}d] has no proxy", windowId);
557 return;
558 }
559 connection->GetProxy()->ClearFocus();
560
561 // Send event
562 AccessibilityEventInfo eventInfo(TYPE_VIEW_ACCESSIBILITY_FOCUS_CLEARED_EVENT);
563 eventInfo.SetWindowId(a11yFocusedWindowId_);
564 Singleton<AccessibleAbilityManagerService>::GetInstance().SendEvent(eventInfo);
565 }
566
GetSceneBoardElementId(const int32_t windowId,const int32_t elementId)567 int32_t AccessibilityWindowManager::GetSceneBoardElementId(const int32_t windowId, const int32_t elementId)
568 {
569 if (elementId != INVALID_SCENE_BOARD_ELEMENT_ID) {
570 return elementId;
571 }
572 if (subWindows_.count(windowId)) {
573 auto iter = a11yWindows_.find(windowId);
574 if (iter != a11yWindows_.end()) {
575 HILOG_DEBUG("GetSceneBoardElementId [%{public}d]", iter->second.GetUiNodeId());
576 return iter->second.GetUiNodeId();
577 }
578 }
579 return elementId;
580 }
581
582 } // namespace Accessibility
583 } // namespace OHOS