1 /*
2 * Copyright (C) 2022-2023 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 <cinttypes>
17 #include "accessibility_system_ability_client_impl.h"
18 #include "hilog_wrapper.h"
19 #include "if_system_ability_manager.h"
20 #include "iservice_registry.h"
21 #include "parameter.h"
22 #include "system_ability_definition.h"
23
24 namespace OHOS {
25 namespace Accessibility {
26 namespace {
27 constexpr int32_t REQUEST_WINDOW_ID_MASK_BIT = 16;
28 constexpr int32_t CONFIG_PARAMETER_VALUE_SIZE = 10;
29 const std::string SYSTEM_PARAMETER_AAMS_NAME = "accessibility.config.ready";
30 } // namespaces
31
32 static std::mutex g_Mutex;
33 static std::shared_ptr<AccessibilitySystemAbilityClientImpl> g_Instance = nullptr;
GetInstance()34 std::shared_ptr<AccessibilitySystemAbilityClient> AccessibilitySystemAbilityClient::GetInstance()
35 {
36 HILOG_DEBUG();
37 std::lock_guard<std::mutex> lock(g_Mutex);
38 if (!g_Instance) {
39 g_Instance = std::make_shared<AccessibilitySystemAbilityClientImpl>();
40 } else {
41 HILOG_DEBUG("AccessibilitySystemAbilityClient had construct instance");
42 }
43
44 return g_Instance;
45 }
46
AccessibilitySystemAbilityClientImpl()47 AccessibilitySystemAbilityClientImpl::AccessibilitySystemAbilityClientImpl()
48 {
49 HILOG_DEBUG();
50
51 stateArray_.fill(false);
52 char value[CONFIG_PARAMETER_VALUE_SIZE] = "default";
53 int retSysParam = GetParameter(SYSTEM_PARAMETER_AAMS_NAME.c_str(), "false", value, CONFIG_PARAMETER_VALUE_SIZE);
54 if (retSysParam >= 0 && !std::strcmp(value, "true")) {
55 HILOG_ERROR("accessibility service is ready.");
56 if (!ConnectToService()) {
57 HILOG_ERROR("Failed to connect to aams service");
58 return;
59 }
60 Init();
61 }
62
63 retSysParam = WatchParameter(SYSTEM_PARAMETER_AAMS_NAME.c_str(), &OnParameterChanged, this);
64 if (retSysParam) {
65 HILOG_ERROR("Watch parameter failed, error = %{public}d", retSysParam);
66 }
67 }
68
~AccessibilitySystemAbilityClientImpl()69 AccessibilitySystemAbilityClientImpl::~AccessibilitySystemAbilityClientImpl()
70 {
71 HILOG_DEBUG();
72 }
73
ConnectToService()74 bool AccessibilitySystemAbilityClientImpl::ConnectToService()
75 {
76 HILOG_DEBUG();
77
78 if (serviceProxy_) {
79 HILOG_DEBUG("AAMS Service is connected");
80 return true;
81 }
82
83 sptr<ISystemAbilityManager> samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
84 if (!samgr) {
85 HILOG_ERROR("Failed to get ISystemAbilityManager");
86 return false;
87 }
88
89 sptr<IRemoteObject> object = samgr->GetSystemAbility(ACCESSIBILITY_MANAGER_SERVICE_ID);
90 if (!object) {
91 HILOG_ERROR("Get IAccessibleAbilityManagerService object from samgr failed");
92 return false;
93 }
94
95 if (!deathRecipient_) {
96 deathRecipient_ = new(std::nothrow) DeathRecipient(*this);
97 if (!deathRecipient_) {
98 HILOG_ERROR("Failed to create deathRecipient.");
99 return false;
100 }
101 }
102
103 if ((object->IsProxyObject()) && (!object->AddDeathRecipient(deathRecipient_))) {
104 HILOG_ERROR("Failed to add death recipient");
105 }
106
107 HILOG_DEBUG("Get remote object ok");
108 serviceProxy_ = iface_cast<IAccessibleAbilityManagerService>(object);
109 if (!serviceProxy_) {
110 HILOG_ERROR("IAccessibleAbilityManagerService iface_cast failed");
111 return false;
112 }
113 return true;
114 }
115
OnParameterChanged(const char * key,const char * value,void * context)116 void AccessibilitySystemAbilityClientImpl::OnParameterChanged(const char *key, const char *value, void *context)
117 {
118 HILOG_DEBUG("Parameter key = [%{public}s] value = [%{public}s]", key, value);
119
120 if (!key || std::strcmp(key, SYSTEM_PARAMETER_AAMS_NAME.c_str())) {
121 HILOG_WARN("not accessibility.config.ready callback");
122 return;
123 }
124
125 if (!value || std::strcmp(value, "true")) {
126 HILOG_WARN("accessibility.config.ready value not true");
127 return;
128 }
129
130 if (!context) {
131 HILOG_ERROR("accessibility.config.ready context NULL");
132 return;
133 }
134
135 AccessibilitySystemAbilityClientImpl* implPtr = static_cast<AccessibilitySystemAbilityClientImpl*>(context);
136 {
137 HILOG_DEBUG("ConnectToService start.");
138 std::lock_guard<std::mutex> lock(implPtr->mutex_);
139 if (implPtr->serviceProxy_) {
140 HILOG_DEBUG("service is already started.");
141 return;
142 }
143 if (!implPtr->ConnectToService()) {
144 HILOG_ERROR("Failed to connect to aams service");
145 return;
146 }
147 implPtr->Init();
148 implPtr->ReregisterElementOperator();
149 }
150 }
151
Init()152 void AccessibilitySystemAbilityClientImpl::Init()
153 {
154 HILOG_DEBUG();
155 stateArray_.fill(false);
156 if (!stateObserver_) {
157 stateObserver_ = new(std::nothrow) AccessibleAbilityManagerStateObserverImpl(*this);
158 if (!stateObserver_) {
159 HILOG_ERROR("Failed to create stateObserver.");
160 return;
161 }
162 }
163 uint32_t stateType = serviceProxy_->RegisterStateObserver(stateObserver_);
164 if (stateType & STATE_ACCESSIBILITY_ENABLED) {
165 stateArray_[AccessibilityStateEventType::EVENT_ACCESSIBILITY_STATE_CHANGED] = true;
166 }
167 if (stateType & STATE_EXPLORATION_ENABLED) {
168 stateArray_[AccessibilityStateEventType::EVENT_TOUCH_GUIDE_STATE_CHANGED] = true;
169 }
170 if (stateType & STATE_KEYEVENT_ENABLED) {
171 stateArray_[AccessibilityStateEventType::EVENT_KEVEVENT_STATE_CHANGED] = true;
172 }
173 if (stateType & STATE_GESTURE_ENABLED) {
174 stateArray_[AccessibilityStateEventType::EVENT_GESTURE_STATE_CHANGED] = true;
175 }
176 }
177
ResetService(const wptr<IRemoteObject> & remote)178 void AccessibilitySystemAbilityClientImpl::ResetService(const wptr<IRemoteObject> &remote)
179 {
180 HILOG_DEBUG();
181 std::lock_guard<std::mutex> lock(mutex_);
182 if (serviceProxy_) {
183 sptr<IRemoteObject> object = serviceProxy_->AsObject();
184 if (object && (remote == object)) {
185 object->RemoveDeathRecipient(deathRecipient_);
186 serviceProxy_ = nullptr;
187 HILOG_DEBUG("Reset OK");
188 }
189 }
190 }
191
RegisterElementOperator(const int32_t windowId,const std::shared_ptr<AccessibilityElementOperator> & operation)192 RetError AccessibilitySystemAbilityClientImpl::RegisterElementOperator(
193 const int32_t windowId, const std::shared_ptr<AccessibilityElementOperator> &operation)
194 {
195 HILOG_INFO("Register windowId[%{public}d] start", windowId);
196 std::lock_guard<std::mutex> lock(mutex_);
197 if (!operation) {
198 HILOG_ERROR("Input operation is null");
199 return RET_ERR_INVALID_PARAM;
200 }
201 if (!serviceProxy_) {
202 HILOG_ERROR("Failed to get aams service");
203 return RET_ERR_SAMGR;
204 }
205
206 auto iter = elementOperators_.find(windowId);
207 if (iter != elementOperators_.end()) {
208 HILOG_ERROR("windowID[%{public}d] is exited", windowId);
209 return RET_ERR_CONNECTION_EXIST;
210 }
211
212 sptr<AccessibilityElementOperatorImpl> aamsInteractionOperator =
213 new(std::nothrow) AccessibilityElementOperatorImpl(windowId, operation, *this);
214 if (!aamsInteractionOperator) {
215 HILOG_ERROR("Failed to create aamsInteractionOperator.");
216 return RET_ERR_NULLPTR;
217 }
218 elementOperators_[windowId] = aamsInteractionOperator;
219 return serviceProxy_->RegisterElementOperator(windowId, aamsInteractionOperator);
220 }
221
ReregisterElementOperator()222 void AccessibilitySystemAbilityClientImpl::ReregisterElementOperator()
223 {
224 HILOG_DEBUG();
225
226 if (!serviceProxy_) {
227 HILOG_ERROR("serviceProxy_ is null.");
228 return;
229 }
230 for (auto iter = elementOperators_.begin(); iter != elementOperators_.end(); iter++) {
231 serviceProxy_->RegisterElementOperator(iter->first, iter->second);
232 }
233 }
234
DeregisterElementOperator(const int32_t windowId)235 RetError AccessibilitySystemAbilityClientImpl::DeregisterElementOperator(const int32_t windowId)
236 {
237 HILOG_INFO("Deregister windowId[%{public}d] start", windowId);
238 std::lock_guard<std::mutex> lock(mutex_);
239
240 if (!serviceProxy_) {
241 HILOG_ERROR("Failed to get aams service");
242 return RET_ERR_SAMGR;
243 }
244 auto iter = elementOperators_.find(windowId);
245 if (iter != elementOperators_.end()) {
246 HILOG_DEBUG("windowID[%{public}d] is erase", windowId);
247 elementOperators_.erase(iter);
248 } else {
249 HILOG_WARN("Not find windowID[%{public}d]", windowId);
250 return RET_ERR_NO_REGISTER;
251 }
252 return serviceProxy_->DeregisterElementOperator(windowId);
253 }
254
IsEnabled(bool & isEnabled)255 RetError AccessibilitySystemAbilityClientImpl::IsEnabled(bool &isEnabled)
256 {
257 HILOG_DEBUG();
258 std::lock_guard<std::mutex> lock(mutex_);
259 isEnabled = stateArray_[AccessibilityStateEventType::EVENT_ACCESSIBILITY_STATE_CHANGED];
260 return RET_OK;
261 }
262
IsTouchExplorationEnabled(bool & isEnabled)263 RetError AccessibilitySystemAbilityClientImpl::IsTouchExplorationEnabled(bool &isEnabled)
264 {
265 HILOG_DEBUG();
266 std::lock_guard<std::mutex> lock(mutex_);
267 isEnabled = stateArray_[AccessibilityStateEventType::EVENT_TOUCH_GUIDE_STATE_CHANGED];
268 return RET_OK;
269 }
270
GetAbilityList(const uint32_t accessibilityAbilityTypes,const AbilityStateType stateType,std::vector<AccessibilityAbilityInfo> & infos)271 RetError AccessibilitySystemAbilityClientImpl::GetAbilityList(const uint32_t accessibilityAbilityTypes,
272 const AbilityStateType stateType, std::vector<AccessibilityAbilityInfo> &infos)
273 {
274 HILOG_DEBUG();
275 std::lock_guard<std::mutex> lock(mutex_);
276 bool check = false;
277 if ((accessibilityAbilityTypes & AccessibilityAbilityTypes::ACCESSIBILITY_ABILITY_TYPE_SPOKEN) ||
278 (accessibilityAbilityTypes & AccessibilityAbilityTypes::ACCESSIBILITY_ABILITY_TYPE_HAPTIC) ||
279 (accessibilityAbilityTypes & AccessibilityAbilityTypes::ACCESSIBILITY_ABILITY_TYPE_AUDIBLE) ||
280 (accessibilityAbilityTypes & AccessibilityAbilityTypes::ACCESSIBILITY_ABILITY_TYPE_VISUAL) ||
281 (accessibilityAbilityTypes & AccessibilityAbilityTypes::ACCESSIBILITY_ABILITY_TYPE_GENERIC)) {
282 check = true;
283 }
284 if (stateType == ABILITY_STATE_INVALID) {
285 check = false;
286 }
287 if (!check) {
288 HILOG_ERROR("Invalid params: accessibilityAbilityTypes[%{public}d] stateType[%{public}d]",
289 accessibilityAbilityTypes, stateType);
290 return RET_ERR_INVALID_PARAM;
291 }
292 if (!serviceProxy_) {
293 HILOG_ERROR("Failed to get aams service");
294 return RET_ERR_SAMGR;
295 }
296 return serviceProxy_->GetAbilityList(accessibilityAbilityTypes, stateType, infos);
297 }
298
CheckEventType(EventType eventType)299 bool AccessibilitySystemAbilityClientImpl::CheckEventType(EventType eventType)
300 {
301 if ((eventType < EventType::TYPE_VIEW_CLICKED_EVENT) ||
302 ((eventType >= EventType::TYPE_MAX_NUM) && (eventType != EventType::TYPES_ALL_MASK))) {
303 HILOG_ERROR("event type is invalid");
304 return false;
305 } else {
306 return true;
307 }
308 }
309
SendEvent(const EventType eventType,const int64_t componentId)310 RetError AccessibilitySystemAbilityClientImpl::SendEvent(const EventType eventType, const int64_t componentId)
311 {
312 HILOG_DEBUG("componentId[%{public}" PRId64 "], eventType[%{public}d]", componentId, eventType);
313 std::lock_guard<std::mutex> lock(mutex_);
314 if (!CheckEventType(eventType)) {
315 return RET_ERR_INVALID_PARAM;
316 }
317 AccessibilityEventInfo event;
318 event.SetEventType(eventType);
319 event.SetSource(componentId);
320 if (!serviceProxy_) {
321 HILOG_ERROR("Failed to get aams service");
322 return RET_ERR_SAMGR;
323 }
324 return serviceProxy_->SendEvent(event);
325 }
326
SendEvent(const AccessibilityEventInfo & event)327 RetError AccessibilitySystemAbilityClientImpl::SendEvent(const AccessibilityEventInfo &event)
328 {
329 HILOG_DEBUG("EventType[%{public}d]", event.GetEventType());
330 std::lock_guard<std::mutex> lock(mutex_);
331 if (!CheckEventType(event.GetEventType())) {
332 return RET_ERR_INVALID_PARAM;
333 }
334 if (!serviceProxy_) {
335 HILOG_ERROR("Failed to get aams service");
336 return RET_ERR_SAMGR;
337 }
338 return serviceProxy_->SendEvent(event);
339 }
340
SubscribeStateObserver(const std::shared_ptr<AccessibilityStateObserver> & observer,const uint32_t eventType)341 RetError AccessibilitySystemAbilityClientImpl::SubscribeStateObserver(
342 const std::shared_ptr<AccessibilityStateObserver> &observer, const uint32_t eventType)
343 {
344 HILOG_DEBUG();
345 std::lock_guard<std::mutex> lock(mutex_);
346 if (eventType >= AccessibilityStateEventType::EVENT_TYPE_MAX) {
347 HILOG_ERROR("Input eventType is out of scope");
348 return RET_ERR_INVALID_PARAM;
349 }
350 if (!observer) {
351 HILOG_ERROR("Input observer is null");
352 return RET_ERR_INVALID_PARAM;
353 }
354
355 StateObserverVector &observerVector = stateObserversArray_[eventType];
356 for (auto iter = observerVector.begin(); iter != observerVector.end(); ++iter) {
357 if (*iter == observer) {
358 HILOG_INFO("Observer has subscribed!");
359 return RET_ERR_REGISTER_EXIST;
360 }
361 }
362 observerVector.push_back(observer);
363 return RET_OK;
364 }
365
UnsubscribeStateObserver(const std::shared_ptr<AccessibilityStateObserver> & observer,const uint32_t eventType)366 RetError AccessibilitySystemAbilityClientImpl::UnsubscribeStateObserver(
367 const std::shared_ptr<AccessibilityStateObserver> &observer, const uint32_t eventType)
368 {
369 HILOG_DEBUG("eventType is [%{public}d]", eventType);
370 std::lock_guard<std::mutex> lock(mutex_);
371 if (eventType >= AccessibilityStateEventType::EVENT_TYPE_MAX) {
372 HILOG_ERROR("Input eventType is out of scope");
373 return RET_ERR_INVALID_PARAM;
374 }
375 if (!observer) {
376 HILOG_ERROR("Input observer is null");
377 return RET_ERR_INVALID_PARAM;
378 }
379
380 StateObserverVector &observerVector = stateObserversArray_[eventType];
381 for (auto iter = observerVector.begin(); iter != observerVector.end(); ++iter) {
382 if (*iter == observer) {
383 observerVector.erase(iter);
384 return RET_OK;
385 }
386 }
387 HILOG_ERROR("The observer has not subscribed.");
388 return RET_ERR_NO_REGISTER;
389 }
390
NotifyStateChanged(uint32_t eventType,bool value)391 void AccessibilitySystemAbilityClientImpl::NotifyStateChanged(uint32_t eventType, bool value)
392 {
393 HILOG_DEBUG("EventType is %{public}d, value is %{public}d", eventType, value);
394 if (eventType >= AccessibilityStateEventType::EVENT_TYPE_MAX) {
395 HILOG_ERROR("EventType is invalid");
396 return;
397 }
398
399 if (stateArray_[eventType] == value) {
400 HILOG_DEBUG("State value is not changed");
401 return;
402 }
403
404 stateArray_[eventType] = value;
405 StateObserverVector &observers = stateObserversArray_[eventType];
406 for (auto &observer : observers) {
407 if (observer) {
408 observer->OnStateChanged(value);
409 } else {
410 HILOG_ERROR("end stateObserversArray[%{public}d] is null", eventType);
411 }
412 }
413 HILOG_DEBUG("end");
414 }
415
GetEnabledAbilities(std::vector<std::string> & enabledAbilities)416 RetError AccessibilitySystemAbilityClientImpl::GetEnabledAbilities(std::vector<std::string> &enabledAbilities)
417 {
418 HILOG_DEBUG();
419 std::lock_guard<std::mutex> lock(mutex_);
420 if (!serviceProxy_) {
421 HILOG_ERROR("Failed to get aams service");
422 return RET_ERR_SAMGR;
423 }
424 return serviceProxy_->GetEnabledAbilities(enabledAbilities);
425 }
426
OnAccessibleAbilityManagerStateChanged(const uint32_t stateType)427 void AccessibilitySystemAbilityClientImpl::OnAccessibleAbilityManagerStateChanged(const uint32_t stateType)
428 {
429 HILOG_DEBUG("stateType[%{public}d}", stateType);
430 SetAccessibilityState(stateType);
431 std::lock_guard<std::mutex> lock(mutex_);
432 if (stateType & STATE_ACCESSIBILITY_ENABLED) {
433 NotifyStateChanged(AccessibilityStateEventType::EVENT_ACCESSIBILITY_STATE_CHANGED, true);
434 } else {
435 NotifyStateChanged(AccessibilityStateEventType::EVENT_ACCESSIBILITY_STATE_CHANGED, false);
436 }
437
438 if (stateType & STATE_EXPLORATION_ENABLED) {
439 NotifyStateChanged(AccessibilityStateEventType::EVENT_TOUCH_GUIDE_STATE_CHANGED, true);
440 } else {
441 NotifyStateChanged(AccessibilityStateEventType::EVENT_TOUCH_GUIDE_STATE_CHANGED, false);
442 }
443
444 if (stateType & STATE_KEYEVENT_ENABLED) {
445 NotifyStateChanged(AccessibilityStateEventType::EVENT_KEVEVENT_STATE_CHANGED, true);
446 } else {
447 NotifyStateChanged(AccessibilityStateEventType::EVENT_KEVEVENT_STATE_CHANGED, false);
448 }
449
450 if (stateType & STATE_GESTURE_ENABLED) {
451 NotifyStateChanged(AccessibilityStateEventType::EVENT_GESTURE_STATE_CHANGED, true);
452 } else {
453 NotifyStateChanged(AccessibilityStateEventType::EVENT_GESTURE_STATE_CHANGED, false);
454 }
455 }
456
SetSearchElementInfoByAccessibilityIdResult(const std::list<AccessibilityElementInfo> & infos,const int32_t requestId)457 void AccessibilitySystemAbilityClientImpl::SetSearchElementInfoByAccessibilityIdResult(
458 const std::list<AccessibilityElementInfo> &infos, const int32_t requestId)
459 {
460 std::lock_guard<std::mutex> lock(mutex_);
461 HILOG_DEBUG("search element requestId[%{public}d]", requestId);
462 if (requestId >= 0) {
463 auto iter = elementOperators_.find(static_cast<uint32_t>(requestId) >> REQUEST_WINDOW_ID_MASK_BIT);
464 if (iter != elementOperators_.end()) {
465 if (iter->second) {
466 iter->second->SetSearchElementInfoByAccessibilityIdResult(infos, requestId);
467 }
468 }
469 }
470 }
471
SetSearchElementInfoByTextResult(const std::list<AccessibilityElementInfo> & infos,const int32_t requestId)472 void AccessibilitySystemAbilityClientImpl::SetSearchElementInfoByTextResult(
473 const std::list<AccessibilityElementInfo> &infos, const int32_t requestId)
474 {
475 std::lock_guard<std::mutex> lock(mutex_);
476 HILOG_DEBUG("requestId[%{public}d]", requestId);
477 if (requestId >= 0) {
478 auto iter = elementOperators_.find(static_cast<uint32_t>(requestId) >> REQUEST_WINDOW_ID_MASK_BIT);
479 if (iter != elementOperators_.end()) {
480 if (iter->second) {
481 iter->second->SetSearchElementInfoByTextResult(infos, requestId);
482 }
483 }
484 }
485 }
486
SetFindFocusedElementInfoResult(const AccessibilityElementInfo & info,const int32_t requestId)487 void AccessibilitySystemAbilityClientImpl::SetFindFocusedElementInfoResult(
488 const AccessibilityElementInfo &info, const int32_t requestId)
489 {
490 std::lock_guard<std::mutex> lock(mutex_);
491 HILOG_DEBUG("requestId[%{public}d]", requestId);
492 if (requestId >= 0) {
493 auto iter = elementOperators_.find(static_cast<uint32_t>(requestId) >> REQUEST_WINDOW_ID_MASK_BIT);
494 if (iter != elementOperators_.end()) {
495 if (iter->second) {
496 iter->second->SetFindFocusedElementInfoResult(info, requestId);
497 }
498 }
499 }
500 }
501
SetFocusMoveSearchResult(const AccessibilityElementInfo & info,const int32_t requestId)502 void AccessibilitySystemAbilityClientImpl::SetFocusMoveSearchResult(
503 const AccessibilityElementInfo &info, const int32_t requestId)
504 {
505 std::lock_guard<std::mutex> lock(mutex_);
506 HILOG_DEBUG("requestId[%{public}d]", requestId);
507 if (requestId >= 0) {
508 auto iter = elementOperators_.find(static_cast<uint32_t>(requestId) >> REQUEST_WINDOW_ID_MASK_BIT);
509 if (iter != elementOperators_.end()) {
510 if (iter->second) {
511 iter->second->SetFocusMoveSearchResult(info, requestId);
512 }
513 }
514 }
515 }
516
SetExecuteActionResult(const bool succeeded,const int32_t requestId)517 void AccessibilitySystemAbilityClientImpl::SetExecuteActionResult(
518 const bool succeeded, const int32_t requestId)
519 {
520 std::lock_guard<std::mutex> lock(mutex_);
521 HILOG_DEBUG("requestId[%{public}d]", requestId);
522 if (requestId >= 0) {
523 auto iter = elementOperators_.find(static_cast<uint32_t>(requestId) >> REQUEST_WINDOW_ID_MASK_BIT);
524 if (iter != elementOperators_.end()) {
525 if (iter->second) {
526 iter->second->SetExecuteActionResult(succeeded, requestId);
527 }
528 }
529 }
530 }
531
SetAccessibilityState(const uint32_t stateType)532 void AccessibilitySystemAbilityClientImpl::SetAccessibilityState(const uint32_t stateType)
533 {
534 HILOG_DEBUG();
535 state_ = stateType;
536 }
537
GetAccessibilityState()538 uint32_t AccessibilitySystemAbilityClientImpl::GetAccessibilityState()
539 {
540 HILOG_DEBUG();
541 return state_;
542 }
543
SetFindAccessibilityNodeInfosResult(const std::list<AccessibilityElementInfo> elementInfos,const int32_t requestId,const int32_t requestCode)544 void AccessibilitySystemAbilityClientImpl::SetFindAccessibilityNodeInfosResult(
545 const std::list<AccessibilityElementInfo> elementInfos, const int32_t requestId, const int32_t requestCode)
546 {
547 HILOG_DEBUG();
548 switch (static_cast<SET_AA_CALLBACK_RESULT>(requestCode)) {
549 case FIND_ACCESSIBILITY_NODE_BY_ACCESSIBILITY_ID:
550 SetSearchElementInfoByAccessibilityIdResult(elementInfos, requestId);
551 break;
552 case FIND_ACCESSIBILITY_NODE_BY_TEXT:
553 SetSearchElementInfoByTextResult(elementInfos, requestId);
554 break;
555 default:
556 break;
557 }
558 }
559
SetFindAccessibilityNodeInfoResult(const AccessibilityElementInfo elementInfo,const int32_t requestId,const int32_t requestCode)560 void AccessibilitySystemAbilityClientImpl::SetFindAccessibilityNodeInfoResult(
561 const AccessibilityElementInfo elementInfo, const int32_t requestId, const int32_t requestCode)
562 {
563 HILOG_DEBUG();
564 switch (static_cast<SET_AA_CALLBACK_RESULT>(requestCode)) {
565 case FIND_ACCESSIBILITY_NODE_BY_ACCESSIBILITY_ID:
566 {
567 std::list<AccessibilityElementInfo> elementInfos = {};
568 elementInfos.push_back(elementInfo);
569 SetSearchElementInfoByAccessibilityIdResult(elementInfos, requestId);
570 }
571 break;
572 case FIND_FOCUS:
573 SetFindFocusedElementInfoResult(elementInfo, requestId);
574 break;
575 case FIND_FOCUS_SEARCH:
576 SetFocusMoveSearchResult(elementInfo, requestId);
577 break;
578 default:
579 break;
580 }
581 }
582
SetPerformActionResult(const bool succeeded,const int32_t requestId)583 void AccessibilitySystemAbilityClientImpl::SetPerformActionResult(const bool succeeded, const int32_t requestId)
584 {
585 HILOG_DEBUG();
586 SetExecuteActionResult(succeeded, requestId);
587 }
588
GetFocusedWindowId(int32_t & focusedWindowId)589 RetError AccessibilitySystemAbilityClientImpl::GetFocusedWindowId(int32_t &focusedWindowId)
590 {
591 HILOG_DEBUG();
592 std::lock_guard<std::mutex> lock(mutex_);
593 if (!serviceProxy_) {
594 HILOG_ERROR("Failed to get aams service");
595 return RET_ERR_SAMGR;
596 }
597 return serviceProxy_->GetFocusedWindowId(focusedWindowId);
598 }
599 } // namespace Accessibility
600 } // namespace OHOS