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 "accessible_ability_manager_service.h"
17
18 #include <new>
19 #include <unistd.h>
20 #include <functional>
21 #include <hitrace_meter.h>
22
23 #include "ability_info.h"
24 #include "accessibility_event_info.h"
25 #include "accessibility_window_manager.h"
26 #include "display_power_mgr_client.h"
27 #include "hilog_wrapper.h"
28 #include "input_manager.h"
29 #include "iservice_registry.h"
30 #include "os_account_manager.h"
31 #include "parameter.h"
32 #include "system_ability_definition.h"
33 #include "utils.h"
34
35 using namespace std;
36
37 namespace OHOS {
38 namespace Accessibility {
39 namespace {
40 const std::string AAMS_SERVICE_NAME = "AccessibleAbilityManagerService";
41 const std::string UI_TEST_BUNDLE_NAME = "ohos.uitest";
42 const std::string UI_TEST_ABILITY_NAME = "uitestability";
43 const std::string SYSTEM_PARAMETER_AAMS_NAME = "accessibility.config.ready";
44 const std::string GRAPHIC_ANIMATION_SCALE_NAME = "persist.sys.graphic.animationscale";
45 const std::string ARKUI_ANIMATION_SCALE_NAME = "persist.sys.arkui.animationscale";
46 constexpr int32_t QUERY_USER_ID_RETRY_COUNT = 600;
47 constexpr int32_t QUERY_USER_ID_SLEEP_TIME = 50;
48 } // namespace
49
50 const bool REGISTER_RESULT =
51 SystemAbility::MakeAndRegisterAbility(&Singleton<AccessibleAbilityManagerService>::GetInstance());
52
AccessibleAbilityManagerService()53 AccessibleAbilityManagerService::AccessibleAbilityManagerService()
54 : SystemAbility(ACCESSIBILITY_MANAGER_SERVICE_ID, true)
55 {
56 HILOG_INFO("AccessibleAbilityManagerService is constructed");
57 dependentServicesStatus_[ABILITY_MGR_SERVICE_ID] = false;
58 dependentServicesStatus_[BUNDLE_MGR_SERVICE_SYS_ABILITY_ID] = false;
59 dependentServicesStatus_[COMMON_EVENT_SERVICE_ID] = false;
60 dependentServicesStatus_[DISPLAY_MANAGER_SERVICE_SA_ID] = false;
61 dependentServicesStatus_[SUBSYS_ACCOUNT_SYS_ABILITY_ID_BEGIN] = false;
62 dependentServicesStatus_[WINDOW_MANAGER_SERVICE_ID] = false;
63 }
64
~AccessibleAbilityManagerService()65 AccessibleAbilityManagerService::~AccessibleAbilityManagerService()
66 {
67 HILOG_INFO("AccessibleAbilityManagerService::~AccessibleAbilityManagerService");
68
69 inputInterceptor_ = nullptr;
70 touchEventInjector_ = nullptr;
71 keyEventFilter_ = nullptr;
72 }
73
OnStart()74 void AccessibleAbilityManagerService::OnStart()
75 {
76 HILOG_INFO("AccessibleAbilityManagerService::OnStart start");
77 if (!runner_) {
78 runner_ = AppExecFwk::EventRunner::Create(AAMS_SERVICE_NAME);
79 if (!runner_) {
80 HILOG_ERROR("AccessibleAbilityManagerService::OnStart failed:create AAMS runner failed");
81 return;
82 }
83 }
84
85 if (!handler_) {
86 handler_ = std::make_shared<AAMSEventHandler>(runner_);
87 if (!handler_) {
88 HILOG_ERROR("AccessibleAbilityManagerService::OnStart failed:create AAMS event handler failed");
89 return;
90 }
91 }
92 SetParameter(SYSTEM_PARAMETER_AAMS_NAME.c_str(), "false");
93
94 HILOG_DEBUG("AddAbilityListener!");
95 AddSystemAbilityListener(ABILITY_MGR_SERVICE_ID);
96 AddSystemAbilityListener(BUNDLE_MGR_SERVICE_SYS_ABILITY_ID);
97 AddSystemAbilityListener(COMMON_EVENT_SERVICE_ID);
98 AddSystemAbilityListener(DISPLAY_MANAGER_SERVICE_SA_ID);
99 AddSystemAbilityListener(SUBSYS_ACCOUNT_SYS_ABILITY_ID_BEGIN);
100 AddSystemAbilityListener(WINDOW_MANAGER_SERVICE_ID);
101 }
102
OnStop()103 void AccessibleAbilityManagerService::OnStop()
104 {
105 HILOG_INFO("stop AccessibleAbilityManagerService");
106 if (!handler_) {
107 HILOG_ERROR("AccessibleAbilityManagerService::OnStop failed!");
108 return;
109 }
110
111 std::promise<void> syncPromise;
112 std::future syncFuture = syncPromise.get_future();
113 handler_->PostTask(std::bind([this, &syncPromise]() -> void {
114 HILOG_DEBUG();
115
116 Singleton<AccessibilityCommonEvent>::GetInstance().UnSubscriberEvent();
117 Singleton<AccessibilityDisplayManager>::GetInstance().UnregisterDisplayListener();
118 Singleton<AccessibilityWindowManager>::GetInstance().DeregisterWindowListener();
119
120 currentAccountId_ = -1;
121 a11yAccountsData_.clear();
122 stateCallbacks_.clear();
123 bundleManager_ = nullptr;
124 inputInterceptor_ = nullptr;
125 touchEventInjector_ = nullptr;
126 keyEventFilter_ = nullptr;
127 stateCallbackDeathRecipient_ = nullptr;
128 bundleManagerDeathRecipient_ = nullptr;
129
130 syncPromise.set_value();
131 }), "TASK_ONSTOP");
132 syncFuture.wait();
133
134 runner_.reset();
135 handler_.reset();
136 for (auto &iter : dependentServicesStatus_) {
137 iter.second = false;
138 }
139
140 isReady_ = false;
141 isPublished_ = false;
142 SetParameter(SYSTEM_PARAMETER_AAMS_NAME.c_str(), "false");
143 HILOG_INFO("AccessibleAbilityManagerService::OnStop OK.");
144 }
145
OnAddSystemAbility(int32_t systemAbilityId,const std::string & deviceId)146 void AccessibleAbilityManagerService::OnAddSystemAbility(int32_t systemAbilityId, const std::string &deviceId)
147 {
148 HILOG_DEBUG("systemAbilityId:%{public}d added!", systemAbilityId);
149 if (!handler_) {
150 HILOG_DEBUG("Event handler is nullptr.");
151 return;
152 }
153
154 handler_->PostTask(std::bind([=]() -> void {
155 auto iter = dependentServicesStatus_.find(systemAbilityId);
156 if (iter == dependentServicesStatus_.end()) {
157 HILOG_ERROR("SystemAbilityId is not found!");
158 return;
159 }
160
161 dependentServicesStatus_[systemAbilityId] = true;
162 if (std::any_of(dependentServicesStatus_.begin(), dependentServicesStatus_.end(),
163 [](const std::map<int32_t, bool>::value_type &status) { return !status.second; })) {
164 HILOG_DEBUG("Not all the dependence is ready!");
165 return;
166 }
167
168 if (Init() == false) {
169 HILOG_ERROR("AccessibleAbilityManagerService::Init failed!");
170 return;
171 }
172
173 if (!isPublished_) {
174 if (Publish(this) == false) {
175 HILOG_ERROR("AccessibleAbilityManagerService::Publish failed!");
176 return;
177 }
178 isPublished_ = true;
179 }
180
181 isReady_ = true;
182 SetParameter(SYSTEM_PARAMETER_AAMS_NAME.c_str(), "true");
183 HILOG_DEBUG("AAMS is ready!");
184 }), "OnAddSystemAbility");
185 }
186
OnRemoveSystemAbility(int32_t systemAbilityId,const std::string & deviceId)187 void AccessibleAbilityManagerService::OnRemoveSystemAbility(int32_t systemAbilityId, const std::string &deviceId)
188 {
189 HILOG_DEBUG("systemAbilityId:%{public}d removed!", systemAbilityId);
190 if (!handler_) {
191 HILOG_DEBUG("Event handler is nullptr.");
192 return;
193 }
194
195 handler_->PostTask(std::bind([=]() -> void {
196 auto iter = dependentServicesStatus_.find(systemAbilityId);
197 if (iter == dependentServicesStatus_.end()) {
198 HILOG_ERROR("SystemAbilityId is not found!");
199 return;
200 }
201
202 dependentServicesStatus_[systemAbilityId] = false;
203 if (isReady_) {
204 SwitchedUser(-1);
205 Singleton<AccessibilityCommonEvent>::GetInstance().UnSubscriberEvent();
206 Singleton<AccessibilityDisplayManager>::GetInstance().UnregisterDisplayListener();
207 Singleton<AccessibilityWindowManager>::GetInstance().DeregisterWindowListener();
208 Singleton<AccessibilityWindowManager>::GetInstance().DeInit();
209
210 isReady_ = false;
211 SetParameter(SYSTEM_PARAMETER_AAMS_NAME.c_str(), "false");
212 }
213 }), "OnRemoveSystemAbility");
214 }
215
Dump(int fd,const std::vector<std::u16string> & args)216 int AccessibleAbilityManagerService::Dump(int fd, const std::vector<std::u16string>& args)
217 {
218 HILOG_DEBUG("dump AccessibilityManagerServiceInfo");
219 if (!accessibilityDumper_) {
220 accessibilityDumper_ = new(std::nothrow) AccessibilityDumper();
221 if (!accessibilityDumper_) {
222 HILOG_ERROR("accessibilityDumper_ is nullptr");
223 return -1;
224 }
225 }
226 return accessibilityDumper_->Dump(fd, args);
227 }
228
SendEvent(const AccessibilityEventInfo & uiEvent)229 RetError AccessibleAbilityManagerService::SendEvent(const AccessibilityEventInfo &uiEvent)
230 {
231 HILOG_DEBUG("eventType[%{public}d] gestureId[%{public}d]", uiEvent.GetEventType(), uiEvent.GetGestureType());
232 if (!handler_) {
233 HILOG_ERROR("Parameters check failed!");
234 return RET_ERR_NULLPTR;
235 }
236
237 UpdateAccessibilityWindowStateByEvent(uiEvent);
238 handler_->PostTask(std::bind([this](AccessibilityEventInfo &event) -> void {
239 HILOG_DEBUG();
240 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData();
241 if (!accountData) {
242 HILOG_ERROR("accountData is nullptr.");
243 return;
244 }
245
246 event.SetTimeStamp(Utils::GetSystemTime());
247 map<string, sptr<AccessibleAbilityConnection>> abilities = accountData->GetConnectedA11yAbilities();
248 for (auto &ability : abilities) {
249 if (ability.second) {
250 ability.second->OnAccessibilityEvent(event);
251 }
252 }
253 }, uiEvent), "TASK_SEND_EVENT");
254 return RET_OK;
255 }
256
RegisterStateObserver(const sptr<IAccessibleAbilityManagerStateObserver> & callback)257 uint32_t AccessibleAbilityManagerService::RegisterStateObserver(
258 const sptr<IAccessibleAbilityManagerStateObserver> &callback)
259 {
260 HILOG_DEBUG();
261 if (!callback || !handler_) {
262 HILOG_ERROR("Parameters check failed!");
263 return 0;
264 }
265
266 std::promise<uint32_t> syncPromise;
267 std::future syncFuture = syncPromise.get_future();
268 handler_->PostTask(std::bind([this, &syncPromise, callback]() -> void {
269 HILOG_DEBUG();
270 if (!stateCallbackDeathRecipient_) {
271 stateCallbackDeathRecipient_ = new(std::nothrow) StateCallbackDeathRecipient();
272 if (!stateCallbackDeathRecipient_) {
273 HILOG_ERROR("stateCallbackDeathRecipient_ is null");
274 syncPromise.set_value(0);
275 return;
276 }
277 }
278 if (!callback->AsObject()) {
279 HILOG_ERROR("object is null");
280 syncPromise.set_value(0);
281 return;
282 }
283 callback->AsObject()->AddDeathRecipient(stateCallbackDeathRecipient_);
284 auto iter = std::find(stateCallbacks_.begin(), stateCallbacks_.end(), callback);
285 if (iter == stateCallbacks_.end()) {
286 stateCallbacks_.push_back(callback);
287 HILOG_INFO("RegisterStateObserver successfully");
288 }
289
290 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData();
291 if (!accountData) {
292 HILOG_ERROR("Account data is null");
293 syncPromise.set_value(0);
294 return;
295 }
296 uint32_t state = accountData->GetAccessibilityState();
297 syncPromise.set_value(state);
298 }), "TASK_REGISTER_STATE_OBSERVER");
299
300 return syncFuture.get();
301 }
302
RegisterCaptionObserver(const sptr<IAccessibleAbilityManagerCaptionObserver> & callback)303 uint32_t AccessibleAbilityManagerService::RegisterCaptionObserver(
304 const sptr<IAccessibleAbilityManagerCaptionObserver> &callback)
305 {
306 HILOG_DEBUG();
307 if (!callback || !handler_) {
308 HILOG_ERROR("Parameters check failed! callback:%{public}p, handler:%{public}p",
309 callback.GetRefPtr(), handler_.get());
310 return ERR_INVALID_VALUE;
311 }
312
313 std::promise<uint32_t> syncPromise;
314 std::future syncFuture = syncPromise.get_future();
315 handler_->PostTask(std::bind([this, &syncPromise, callback]() -> void {
316 HILOG_DEBUG();
317 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData();
318 if (!accountData) {
319 HILOG_ERROR("Account data is null");
320 syncPromise.set_value(ERR_INVALID_VALUE);
321 return;
322 }
323 if (!captionPropertyCallbackDeathRecipient_) {
324 captionPropertyCallbackDeathRecipient_ = new(std::nothrow) CaptionPropertyCallbackDeathRecipient();
325 if (!captionPropertyCallbackDeathRecipient_) {
326 HILOG_ERROR("captionPropertyCallbackDeathRecipient_ is null");
327 syncPromise.set_value(ERR_INVALID_VALUE);
328 return;
329 }
330 }
331 if (!callback->AsObject()) {
332 HILOG_ERROR("object is null");
333 syncPromise.set_value(0);
334 return;
335 }
336 callback->AsObject()->AddDeathRecipient(captionPropertyCallbackDeathRecipient_);
337 accountData->AddCaptionPropertyCallback(callback);
338 HILOG_DEBUG("the size of caption property callbacks is %{public}zu",
339 accountData->GetCaptionPropertyCallbacks().size());
340 syncPromise.set_value(NO_ERROR);
341 }), "TASK_REGISTER_CAPTION_OBSERVER");
342 return syncFuture.get();
343 }
344
RegisterEnableAbilityListsObserver(const sptr<IAccessibilityEnableAbilityListsObserver> & observer)345 void AccessibleAbilityManagerService::RegisterEnableAbilityListsObserver(
346 const sptr<IAccessibilityEnableAbilityListsObserver> &observer)
347 {
348 HILOG_DEBUG();
349 if (!observer || !handler_) {
350 HILOG_ERROR("Parameters check failed!");
351 return;
352 }
353
354 std::promise<void> syncPromise;
355 std::future syncFuture = syncPromise.get_future();
356 handler_->PostTask(std::bind([this, &syncPromise, observer]() -> void {
357 HILOG_DEBUG();
358 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData();
359 if (!accountData) {
360 HILOG_ERROR("Account data is null");
361 syncPromise.set_value();
362 return;
363 }
364 if (!enableAbilityListsObserverDeathRecipient_) {
365 enableAbilityListsObserverDeathRecipient_ = new(std::nothrow) EnableAbilityListsObserverDeathRecipient();
366 if (!enableAbilityListsObserverDeathRecipient_) {
367 HILOG_ERROR("enableAbilityListsObserverDeathRecipient_ is null");
368 syncPromise.set_value();
369 return;
370 }
371 }
372 if (!observer->AsObject()) {
373 HILOG_ERROR("object is null");
374 syncPromise.set_value();
375 return;
376 }
377 observer->AsObject()->AddDeathRecipient(enableAbilityListsObserverDeathRecipient_);
378 accountData->AddEnableAbilityListsObserver(observer);
379 syncPromise.set_value();
380 }), "TASK_REGISTER_ENABLE_ABILITY_LISTS_OBSERVER");
381 return syncFuture.get();
382 }
383
GetAbilityList(const uint32_t abilityTypes,const int32_t stateType,std::vector<AccessibilityAbilityInfo> & infos)384 RetError AccessibleAbilityManagerService::GetAbilityList(const uint32_t abilityTypes, const int32_t stateType,
385 std::vector<AccessibilityAbilityInfo> &infos)
386 {
387 HILOG_DEBUG("abilityTypes(%{public}d) stateType(%{public}d)", abilityTypes, stateType);
388 if (!handler_ || (stateType > ABILITY_STATE_INSTALLED) || (stateType < ABILITY_STATE_ENABLE)) {
389 HILOG_ERROR("Parameters check failed! stateType:%{public}d, handler:%{public}p", stateType, handler_.get());
390 return RET_ERR_INVALID_PARAM;
391 }
392
393 std::promise<RetError> syncPromise;
394 std::future syncFuture = syncPromise.get_future();
395 handler_->PostTask(std::bind([this, &syncPromise, &infos, abilityTypes, stateType]() -> void {
396 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData();
397 if (!accountData) {
398 HILOG_ERROR("Get current account data failed!!");
399 syncPromise.set_value(RET_ERR_FAILED);
400 return;
401 }
402
403 vector<AccessibilityAbilityInfo> abilities;
404 accountData->GetAbilitiesByState(static_cast<AbilityStateType>(stateType), abilities);
405 HILOG_DEBUG("abilityes count is %{public}zu", abilities.size());
406 for (auto &ability : abilities) {
407 if (abilityTypes == AccessibilityAbilityTypes::ACCESSIBILITY_ABILITY_TYPE_ALL ||
408 (ability.GetAccessibilityAbilityType() & abilityTypes)) {
409 infos.push_back(ability);
410 }
411 }
412 HILOG_DEBUG("infos count is %{public}zu", infos.size());
413 syncPromise.set_value(RET_OK);
414 }), "TASK_GET_ABILITY_LIST");
415 return syncFuture.get();
416 }
417
RegisterElementOperator(const int32_t windowId,const sptr<IAccessibilityElementOperator> & operation)418 RetError AccessibleAbilityManagerService::RegisterElementOperator(
419 const int32_t windowId, const sptr<IAccessibilityElementOperator> &operation)
420 {
421 if (!handler_) {
422 Utils::RecordUnavailableEvent(A11yUnavailableEvent::CONNECT_EVENT,
423 A11yError::ERROR_CONNECT_TARGET_APPLICATION_FAILED);
424 HILOG_ERROR("handler_ is nullptr.");
425 return RET_ERR_NULLPTR;
426 }
427
428 handler_->PostTask(std::bind([=]() -> void {
429 HILOG_INFO("Register windowId[%{public}d]", windowId);
430 HITRACE_METER_NAME(HITRACE_TAG_ACCESSIBILITY_MANAGER, "RegisterElementOperator");
431 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData();
432 if (!accountData) {
433 Utils::RecordUnavailableEvent(A11yUnavailableEvent::CONNECT_EVENT,
434 A11yError::ERROR_CONNECT_TARGET_APPLICATION_FAILED);
435 HILOG_ERROR("Get current account data failed!!");
436 return;
437 }
438 if (accountData->GetAccessibilityWindowConnection(windowId)) {
439 Utils::RecordUnavailableEvent(A11yUnavailableEvent::CONNECT_EVENT,
440 A11yError::ERROR_CONNECT_TARGET_APPLICATION_FAILED);
441 HILOG_WARN("This operation already exists, do not register twice!!");
442 return;
443 }
444
445 sptr<AccessibilityWindowConnection> connection =
446 new(std::nothrow) AccessibilityWindowConnection(windowId, operation, currentAccountId_);
447 if (!connection) {
448 Utils::RecordUnavailableEvent(A11yUnavailableEvent::CONNECT_EVENT,
449 A11yError::ERROR_CONNECT_TARGET_APPLICATION_FAILED);
450 HILOG_ERROR("New AccessibilityWindowConnection failed!!");
451 return;
452 }
453 accountData->AddAccessibilityWindowConnection(windowId, connection);
454
455 if (operation && operation->AsObject()) {
456 sptr<IRemoteObject::DeathRecipient> deathRecipient =
457 new(std::nothrow) InteractionOperationDeathRecipient(windowId);
458 if (!deathRecipient) {
459 Utils::RecordUnavailableEvent(A11yUnavailableEvent::CONNECT_EVENT,
460 A11yError::ERROR_CONNECT_TARGET_APPLICATION_FAILED);
461 HILOG_ERROR("Create interactionOperationDeathRecipient failed");
462 return;
463 }
464
465 bool result = operation->AsObject()->AddDeathRecipient(deathRecipient);
466 interactionOperationDeathRecipients_[windowId] = deathRecipient;
467 HILOG_DEBUG("The result of adding operation's death recipient is %{public}d", result);
468 }
469 }), "TASK_REGISTER_ELEMENT_OPERATOR");
470 return RET_OK;
471 }
472
DeregisterElementOperator(int32_t windowId)473 RetError AccessibleAbilityManagerService::DeregisterElementOperator(int32_t windowId)
474 {
475 if (!handler_) {
476 HILOG_ERROR("handler_ is nullptr.");
477 return RET_ERR_NULLPTR;
478 }
479
480 handler_->PostTask(std::bind([=]() -> void {
481 HILOG_INFO("Deregister windowId[%{public}d]", windowId);
482 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData();
483 if (!accountData) {
484 HILOG_ERROR("accountData is nullptr.");
485 return;
486 }
487 sptr<AccessibilityWindowConnection> connection = accountData->GetAccessibilityWindowConnection(windowId);
488 if (!connection) {
489 HILOG_WARN("The operation of windowId[%{public}d] has not been registered.", windowId);
490 return;
491 }
492 accountData->RemoveAccessibilityWindowConnection(windowId);
493
494 if (!connection->GetProxy()) {
495 HILOG_ERROR("proxy is null");
496 return;
497 }
498
499 auto object = connection->GetProxy()->AsObject();
500 if (object) {
501 auto iter = interactionOperationDeathRecipients_.find(windowId);
502 if (iter != interactionOperationDeathRecipients_.end()) {
503 sptr<IRemoteObject::DeathRecipient> deathRecipient = iter->second;
504 bool result = object->RemoveDeathRecipient(deathRecipient);
505 HILOG_DEBUG("The result of deleting operation's death recipient is %{public}d", result);
506 interactionOperationDeathRecipients_.erase(iter);
507 }
508 }
509 }), "TASK_DEREGISTER_ELEMENT_OPERATOR");
510 return RET_OK;
511 }
512
GetCaptionProperty(AccessibilityConfig::CaptionProperty & caption)513 RetError AccessibleAbilityManagerService::GetCaptionProperty(AccessibilityConfig::CaptionProperty &caption)
514 {
515 HILOG_DEBUG();
516 if (!handler_) {
517 HILOG_ERROR("handler_ is nullptr.");
518 return RET_ERR_NULLPTR;
519 }
520
521 std::promise<RetError> syncPromise;
522 std::future syncFuture = syncPromise.get_future();
523 handler_->PostTask(std::bind([this, &syncPromise, &caption]() -> void {
524 HILOG_DEBUG();
525 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData();
526 if (!accountData) {
527 HILOG_ERROR("accountData is nullptr.");
528 syncPromise.set_value(RET_ERR_NULLPTR);
529 return;
530 }
531 caption = accountData->GetConfig()->GetCaptionProperty();
532 syncPromise.set_value(RET_OK);
533 }), "TASK_GET_CAPTION_PROPERTY");
534 return syncFuture.get();
535 }
536
SetCaptionProperty(const AccessibilityConfig::CaptionProperty & caption)537 RetError AccessibleAbilityManagerService::SetCaptionProperty(const AccessibilityConfig::CaptionProperty &caption)
538 {
539 HILOG_DEBUG();
540 if (!handler_) {
541 HILOG_ERROR("handler_ is nullptr.");
542 return RET_ERR_NULLPTR;
543 }
544
545 std::promise<RetError> syncPromise;
546 std::future syncFuture = syncPromise.get_future();
547 handler_->PostTask(std::bind([this, &syncPromise, &caption]() -> void {
548 HILOG_DEBUG();
549 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData();
550 if (!accountData) {
551 HILOG_ERROR("accountData is nullptr.");
552 syncPromise.set_value(RET_ERR_NULLPTR);
553 return;
554 }
555 RetError ret = accountData->GetConfig()->SetCaptionProperty(caption);
556 syncPromise.set_value(ret);
557 UpdateCaptionProperty();
558 }), "TASK_SET_CAPTION_PROPERTY");
559 return syncFuture.get();
560 }
561
SetCaptionState(const bool state)562 RetError AccessibleAbilityManagerService::SetCaptionState(const bool state)
563 {
564 if (!handler_) {
565 HILOG_ERROR("handler_ is nullptr.");
566 return RET_ERR_NULLPTR;
567 }
568
569 std::promise<RetError> syncPromise;
570 std::future syncFuture = syncPromise.get_future();
571 handler_->PostTask(std::bind([this, &syncPromise, state]() -> void {
572 HILOG_INFO("state = [%{public}s]", state ? "True" : "False");
573 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData();
574 if (!accountData) {
575 HILOG_ERROR("accountData is nullptr.");
576 syncPromise.set_value(RET_ERR_NULLPTR);
577 return;
578 }
579 RetError ret = accountData->GetConfig()->SetCaptionState(state);
580 syncPromise.set_value(ret);
581 UpdateConfigState();
582 }), "TASK_SET_CAPTION_STATE");
583 return syncFuture.get();
584 }
585
GetEnabledState()586 bool AccessibleAbilityManagerService::GetEnabledState()
587 {
588 HILOG_DEBUG();
589 if (!handler_) {
590 HILOG_ERROR("handler_ is nullptr.");
591 return false;
592 }
593
594 std::promise<bool> syncPromise;
595 std::future syncFuture = syncPromise.get_future();
596 handler_->PostTask(std::bind([this, &syncPromise]() -> void {
597 HILOG_DEBUG();
598 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData();
599 if (!accountData) {
600 HILOG_ERROR("accountData is nullptr");
601 syncPromise.set_value(false);
602 return;
603 }
604 bool result = accountData->GetConfig()->GetEnabledState();
605 syncPromise.set_value(result);
606 }), "TASK_GET_ENABLE_STATE");
607 return syncFuture.get();
608 }
609
GetCaptionState(bool & state)610 RetError AccessibleAbilityManagerService::GetCaptionState(bool &state)
611 {
612 HILOG_DEBUG();
613 if (!handler_) {
614 HILOG_ERROR("handler_ is nullptr.");
615 return RET_ERR_NULLPTR;
616 }
617
618 std::promise<RetError> syncPromise;
619 std::future syncFuture = syncPromise.get_future();
620 handler_->PostTask(std::bind([this, &syncPromise, &state]() -> void {
621 HILOG_DEBUG();
622 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData();
623 if (!accountData) {
624 HILOG_ERROR("accountData is nullptr");
625 syncPromise.set_value(RET_ERR_NULLPTR);
626 return;
627 }
628 state = accountData->GetConfig()->GetCaptionState();
629 syncPromise.set_value(RET_OK);
630 }), "TASK_GET_CAPTION_STATE");
631 return syncFuture.get();
632 }
633
GetTouchGuideState()634 bool AccessibleAbilityManagerService::GetTouchGuideState()
635 {
636 HILOG_DEBUG();
637 if (!handler_) {
638 HILOG_ERROR("handler_ is nullptr.");
639 return false;
640 }
641
642 std::promise<bool> syncPromise;
643 std::future syncFuture = syncPromise.get_future();
644 handler_->PostTask(std::bind([this, &syncPromise]() -> void {
645 HILOG_DEBUG();
646 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData();
647 if (!accountData) {
648 HILOG_ERROR("accountData is nullptr");
649 syncPromise.set_value(false);
650 return;
651 }
652 bool result = accountData->GetConfig()->GetTouchGuideState();
653 syncPromise.set_value(result);
654 }), "TASK_GET_TOUCH_GUIDE_STATE");
655 return syncFuture.get();
656 }
657
GetGestureState()658 bool AccessibleAbilityManagerService::GetGestureState()
659 {
660 HILOG_DEBUG();
661 if (!handler_) {
662 HILOG_ERROR("handler_ is nullptr.");
663 return false;
664 }
665
666 std::promise<bool> syncPromise;
667 std::future syncFuture = syncPromise.get_future();
668 handler_->PostTask(std::bind([this, &syncPromise]() -> void {
669 HILOG_DEBUG();
670 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData();
671 if (!accountData) {
672 HILOG_ERROR("accountData is nullptr");
673 syncPromise.set_value(false);
674 return;
675 }
676 bool result = accountData->GetConfig()->GetGestureState();
677 syncPromise.set_value(result);
678 }), "TASK_GET_GESTURE_STATE");
679 return syncFuture.get();
680 }
681
GetKeyEventObserverState()682 bool AccessibleAbilityManagerService::GetKeyEventObserverState()
683 {
684 HILOG_DEBUG();
685 if (!handler_) {
686 HILOG_ERROR("handler_ is nullptr.");
687 return false;
688 }
689
690 std::promise<bool> syncPromise;
691 std::future syncFuture = syncPromise.get_future();
692 handler_->PostTask(std::bind([this, &syncPromise]() -> void {
693 HILOG_DEBUG();
694 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData();
695 if (!accountData) {
696 HILOG_ERROR("accountData is nullptr");
697 syncPromise.set_value(false);
698 return;
699 }
700 bool result = accountData->GetConfig()->GetKeyEventObserverState();
701 syncPromise.set_value(result);
702 }), "TASK_GET_KEY_EVENT_OBSERVER_STATE");
703 return syncFuture.get();
704 }
705
EnableAbility(const std::string & name,const uint32_t capabilities)706 RetError AccessibleAbilityManagerService::EnableAbility(const std::string &name, const uint32_t capabilities)
707 {
708 HILOG_DEBUG();
709 if (!handler_) {
710 HILOG_ERROR("handler_ is nullptr.");
711 return RET_ERR_NULLPTR;
712 }
713
714 std::promise<RetError> syncPromise;
715 std::future syncFuture = syncPromise.get_future();
716 handler_->PostTask(std::bind([this, &syncPromise, &name, &capabilities]() -> void {
717 HILOG_DEBUG();
718 RetError result = InnerEnableAbility(name, capabilities);
719 syncPromise.set_value(result);
720 }), "TASK_ENABLE_ABILITIES");
721 return syncFuture.get();
722 }
723
InnerEnableAbility(const std::string & name,const uint32_t capabilities)724 RetError AccessibleAbilityManagerService::InnerEnableAbility(const std::string &name, const uint32_t capabilities)
725 {
726 HILOG_DEBUG();
727 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData();
728 if (!accountData) {
729 HILOG_ERROR("accountData is nullptr");
730 return RET_ERR_NULLPTR;
731 }
732 return accountData->EnableAbility(name, capabilities);
733 }
734
GetEnabledAbilities(std::vector<std::string> & enabledAbilities)735 RetError AccessibleAbilityManagerService::GetEnabledAbilities(std::vector<std::string> &enabledAbilities)
736 {
737 HILOG_DEBUG();
738 if (!handler_) {
739 HILOG_ERROR("handler_ is nullptr.");
740 return RET_ERR_NULLPTR;
741 }
742
743 std::promise<RetError> syncPromise;
744 std::future syncFuture = syncPromise.get_future();
745 handler_->PostTask(std::bind([this, &syncPromise, &enabledAbilities]() -> void {
746 HILOG_DEBUG();
747 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData();
748 if (!accountData) {
749 HILOG_ERROR("accountData is nullptr");
750 syncPromise.set_value(RET_ERR_NULLPTR);
751 return;
752 }
753 enabledAbilities = accountData->GetEnabledAbilities();
754 syncPromise.set_value(RET_OK);
755 }), "TASK_GET_ENABLE_ABILITIES");
756 return syncFuture.get();
757 }
758
DisableAbility(const std::string & name)759 RetError AccessibleAbilityManagerService::DisableAbility(const std::string &name)
760 {
761 HILOG_DEBUG();
762 if (!handler_) {
763 HILOG_ERROR("handler_ is nullptr.");
764 return RET_ERR_NULLPTR;
765 }
766
767 std::promise<RetError> syncPromise;
768 std::future syncFuture = syncPromise.get_future();
769 handler_->PostTask(std::bind([this, &syncPromise, &name]() -> void {
770 HILOG_DEBUG();
771 RetError result = InnerDisableAbility(name);
772 syncPromise.set_value(result);
773 }), "TASK_DISABLE_ABILITIES");
774 return syncFuture.get();
775 }
776
InnerDisableAbility(const std::string & name)777 RetError AccessibleAbilityManagerService::InnerDisableAbility(const std::string &name)
778 {
779 HILOG_DEBUG();
780 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData();
781 if (!accountData) {
782 HILOG_ERROR("accountData is nullptr");
783 return RET_ERR_NULLPTR;
784 }
785 RetError ret = accountData->RemoveEnabledAbility(name);
786 if (ret != RET_OK) {
787 HILOG_ERROR("RemoveEnabledAbility failed");
788 return ret;
789 }
790 accountData->RemoveConnectingA11yAbility(name);
791 accountData->UpdateAbilities();
792 return RET_OK;
793 }
794
EnableUITestAbility(const sptr<IRemoteObject> & obj)795 RetError AccessibleAbilityManagerService::EnableUITestAbility(const sptr<IRemoteObject> &obj)
796 {
797 HILOG_DEBUG();
798 if (!handler_) {
799 HILOG_ERROR("handler_ is nullptr.");
800 return RET_ERR_NULLPTR;
801 }
802
803 std::promise<RetError> syncPromise;
804 std::future syncFuture = syncPromise.get_future();
805 handler_->PostTask(std::bind([this, &syncPromise, obj]() -> void {
806 HILOG_DEBUG();
807 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData();
808 if (!accountData) {
809 HILOG_ERROR("accountData is nullptr");
810 syncPromise.set_value(RET_ERR_NULLPTR);
811 return;
812 }
813 std::string uiTestUri = Utils::GetUri(UI_TEST_BUNDLE_NAME, UI_TEST_ABILITY_NAME);
814 sptr<AccessibleAbilityConnection> connection = accountData->GetAccessibleAbilityConnection(uiTestUri);
815 if (connection) {
816 HILOG_ERROR("connection is existed!!");
817 syncPromise.set_value(RET_ERR_CONNECTION_EXIST);
818 return;
819 }
820
821 std::function<void()> addUITestClientFunc = std::bind(&AccessibilityAccountData::AddUITestClient, accountData,
822 obj, UI_TEST_BUNDLE_NAME, UI_TEST_ABILITY_NAME);
823 handler_->PostTask(addUITestClientFunc, "AddUITestClient");
824 syncPromise.set_value(RET_OK);
825 }), "TASK_ENABLE_UI_TEST_ABILITIES");
826 return syncFuture.get();
827 }
828
DisableUITestAbility()829 RetError AccessibleAbilityManagerService::DisableUITestAbility()
830 {
831 HILOG_DEBUG();
832 if (!handler_) {
833 HILOG_ERROR("handler_ is nullptr.");
834 return RET_ERR_NULLPTR;
835 }
836
837 std::promise<RetError> syncPromise;
838 std::future syncFuture = syncPromise.get_future();
839 handler_->PostTask(std::bind([this, &syncPromise]() -> void {
840 HILOG_DEBUG();
841 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData();
842 if (!accountData) {
843 HILOG_ERROR("accountData is nullptr");
844 syncPromise.set_value(RET_ERR_NULLPTR);
845 return;
846 }
847 std::string uiTestUri = Utils::GetUri(UI_TEST_BUNDLE_NAME, UI_TEST_ABILITY_NAME);
848 sptr<AccessibleAbilityConnection> connection = accountData->GetAccessibleAbilityConnection(uiTestUri);
849 if (!connection) {
850 HILOG_ERROR("connection is not existed!!");
851 syncPromise.set_value(RET_ERR_NO_CONNECTION);
852 return;
853 }
854 std::function<void()> removeUITestClientFunc =
855 std::bind(&AccessibilityAccountData::RemoveUITestClient, accountData, connection, UI_TEST_BUNDLE_NAME);
856 handler_->PostTask(removeUITestClientFunc, "RemoveUITestClient");
857 syncPromise.set_value(RET_OK);
858 }), "TASK_DISABLE_UI_TEST_ABILITIES");
859 return syncFuture.get();
860 }
861
GetActiveWindow()862 int32_t AccessibleAbilityManagerService::GetActiveWindow()
863 {
864 HILOG_DEBUG();
865 if (!handler_) {
866 HILOG_ERROR("handler_ is nullptr.");
867 return -1;
868 }
869
870 std::promise<int32_t> syncPromise;
871 std::future syncFuture = syncPromise.get_future();
872 handler_->PostTask(std::bind([this, &syncPromise]() -> void {
873 HILOG_DEBUG();
874 syncPromise.set_value(Singleton<AccessibilityWindowManager>::GetInstance().activeWindowId_);
875 }), "TASK_GET_ACTIVE_WINDOW");
876 return syncFuture.get();
877 }
878
Init()879 bool AccessibleAbilityManagerService::Init()
880 {
881 HILOG_DEBUG();
882 Singleton<AccessibilityCommonEvent>::GetInstance().SubscriberEvent(handler_);
883 Singleton<AccessibilityDisplayManager>::GetInstance().RegisterDisplayListener(handler_);
884 Singleton<AccessibilityWindowManager>::GetInstance().RegisterWindowListener(handler_);
885 bool result = Singleton<AccessibilityWindowManager>::GetInstance().Init();
886 HILOG_DEBUG("wms init result is %{public}d", result);
887
888 int32_t retry = QUERY_USER_ID_RETRY_COUNT;
889 int32_t sleepTime = QUERY_USER_ID_SLEEP_TIME;
890 std::vector<int32_t> accountIds;
891 ErrCode ret = AccountSA::OsAccountManager::QueryActiveOsAccountIds(accountIds);
892 while (ret != ERR_OK || accountIds.size() == 0) {
893 HILOG_DEBUG("Query account information failed, left retry count:%{public}d", retry);
894 if (retry == 0) {
895 HILOG_ERROR("Query account information failed!!!");
896 break;
897 }
898 std::this_thread::sleep_for(std::chrono::milliseconds(sleepTime));
899 ret = AccountSA::OsAccountManager::QueryActiveOsAccountIds(accountIds);
900 retry--;
901 }
902
903 if (accountIds.size() > 0) {
904 HILOG_DEBUG("Query account information success, account id:%{public}d", accountIds[0]);
905 SwitchedUser(accountIds[0]);
906 }
907
908 return true;
909 }
910
OnRemoteDied(const wptr<IRemoteObject> & remote)911 void AccessibleAbilityManagerService::InteractionOperationDeathRecipient::OnRemoteDied(
912 const wptr<IRemoteObject> &remote)
913 {
914 Utils::RecordUnavailableEvent(A11yUnavailableEvent::CONNECT_EVENT,
915 A11yError::ERROR_TARGET_APPLICATION_DISCONNECT_ABNORMALLY);
916 HILOG_INFO();
917 Singleton<AccessibleAbilityManagerService>::GetInstance().DeregisterElementOperator(windowId_);
918 }
919
GetCurrentAccountData()920 sptr<AccessibilityAccountData> AccessibleAbilityManagerService::GetCurrentAccountData()
921 {
922 HILOG_DEBUG("currentAccoutId is %{public}d ", currentAccountId_);
923 if (currentAccountId_ == -1) {
924 HILOG_ERROR("current account id is wrong");
925 return nullptr;
926 }
927 auto iter = a11yAccountsData_.find(currentAccountId_);
928 if (iter != a11yAccountsData_.end()) {
929 return iter->second;
930 }
931 sptr<AccessibilityAccountData> accountData = new(std::nothrow) AccessibilityAccountData(currentAccountId_);
932 if (!accountData) {
933 HILOG_ERROR("accountData is null");
934 return nullptr;
935 }
936 a11yAccountsData_.insert(make_pair(currentAccountId_, accountData));
937 return accountData;
938 }
939
GetAccountData(int32_t accountId) const940 sptr<AccessibilityAccountData> AccessibleAbilityManagerService::GetAccountData(int32_t accountId) const
941 {
942 HILOG_DEBUG("accountId is %{public}d ", accountId);
943 auto iter = a11yAccountsData_.find(accountId);
944 if (iter != a11yAccountsData_.end()) {
945 return iter->second;
946 }
947 HILOG_ERROR("There is no account[%{public}d]", accountId);
948 return nullptr;
949 }
950
GetBundleMgrProxy()951 sptr<AppExecFwk::IBundleMgr> AccessibleAbilityManagerService::GetBundleMgrProxy()
952 {
953 HILOG_DEBUG();
954 if (bundleManager_) {
955 return bundleManager_;
956 }
957
958 sptr<ISystemAbilityManager> systemAbilityManager =
959 SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
960 if (!systemAbilityManager) {
961 HILOG_ERROR("failed:fail to get system ability mgr.");
962 return nullptr;
963 }
964
965 sptr<IRemoteObject> remoteObject = systemAbilityManager->GetSystemAbility(BUNDLE_MGR_SERVICE_SYS_ABILITY_ID);
966 if (!remoteObject) {
967 HILOG_ERROR("failed:fail to get bundle manager proxy.");
968 return nullptr;
969 }
970
971 bundleManager_ = iface_cast<AppExecFwk::IBundleMgr>(remoteObject);
972 if (!bundleManager_) {
973 HILOG_ERROR("fail to new bundle manager.");
974 return nullptr;
975 }
976
977 if (!bundleManagerDeathRecipient_) {
978 bundleManagerDeathRecipient_ = new(std::nothrow) BundleManagerDeathRecipient();
979 if (!bundleManagerDeathRecipient_) {
980 HILOG_ERROR("bundleManagerDeathRecipient_ is null");
981 return nullptr;
982 }
983 }
984
985 bundleManager_->AsObject()->AddDeathRecipient(bundleManagerDeathRecipient_);
986 return bundleManager_;
987 }
988
GetAccessibilityWindowConnection(int32_t windowId)989 sptr<AccessibilityWindowConnection> AccessibleAbilityManagerService::GetAccessibilityWindowConnection(
990 int32_t windowId)
991 {
992 HILOG_DEBUG("windowId(%{public}d)", windowId);
993 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData();
994 if (!accountData) {
995 HILOG_ERROR("Get account data failed");
996 return nullptr;
997 }
998 return accountData->GetAccessibilityWindowConnection(windowId);
999 }
1000
ClearFocus(int32_t windowId)1001 void AccessibleAbilityManagerService::ClearFocus(int32_t windowId)
1002 {
1003 HILOG_DEBUG();
1004 sptr<AccessibilityWindowConnection> connection = GetAccessibilityWindowConnection(windowId);
1005 if (connection && connection->GetProxy()) {
1006 connection->GetProxy()->ClearFocus();
1007 }
1008 }
1009
OutsideTouch(int32_t windowId)1010 void AccessibleAbilityManagerService::OutsideTouch(int32_t windowId)
1011 {
1012 HILOG_DEBUG();
1013 sptr<AccessibilityWindowConnection> connection = GetAccessibilityWindowConnection(windowId);
1014 if (connection && connection->GetProxy()) {
1015 connection->GetProxy()->OutsideTouch();
1016 }
1017 }
1018
SetTouchEventInjector(const sptr<TouchEventInjector> & touchEventInjector)1019 void AccessibleAbilityManagerService::SetTouchEventInjector(const sptr<TouchEventInjector> &touchEventInjector)
1020 {
1021 HILOG_DEBUG();
1022 touchEventInjector_ = touchEventInjector;
1023 }
1024
SetKeyEventFilter(const sptr<KeyEventFilter> & keyEventFilter)1025 void AccessibleAbilityManagerService::SetKeyEventFilter(const sptr<KeyEventFilter> &keyEventFilter)
1026 {
1027 HILOG_DEBUG();
1028 keyEventFilter_ = keyEventFilter;
1029 }
1030
OnRemoteDied(const wptr<IRemoteObject> & remote)1031 void AccessibleAbilityManagerService::StateCallbackDeathRecipient::OnRemoteDied(const wptr<IRemoteObject> &remote)
1032 {
1033 Singleton<AccessibleAbilityManagerService>::GetInstance().RemoveCallback(STATE_CALLBACK, this, remote);
1034 }
1035
OnRemoteDied(const wptr<IRemoteObject> & remote)1036 void AccessibleAbilityManagerService::CaptionPropertyCallbackDeathRecipient::OnRemoteDied(
1037 const wptr<IRemoteObject> &remote)
1038 {
1039 Singleton<AccessibleAbilityManagerService>::GetInstance().RemoveCallback(CAPTION_PROPERTY_CALLBACK, this, remote);
1040 }
1041
OnRemoteDied(const wptr<IRemoteObject> & remote)1042 void AccessibleAbilityManagerService::EnableAbilityListsObserverDeathRecipient::OnRemoteDied(
1043 const wptr<IRemoteObject> &remote)
1044 {
1045 Singleton<AccessibleAbilityManagerService>::GetInstance().RemoveCallback(
1046 ENABLE_ABILITY_LISTS_CALLBACK, this, remote);
1047 }
1048
AddedUser(int32_t accountId)1049 void AccessibleAbilityManagerService::AddedUser(int32_t accountId)
1050 {
1051 HILOG_DEBUG("accountId(%{public}d)", accountId);
1052
1053 // Add this account in map
1054 auto iter = a11yAccountsData_.find(accountId);
1055 if (iter != a11yAccountsData_.end()) {
1056 HILOG_DEBUG("The account[%{public}d] is already exist.", accountId);
1057 }
1058 sptr<AccessibilityAccountData> accountData = new(std::nothrow) AccessibilityAccountData(accountId);
1059 if (!accountData) {
1060 HILOG_ERROR("accountData is null");
1061 return;
1062 }
1063 a11yAccountsData_.insert(make_pair(accountId, accountData));
1064
1065 // Initialize data of this account
1066 a11yAccountsData_[accountId]->Init();
1067 }
1068
RemovedUser(int32_t accountId)1069 void AccessibleAbilityManagerService::RemovedUser(int32_t accountId)
1070 {
1071 HILOG_DEBUG("accountId(%{public}d)", accountId);
1072 if (accountId == currentAccountId_) {
1073 HILOG_ERROR("Remove user failed, this account is current account.");
1074 return;
1075 }
1076
1077 auto iter = a11yAccountsData_.find(accountId);
1078 if (iter != a11yAccountsData_.end()) {
1079 iter->second->GetConfig()->ClearData();
1080 a11yAccountsData_.erase(iter);
1081 return;
1082 }
1083 HILOG_ERROR("The account[%{public}d] is not exist.", accountId);
1084 }
1085
SwitchedUser(int32_t accountId)1086 void AccessibleAbilityManagerService::SwitchedUser(int32_t accountId)
1087 {
1088 HILOG_DEBUG("accountId(%{public}d)", accountId);
1089
1090 if (accountId == currentAccountId_) {
1091 HILOG_WARN("The account id(%{public}d) is current account id.", accountId);
1092 return;
1093 }
1094
1095 std::map<std::string, uint32_t> importantEnabledAbilities;
1096 std::vector<sptr<IAccessibleAbilityManagerConfigObserver>> tmpObserver;
1097 // Clear last account's data
1098 if (currentAccountId_ != -1) {
1099 HILOG_DEBUG("current account id: %{public}d", currentAccountId_);
1100 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData();
1101 if (!accountData) {
1102 HILOG_ERROR("Current account data is null");
1103 return;
1104 }
1105 tmpObserver = accountData->GetConfigCallbacks();
1106 accountData->GetImportantEnabledAbilities(importantEnabledAbilities);
1107 accountData->OnAccountSwitched();
1108 UpdateAccessibilityManagerService();
1109 }
1110
1111 // Switch account id
1112 currentAccountId_ = accountId;
1113
1114 // Initialize data for current account
1115 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData();
1116 if (!accountData) {
1117 HILOG_ERROR("accountData is nullptr.");
1118 return;
1119 }
1120 accountData->Init();
1121 accountData->SetConfigCallbacks(tmpObserver);
1122 float discount = accountData->GetConfig()->GetBrightnessDiscount();
1123 auto& displayPowerMgrClient = DisplayPowerMgr::DisplayPowerMgrClient::GetInstance();
1124 if (!displayPowerMgrClient.DiscountBrightness(discount)) {
1125 HILOG_ERROR("Failed to set brightness discount");
1126 }
1127 if (accountData->GetInstalledAbilitiesFromBMS()) {
1128 accountData->UpdateImportantEnabledAbilities(importantEnabledAbilities);
1129 accountData->UpdateAbilities();
1130 UpdateAccessibilityManagerService();
1131 }
1132 }
1133
PackageRemoved(const std::string & bundleName)1134 void AccessibleAbilityManagerService::PackageRemoved(const std::string &bundleName)
1135 {
1136 sptr<AccessibilityAccountData> packageAccount = GetCurrentAccountData();
1137 if (!packageAccount) {
1138 HILOG_ERROR("packageAccount is nullptr.");
1139 return;
1140 }
1141
1142 if (packageAccount->RemoveAbility(bundleName)) {
1143 HILOG_DEBUG("ability%{public}s removed!", bundleName.c_str());
1144 UpdateAccessibilityManagerService();
1145 }
1146 }
1147
PackageAdd(const std::string & bundleName)1148 void AccessibleAbilityManagerService::PackageAdd(const std::string &bundleName)
1149 {
1150 sptr<AccessibilityAccountData> packageAccount = GetCurrentAccountData();
1151 if (!packageAccount) {
1152 HILOG_ERROR("packageAccount is nullptr");
1153 return;
1154 }
1155 packageAccount->AddAbility(bundleName);
1156 }
1157
PackageChanged(const std::string & bundleName)1158 void AccessibleAbilityManagerService::PackageChanged(const std::string &bundleName)
1159 {
1160 sptr<AccessibilityAccountData> packageAccount = GetCurrentAccountData();
1161 if (!packageAccount) {
1162 HILOG_ERROR("packageAccount is nullptr");
1163 return;
1164 }
1165 packageAccount->ChangeAbility(bundleName);
1166 }
1167
UpdateAccessibilityWindowStateByEvent(const AccessibilityEventInfo & event)1168 void AccessibleAbilityManagerService::UpdateAccessibilityWindowStateByEvent(const AccessibilityEventInfo &event)
1169 {
1170 EventType evtType = event.GetEventType();
1171 HILOG_DEBUG("windowId is %{public}d", event.GetWindowId());
1172 switch (evtType) {
1173 case TYPE_VIEW_HOVER_ENTER_EVENT:
1174 case TYPE_VIEW_ACCESSIBILITY_FOCUSED_EVENT:
1175 Singleton<AccessibilityWindowManager>::GetInstance().SetActiveWindow(event.GetWindowId());
1176 Singleton<AccessibilityWindowManager>::GetInstance().SetAccessibilityFocusedWindow(event.GetWindowId());
1177 break;
1178 default:
1179 break;
1180 }
1181 }
1182
UpdateAccessibilityManagerService()1183 void AccessibleAbilityManagerService::UpdateAccessibilityManagerService()
1184 {
1185 HILOG_DEBUG("start.");
1186
1187 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData();
1188 if (!accountData) {
1189 HILOG_ERROR("Account data is null");
1190 return;
1191 }
1192
1193 accountData->UpdateAccountCapabilities();
1194 UpdateInputFilter();
1195 UpdateAccessibilityState();
1196 }
1197
UpdateAccessibilityState()1198 void AccessibleAbilityManagerService::UpdateAccessibilityState()
1199 {
1200 HILOG_DEBUG("start.");
1201
1202 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData();
1203 if (!accountData) {
1204 HILOG_ERROR("Account data is null");
1205 return;
1206 }
1207 uint32_t state = accountData->GetAccessibilityState();
1208 if (!(state & STATE_ACCESSIBILITY_ENABLED)) {
1209 Singleton<AccessibilityWindowManager>::GetInstance().ClearAccessibilityFocused();
1210 }
1211 for (auto &callback : stateCallbacks_) {
1212 if (callback) {
1213 callback->OnStateChanged(state);
1214 }
1215 }
1216 }
1217
UpdateCaptionProperty()1218 void AccessibleAbilityManagerService::UpdateCaptionProperty()
1219 {
1220 handler_->PostTask(std::bind([this]() -> void {
1221 HILOG_DEBUG("UpdateCaptionProperty.");
1222
1223 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData();
1224 if (!accountData) {
1225 HILOG_ERROR("Account data is null");
1226 return;
1227 }
1228
1229 AccessibilityConfig::CaptionProperty caption = accountData->GetConfig()->GetCaptionProperty();
1230 for (auto &callback : accountData->GetCaptionPropertyCallbacks()) {
1231 if (callback) {
1232 callback->OnPropertyChanged(caption);
1233 }
1234 }
1235 }), "UpdateCaptionProperty");
1236 }
1237
UpdateInputFilter()1238 void AccessibleAbilityManagerService::UpdateInputFilter()
1239 {
1240 HILOG_DEBUG("start.");
1241
1242 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData();
1243 if (!accountData) {
1244 HILOG_ERROR("Account data is null");
1245 return;
1246 }
1247
1248 uint32_t flag = accountData->GetInputFilterFlag();
1249 HILOG_DEBUG("InputInterceptor flag is %{public}d", flag);
1250
1251 inputInterceptor_ = AccessibilityInputInterceptor::GetInstance();
1252 if (!inputInterceptor_) {
1253 HILOG_ERROR("inputInterceptor_ is null.");
1254 return;
1255 }
1256 inputInterceptor_->SetAvailableFunctions(flag);
1257 Utils::RecordStartingA11yEvent(flag);
1258 }
1259
SetScreenMagnificationState(const bool state)1260 RetError AccessibleAbilityManagerService::SetScreenMagnificationState(const bool state)
1261 {
1262 HILOG_INFO("state = [%{public}s]", state ? "True" : "False");
1263 if (!handler_) {
1264 HILOG_ERROR("handler_ is nullptr.");
1265 return RET_ERR_NULLPTR;
1266 }
1267
1268 std::promise<RetError> syncPromise;
1269 std::future syncFuture = syncPromise.get_future();
1270 handler_->PostTask(std::bind([this, &syncPromise, state]() -> void {
1271 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData();
1272 if (!accountData) {
1273 HILOG_ERROR("accountData is nullptr.");
1274 syncPromise.set_value(RET_ERR_NULLPTR);
1275 return;
1276 }
1277 RetError ret = accountData->GetConfig()->SetScreenMagnificationState(state);
1278 syncPromise.set_value(ret);
1279 UpdateConfigState();
1280 UpdateInputFilter();
1281 }), "TASK_SET_SCREENMAGNIFICATION_STATE");
1282 return syncFuture.get();
1283 }
1284
SetShortKeyState(const bool state)1285 RetError AccessibleAbilityManagerService::SetShortKeyState(const bool state)
1286 {
1287 HILOG_INFO("state = [%{public}s]", state ? "True" : "False");
1288 if (!handler_) {
1289 HILOG_ERROR("handler_ is nullptr.");
1290 return RET_ERR_NULLPTR;
1291 }
1292
1293 std::promise<RetError> syncPromise;
1294 std::future syncFuture = syncPromise.get_future();
1295 handler_->PostTask(std::bind([this, &syncPromise, state]() -> void {
1296 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData();
1297 if (!accountData) {
1298 HILOG_ERROR("accountData is nullptr.");
1299 syncPromise.set_value(RET_ERR_NULLPTR);
1300 return;
1301 }
1302 RetError ret = accountData->GetConfig()->SetShortKeyState(state);
1303 syncPromise.set_value(ret);
1304 UpdateConfigState();
1305 UpdateInputFilter();
1306
1307 // Disable shortkey ability
1308 if (!state) {
1309 DisableShortKeyTargetAbility();
1310 }
1311 }), "TASK_SET_SHORTKEY_STATE");
1312 return syncFuture.get();
1313 }
1314
SetMouseKeyState(const bool state)1315 RetError AccessibleAbilityManagerService::SetMouseKeyState(const bool state)
1316 {
1317 HILOG_INFO("state = [%{public}s]", state ? "True" : "False");
1318 if (!handler_) {
1319 HILOG_ERROR("handler_ is nullptr.");
1320 return RET_ERR_NULLPTR;
1321 }
1322
1323 std::promise<RetError> syncPromise;
1324 std::future syncFuture = syncPromise.get_future();
1325 handler_->PostTask(std::bind([this, &syncPromise, state]() -> void {
1326 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData();
1327 if (!accountData) {
1328 HILOG_ERROR("accountData is nullptr.");
1329 syncPromise.set_value(RET_ERR_NULLPTR);
1330 return;
1331 }
1332 RetError ret = accountData->GetConfig()->SetMouseKeyState(state);
1333 syncPromise.set_value(ret);
1334 UpdateConfigState();
1335 UpdateInputFilter();
1336 }), "TASK_SET_MOUSEKEY_STATE");
1337 return syncFuture.get();
1338 }
1339
SetMouseAutoClick(const int32_t time)1340 RetError AccessibleAbilityManagerService::SetMouseAutoClick(const int32_t time)
1341 {
1342 HILOG_INFO("time = [%{public}d]", time);
1343 if (!handler_) {
1344 HILOG_ERROR("handler_ is nullptr.");
1345 return RET_ERR_NULLPTR;
1346 }
1347
1348 std::promise<RetError> syncPromise;
1349 std::future syncFuture = syncPromise.get_future();
1350 handler_->PostTask(std::bind([this, &syncPromise, time]() -> void {
1351 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData();
1352 if (!accountData) {
1353 HILOG_ERROR("accountData is nullptr.");
1354 syncPromise.set_value(RET_ERR_NULLPTR);
1355 return;
1356 }
1357 RetError ret = accountData->GetConfig()->SetMouseAutoClick(time);
1358 syncPromise.set_value(ret);
1359 UpdateMouseAutoClick();
1360 UpdateInputFilter();
1361 }), "TASK_SET_MOUSE_AUTOCLICK");
1362 return syncFuture.get();
1363 }
1364
SetShortkeyTarget(const std::string & name)1365 RetError AccessibleAbilityManagerService::SetShortkeyTarget(const std::string &name)
1366 {
1367 HILOG_INFO("name = [%{public}s]", name.c_str());
1368 if (!handler_) {
1369 HILOG_ERROR("handler_ is nullptr.");
1370 return RET_ERR_NULLPTR;
1371 }
1372 std::promise<RetError> syncPromise;
1373 std::future syncFuture = syncPromise.get_future();
1374 handler_->PostTask(std::bind([this, &syncPromise, &name]() -> void {
1375 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData();
1376 if (!accountData) {
1377 HILOG_ERROR("accountData is nullptr.");
1378 syncPromise.set_value(RET_ERR_NULLPTR);
1379 return;
1380 }
1381 RetError ret = accountData->GetConfig()->SetShortkeyTarget(name);
1382 syncPromise.set_value(ret);
1383 UpdateShortkeyTarget();
1384 }), "TASK_SET_SHORTKEY_TARGET");
1385 return syncFuture.get();
1386 }
1387
SetHighContrastTextState(const bool state)1388 RetError AccessibleAbilityManagerService::SetHighContrastTextState(const bool state)
1389 {
1390 HILOG_INFO("state = [%{public}s]", state ? "True" : "False");
1391 if (!handler_) {
1392 HILOG_ERROR("handler_ is nullptr.");
1393 return RET_ERR_NULLPTR;
1394 }
1395
1396 std::promise<RetError> syncPromise;
1397 std::future syncFuture = syncPromise.get_future();
1398 handler_->PostTask(std::bind([this, &syncPromise, state]() -> void {
1399 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData();
1400 if (!accountData) {
1401 HILOG_ERROR("accountData is nullptr.");
1402 syncPromise.set_value(RET_ERR_NULLPTR);
1403 return;
1404 }
1405 RetError ret = accountData->GetConfig()->SetHighContrastTextState(state);
1406 syncPromise.set_value(ret);
1407 UpdateConfigState();
1408 }), "TASK_SET_HIGHCONTRASTTEXT_STATE");
1409 return syncFuture.get();
1410 }
1411
SetInvertColorState(const bool state)1412 RetError AccessibleAbilityManagerService::SetInvertColorState(const bool state)
1413 {
1414 HILOG_INFO("state = [%{public}s]", state ? "True" : "False");
1415 if (!handler_) {
1416 HILOG_ERROR("handler_ is nullptr.");
1417 return RET_ERR_NULLPTR;
1418 }
1419
1420 std::promise<RetError> syncPromise;
1421 std::future syncFuture = syncPromise.get_future();
1422 handler_->PostTask(std::bind([this, &syncPromise, state]() -> void {
1423 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData();
1424 if (!accountData) {
1425 HILOG_ERROR("accountData is nullptr.");
1426 syncPromise.set_value(RET_ERR_NULLPTR);
1427 return;
1428 }
1429 RetError ret = accountData->GetConfig()->SetInvertColorState(state);
1430 syncPromise.set_value(ret);
1431 UpdateConfigState();
1432 }), "TASK_SET_INVERTCOLOR_STATE");
1433 return syncFuture.get();
1434 }
1435
SetAnimationOffState(const bool state)1436 RetError AccessibleAbilityManagerService::SetAnimationOffState(const bool state)
1437 {
1438 HILOG_INFO("state = [%{public}s]", state ? "True" : "False");
1439 if (!handler_) {
1440 HILOG_ERROR("handler_ is nullptr.");
1441 return RET_ERR_NULLPTR;
1442 }
1443
1444 std::promise<RetError> syncPromise;
1445 std::future syncFuture = syncPromise.get_future();
1446 handler_->PostTask(std::bind([this, &syncPromise, state]() -> void {
1447 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData();
1448 if (!accountData) {
1449 HILOG_ERROR("accountData is nullptr.");
1450 syncPromise.set_value(RET_ERR_NULLPTR);
1451 return;
1452 }
1453 RetError ret = accountData->GetConfig()->SetAnimationOffState(state);
1454 syncPromise.set_value(ret);
1455 UpdateConfigState();
1456 }), "TASK_SET_ANIMATIONOFF_STATE");
1457 RetError ret = syncFuture.get();
1458 int setGraphicParamRes = -1;
1459 int setArkuiParamRes = -1;
1460 if (state) {
1461 setGraphicParamRes = SetParameter(GRAPHIC_ANIMATION_SCALE_NAME.c_str(), "0");
1462 setArkuiParamRes = SetParameter(ARKUI_ANIMATION_SCALE_NAME.c_str(), "0");
1463 } else {
1464 setGraphicParamRes = SetParameter(GRAPHIC_ANIMATION_SCALE_NAME.c_str(), "1");
1465 setArkuiParamRes = SetParameter(ARKUI_ANIMATION_SCALE_NAME.c_str(), "1");
1466 }
1467 HILOG_INFO("SetParameter results are %{public}d and %{public}d", setGraphicParamRes, setArkuiParamRes);
1468 return ret;
1469 }
1470
SetAudioMonoState(const bool state)1471 RetError AccessibleAbilityManagerService::SetAudioMonoState(const bool state)
1472 {
1473 HILOG_INFO("state = [%{public}s]", state ? "True" : "False");
1474 if (!handler_) {
1475 HILOG_ERROR("handler_ is nullptr.");
1476 return RET_ERR_NULLPTR;
1477 }
1478
1479 std::promise<RetError> syncPromise;
1480 std::future syncFuture = syncPromise.get_future();
1481 handler_->PostTask(std::bind([this, &syncPromise, state]() -> void {
1482 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData();
1483 if (!accountData) {
1484 HILOG_ERROR("accountData is nullptr.");
1485 syncPromise.set_value(RET_ERR_NULLPTR);
1486 return;
1487 }
1488 RetError ret = accountData->GetConfig()->SetAudioMonoState(state);
1489 syncPromise.set_value(ret);
1490 UpdateConfigState();
1491 }), "TASK_SET_AUDIOMONO_STATE");
1492 return syncFuture.get();
1493 }
1494
SetDaltonizationColorFilter(const uint32_t filter)1495 RetError AccessibleAbilityManagerService::SetDaltonizationColorFilter(const uint32_t filter)
1496 {
1497 HILOG_INFO("filter = [%{public}u]", filter);
1498 if (!handler_) {
1499 HILOG_ERROR("handler_ is nullptr.");
1500 return RET_ERR_NULLPTR;
1501 }
1502
1503 std::promise<RetError> syncPromise;
1504 std::future syncFuture = syncPromise.get_future();
1505 handler_->PostTask(std::bind([this, &syncPromise, filter]() -> void {
1506 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData();
1507 if (!accountData) {
1508 HILOG_ERROR("accountData is nullptr.");
1509 syncPromise.set_value(RET_ERR_NULLPTR);
1510 return;
1511 }
1512 RetError ret = accountData->GetConfig()->SetDaltonizationColorFilter(filter);
1513 syncPromise.set_value(ret);
1514 UpdateDaltonizationColorFilter();
1515 }), "TASK_SET_DALTONIZATION_COLORFILTER");
1516 return syncFuture.get();
1517 }
1518
SetContentTimeout(const uint32_t time)1519 RetError AccessibleAbilityManagerService::SetContentTimeout(const uint32_t time)
1520 {
1521 HILOG_INFO("time = [%{public}u]", time);
1522 if (!handler_) {
1523 HILOG_ERROR("handler_ is nullptr.");
1524 return RET_ERR_NULLPTR;
1525 }
1526
1527 std::promise<RetError> syncPromise;
1528 std::future syncFuture = syncPromise.get_future();
1529 handler_->PostTask(std::bind([this, &syncPromise, time]() -> void {
1530 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData();
1531 if (!accountData) {
1532 HILOG_ERROR("accountData is nullptr.");
1533 syncPromise.set_value(RET_ERR_NULLPTR);
1534 return;
1535 }
1536 RetError ret = accountData->GetConfig()->SetContentTimeout(time);
1537 syncPromise.set_value(ret);
1538 UpdateContentTimeout();
1539 }), "TASK_SET_CONTENT_TIMEOUT");
1540 return syncFuture.get();
1541 }
1542
SetBrightnessDiscount(const float discount)1543 RetError AccessibleAbilityManagerService::SetBrightnessDiscount(const float discount)
1544 {
1545 HILOG_INFO("discount = [%{public}f]", discount);
1546 if (!handler_) {
1547 HILOG_ERROR("handler_ is nullptr.");
1548 return RET_ERR_NULLPTR;
1549 }
1550 auto& displayPowerMgrClient = DisplayPowerMgr::DisplayPowerMgrClient::GetInstance();
1551 if (!displayPowerMgrClient.DiscountBrightness(discount)) {
1552 HILOG_ERROR("Failed to set brightness discount");
1553 return Accessibility::RET_ERR_FAILED;
1554 }
1555 std::promise<RetError> syncPromise;
1556 std::future syncFuture = syncPromise.get_future();
1557 handler_->PostTask(std::bind([this, &syncPromise, discount]() -> void {
1558 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData();
1559 if (!accountData) {
1560 HILOG_ERROR("accountData is nullptr.");
1561 syncPromise.set_value(RET_ERR_NULLPTR);
1562 return;
1563 }
1564 RetError ret = accountData->GetConfig()->SetBrightnessDiscount(discount);
1565 syncPromise.set_value(ret);
1566 UpdateBrightnessDiscount();
1567 }), "TASK_SET_BRIGHTNESS_DISCOUNT");
1568 return syncFuture.get();
1569 }
1570
SetAudioBalance(const float balance)1571 RetError AccessibleAbilityManagerService::SetAudioBalance(const float balance)
1572 {
1573 HILOG_INFO("balance = [%{public}f]", balance);
1574 if (!handler_) {
1575 HILOG_ERROR("handler_ is nullptr.");
1576 return RET_ERR_NULLPTR;
1577 }
1578
1579 std::promise<RetError> syncPromise;
1580 std::future syncFuture = syncPromise.get_future();
1581 handler_->PostTask(std::bind([this, &syncPromise, balance]() -> void {
1582 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData();
1583 if (!accountData) {
1584 HILOG_ERROR("accountData is nullptr.");
1585 syncPromise.set_value(RET_ERR_NULLPTR);
1586 return;
1587 }
1588 RetError ret = accountData->GetConfig()->SetAudioBalance(balance);
1589 syncPromise.set_value(ret);
1590 UpdateAudioBalance();
1591 }), "TASK_SET_AUDIO_BALANCE");
1592 return syncFuture.get();
1593 }
1594
GetScreenMagnificationState(bool & state)1595 RetError AccessibleAbilityManagerService::GetScreenMagnificationState(bool &state)
1596 {
1597 HILOG_DEBUG();
1598 if (!handler_) {
1599 HILOG_ERROR("handler_ is nullptr.");
1600 return RET_ERR_NULLPTR;
1601 }
1602
1603 std::promise<RetError> syncPromise;
1604 std::future syncFuture = syncPromise.get_future();
1605 handler_->PostTask(std::bind([this, &syncPromise, &state]() -> void {
1606 HILOG_DEBUG();
1607 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData();
1608 if (!accountData) {
1609 HILOG_ERROR("accountData is nullptr");
1610 syncPromise.set_value(RET_ERR_NULLPTR);
1611 return;
1612 }
1613 state = accountData->GetConfig()->GetScreenMagnificationState();
1614 syncPromise.set_value(RET_OK);
1615 }), "TASK_GET_SCREENMAGNIFIER_STATE");
1616 return syncFuture.get();
1617 }
1618
GetShortKeyState(bool & state)1619 RetError AccessibleAbilityManagerService::GetShortKeyState(bool &state)
1620 {
1621 HILOG_DEBUG();
1622 if (!handler_) {
1623 HILOG_ERROR("handler_ is nullptr.");
1624 return RET_ERR_NULLPTR;
1625 }
1626
1627 std::promise<RetError> syncPromise;
1628 std::future syncFuture = syncPromise.get_future();
1629 handler_->PostTask(std::bind([this, &syncPromise, &state]() -> void {
1630 HILOG_DEBUG();
1631 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData();
1632 if (!accountData) {
1633 HILOG_ERROR("accountData is nullptr");
1634 syncPromise.set_value(RET_ERR_NULLPTR);
1635 return;
1636 }
1637 state = accountData->GetConfig()->GetShortKeyState();
1638 syncPromise.set_value(RET_OK);
1639 }), "TASK_GET_SHORTKEY_STATE");
1640 return syncFuture.get();
1641 }
1642
GetMouseKeyState(bool & state)1643 RetError AccessibleAbilityManagerService::GetMouseKeyState(bool &state)
1644 {
1645 HILOG_DEBUG();
1646 if (!handler_) {
1647 HILOG_ERROR("handler_ is nullptr.");
1648 return RET_ERR_NULLPTR;
1649 }
1650
1651 std::promise<RetError> syncPromise;
1652 std::future syncFuture = syncPromise.get_future();
1653 handler_->PostTask(std::bind([this, &syncPromise, &state]() -> void {
1654 HILOG_DEBUG();
1655 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData();
1656 if (!accountData) {
1657 HILOG_ERROR("accountData is nullptr");
1658 syncPromise.set_value(RET_ERR_NULLPTR);
1659 return;
1660 }
1661 state = accountData->GetConfig()->GetMouseKeyState();
1662 syncPromise.set_value(RET_OK);
1663 }), "TASK_GET_MOUSEKEY_STATE");
1664 return syncFuture.get();
1665 }
1666
GetMouseAutoClick(int32_t & time)1667 RetError AccessibleAbilityManagerService::GetMouseAutoClick(int32_t &time)
1668 {
1669 HILOG_DEBUG();
1670 std::promise<RetError> syncPromise;
1671 std::future syncFuture = syncPromise.get_future();
1672 handler_->PostTask(std::bind([this, &syncPromise, &time]() -> void {
1673 HILOG_DEBUG();
1674 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData();
1675 if (!accountData) {
1676 HILOG_ERROR("accountData is nullptr");
1677 syncPromise.set_value(RET_ERR_NULLPTR);
1678 return;
1679 }
1680 time = accountData->GetConfig()->GetMouseAutoClick();
1681 syncPromise.set_value(RET_OK);
1682 }), "TASK_GET_MOUSE_AUTOCLICK");
1683
1684 return syncFuture.get();
1685 }
1686
GetShortkeyTarget(std::string & name)1687 RetError AccessibleAbilityManagerService::GetShortkeyTarget(std::string &name)
1688 {
1689 HILOG_DEBUG();
1690 std::promise<RetError> syncPromise;
1691 std::future syncFuture = syncPromise.get_future();
1692 handler_->PostTask(std::bind([this, &syncPromise, &name]() -> void {
1693 HILOG_DEBUG();
1694 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData();
1695 if (!accountData) {
1696 HILOG_ERROR("accountData is nullptr");
1697 syncPromise.set_value(RET_ERR_NULLPTR);
1698 return;
1699 }
1700 name = accountData->GetConfig()->GetShortkeyTarget();
1701 syncPromise.set_value(RET_OK);
1702 }), "TASK_GET_SHORTKEY_TARGET");
1703
1704 return syncFuture.get();
1705 }
1706
GetHighContrastTextState(bool & state)1707 RetError AccessibleAbilityManagerService::GetHighContrastTextState(bool &state)
1708 {
1709 HILOG_DEBUG();
1710 std::promise<RetError> syncPromise;
1711 std::future syncFuture = syncPromise.get_future();
1712 handler_->PostTask(std::bind([this, &syncPromise, &state]() -> void {
1713 HILOG_DEBUG();
1714 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData();
1715 if (!accountData) {
1716 HILOG_ERROR("accountData is nullptr");
1717 syncPromise.set_value(RET_ERR_NULLPTR);
1718 return;
1719 }
1720 state = accountData->GetConfig()->GetHighContrastTextState();
1721 syncPromise.set_value(RET_OK);
1722 }), "TASK_GET_HIGHCONTRASTTEXT_STATE");
1723
1724 return syncFuture.get();
1725 }
1726
GetInvertColorState(bool & state)1727 RetError AccessibleAbilityManagerService::GetInvertColorState(bool &state)
1728 {
1729 HILOG_DEBUG();
1730 std::promise<RetError> syncPromise;
1731 std::future syncFuture = syncPromise.get_future();
1732 handler_->PostTask(std::bind([this, &syncPromise, &state]() -> void {
1733 HILOG_DEBUG();
1734 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData();
1735 if (!accountData) {
1736 HILOG_ERROR("accountData is nullptr");
1737 syncPromise.set_value(RET_ERR_NULLPTR);
1738 return;
1739 }
1740 state = accountData->GetConfig()->GetInvertColorState();
1741 syncPromise.set_value(RET_OK);
1742 }), "TASK_GET_INVERTCOLOR_STATE");
1743
1744 return syncFuture.get();
1745 }
1746
GetAnimationOffState(bool & state)1747 RetError AccessibleAbilityManagerService::GetAnimationOffState(bool &state)
1748 {
1749 HILOG_DEBUG();
1750 std::promise<RetError> syncPromise;
1751 std::future syncFuture = syncPromise.get_future();
1752 handler_->PostTask(std::bind([this, &syncPromise, &state]() -> void {
1753 HILOG_DEBUG();
1754 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData();
1755 if (!accountData) {
1756 HILOG_ERROR("accountData is nullptr");
1757 syncPromise.set_value(RET_ERR_NULLPTR);
1758 return;
1759 }
1760 state = accountData->GetConfig()->GetAnimationOffState();
1761 syncPromise.set_value(RET_OK);
1762 }), "TASK_GET_ANIMATIONOFF_STATE");
1763
1764 return syncFuture.get();
1765 }
1766
GetAudioMonoState(bool & state)1767 RetError AccessibleAbilityManagerService::GetAudioMonoState(bool &state)
1768 {
1769 HILOG_DEBUG();
1770 std::promise<RetError> syncPromise;
1771 std::future syncFuture = syncPromise.get_future();
1772 handler_->PostTask(std::bind([this, &syncPromise, &state]() -> void {
1773 HILOG_DEBUG();
1774 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData();
1775 if (!accountData) {
1776 HILOG_ERROR("accountData is nullptr");
1777 syncPromise.set_value(RET_ERR_NULLPTR);
1778 return;
1779 }
1780 state = accountData->GetConfig()->GetAudioMonoState();
1781 syncPromise.set_value(RET_OK);
1782 }), "TASK_GET_AUDIOMONO_STATE");
1783
1784 return syncFuture.get();
1785 }
1786
GetDaltonizationColorFilter(uint32_t & type)1787 RetError AccessibleAbilityManagerService::GetDaltonizationColorFilter(uint32_t &type)
1788 {
1789 HILOG_DEBUG();
1790 std::promise<RetError> syncPromise;
1791 std::future syncFuture = syncPromise.get_future();
1792 handler_->PostTask(std::bind([this, &syncPromise, &type]() -> void {
1793 HILOG_DEBUG();
1794 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData();
1795 if (!accountData) {
1796 HILOG_ERROR("accountData is nullptr");
1797 syncPromise.set_value(RET_ERR_NULLPTR);
1798 return;
1799 }
1800 type = accountData->GetConfig()->GetDaltonizationColorFilter();
1801 syncPromise.set_value(RET_OK);
1802 }), "TASK_GET_DALTONIZATION_COLORFILTER");
1803
1804 return syncFuture.get();
1805 }
1806
GetContentTimeout(uint32_t & timer)1807 RetError AccessibleAbilityManagerService::GetContentTimeout(uint32_t &timer)
1808 {
1809 HILOG_DEBUG();
1810 std::promise<RetError> syncPromise;
1811 std::future syncFuture = syncPromise.get_future();
1812 handler_->PostTask(std::bind([this, &syncPromise, &timer]() -> void {
1813 HILOG_DEBUG();
1814 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData();
1815 if (!accountData) {
1816 HILOG_ERROR("accountData is nullptr");
1817 syncPromise.set_value(RET_ERR_NULLPTR);
1818 return;
1819 }
1820 timer = accountData->GetConfig()->GetContentTimeout();
1821 syncPromise.set_value(RET_OK);
1822 }), "TASK_GET_CONTENT_TIMEOUT");
1823
1824 return syncFuture.get();
1825 }
1826
GetBrightnessDiscount(float & brightness)1827 RetError AccessibleAbilityManagerService::GetBrightnessDiscount(float &brightness)
1828 {
1829 HILOG_DEBUG();
1830 std::promise<RetError> syncPromise;
1831 std::future syncFuture = syncPromise.get_future();
1832 handler_->PostTask(std::bind([this, &syncPromise, &brightness]() -> void {
1833 HILOG_DEBUG();
1834 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData();
1835 if (!accountData) {
1836 HILOG_ERROR("accountData is nullptr");
1837 syncPromise.set_value(RET_ERR_NULLPTR);
1838 return;
1839 }
1840 brightness = accountData->GetConfig()->GetBrightnessDiscount();
1841 syncPromise.set_value(RET_OK);
1842 }), "TASK_GET_BRIGHTNESS_DISCOUNT");
1843
1844 return syncFuture.get();
1845 }
1846
GetAudioBalance(float & balance)1847 RetError AccessibleAbilityManagerService::GetAudioBalance(float &balance)
1848 {
1849 HILOG_DEBUG();
1850 std::promise<RetError> syncPromise;
1851 std::future syncFuture = syncPromise.get_future();
1852 handler_->PostTask(std::bind([this, &syncPromise, &balance]() -> void {
1853 HILOG_DEBUG();
1854 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData();
1855 if (!accountData) {
1856 HILOG_ERROR("accountData is nullptr");
1857 syncPromise.set_value(RET_ERR_NULLPTR);
1858 return;
1859 }
1860 balance = accountData->GetConfig()->GetAudioBalance();
1861 syncPromise.set_value(RET_OK);
1862 }), "TASK_GET_AUDIO_BALANCE");
1863
1864 return syncFuture.get();
1865 }
1866
GetAllConfigs(AccessibilityConfigData & configData)1867 void AccessibleAbilityManagerService::GetAllConfigs(AccessibilityConfigData &configData)
1868 {
1869 HILOG_DEBUG();
1870 std::promise<void> syncPromise;
1871 std::future syncFuture = syncPromise.get_future();
1872 handler_->PostTask(std::bind([this, &syncPromise, &configData]() -> void {
1873 HILOG_DEBUG();
1874 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData();
1875 if (!accountData) {
1876 HILOG_ERROR("accountData is nullptr");
1877 syncPromise.set_value();
1878 return;
1879 }
1880
1881 configData.highContrastText_ = accountData->GetConfig()->GetHighContrastTextState();
1882 configData.invertColor_ = accountData->GetConfig()->GetInvertColorState();
1883 configData.animationOff_ = accountData->GetConfig()->GetAnimationOffState();
1884 configData.audioMono_ = accountData->GetConfig()->GetAudioMonoState();
1885 configData.mouseKey_ = accountData->GetConfig()->GetMouseKeyState();
1886 configData.captionState_ = accountData->GetConfig()->GetCaptionState();
1887 configData.screenMagnifier_ = accountData->GetConfig()->GetScreenMagnificationState();
1888 configData.shortkey_ = accountData->GetConfig()->GetShortKeyState();
1889 configData.mouseAutoClick_ = accountData->GetConfig()->GetMouseAutoClick();
1890 configData.daltonizationColorFilter_ = accountData->GetConfig()->GetDaltonizationColorFilter();
1891 configData.contentTimeout_ = accountData->GetConfig()->GetContentTimeout();
1892 configData.brightnessDiscount_ = accountData->GetConfig()->GetBrightnessDiscount();
1893 configData.audioBalance_ = accountData->GetConfig()->GetAudioBalance();
1894 configData.shortkeyTarget_ = accountData->GetConfig()->GetShortkeyTarget();
1895 configData.captionProperty_ = accountData->GetConfig()->GetCaptionProperty();
1896 syncPromise.set_value();
1897 }), "TASK_GET_ALL_CONFIGS");
1898
1899 return syncFuture.get();
1900 }
1901
EnableShortKeyTargetAbility()1902 bool AccessibleAbilityManagerService::EnableShortKeyTargetAbility()
1903 {
1904 HILOG_DEBUG();
1905 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData();
1906 if (!accountData) {
1907 HILOG_ERROR("accountData is nullptr");
1908 return false;
1909 }
1910
1911 std::string targetAbility = accountData->GetConfig()->GetShortkeyTarget();
1912 HILOG_DEBUG("target ability is [%{public}s]", targetAbility.c_str());
1913 if (targetAbility == "") {
1914 HILOG_ERROR("target ability is null");
1915 return false;
1916 }
1917 uint32_t capabilities = CAPABILITY_GESTURE | CAPABILITY_KEY_EVENT_OBSERVER | CAPABILITY_RETRIEVE |
1918 CAPABILITY_TOUCH_GUIDE | CAPABILITY_ZOOM;
1919 return InnerEnableAbility(targetAbility, capabilities) == RET_OK;
1920 }
1921
DisableShortKeyTargetAbility()1922 bool AccessibleAbilityManagerService::DisableShortKeyTargetAbility()
1923 {
1924 HILOG_DEBUG();
1925 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData();
1926 if (!accountData) {
1927 HILOG_ERROR("accountData is nullptr");
1928 return false;
1929 }
1930
1931 std::string targetAbility = accountData->GetConfig()->GetShortkeyTarget();
1932 HILOG_DEBUG("target ability is [%{public}s]", targetAbility.c_str());
1933 if (targetAbility == "") {
1934 HILOG_ERROR("target ability is null");
1935 return false;
1936 }
1937 return InnerDisableAbility(targetAbility) == RET_OK;
1938 }
1939
RegisterConfigObserver(const sptr<IAccessibleAbilityManagerConfigObserver> & callback)1940 uint32_t AccessibleAbilityManagerService::RegisterConfigObserver(
1941 const sptr<IAccessibleAbilityManagerConfigObserver> &callback)
1942 {
1943 HILOG_DEBUG();
1944 if (!callback || !handler_) {
1945 HILOG_ERROR("Parameters check failed! callback:%{public}p, handler:%{public}p",
1946 callback.GetRefPtr(), handler_.get());
1947 return ERR_INVALID_VALUE;
1948 }
1949
1950 std::promise<uint32_t> syncPromise;
1951 std::future syncFuture = syncPromise.get_future();
1952 handler_->PostTask(std::bind([this, &syncPromise, callback]() -> void {
1953 HILOG_DEBUG();
1954 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData();
1955 if (!accountData) {
1956 HILOG_ERROR("Account data is null");
1957 syncPromise.set_value(ERR_INVALID_VALUE);
1958 return;
1959 }
1960 if (!configCallbackDeathRecipient_) {
1961 configCallbackDeathRecipient_ = new(std::nothrow) ConfigCallbackDeathRecipient();
1962 if (!configCallbackDeathRecipient_) {
1963 HILOG_ERROR("configCallbackDeathRecipient_ is null");
1964 syncPromise.set_value(ERR_INVALID_VALUE);
1965 return;
1966 }
1967 }
1968 if (!callback->AsObject()) {
1969 HILOG_ERROR("object is null");
1970 syncPromise.set_value(0);
1971 return;
1972 }
1973 callback->AsObject()->AddDeathRecipient(configCallbackDeathRecipient_);
1974 accountData->AddConfigCallback(callback);
1975 HILOG_DEBUG("the size of caption property callbacks is %{public}zu",
1976 accountData->GetConfigCallbacks().size());
1977 syncPromise.set_value(NO_ERROR);
1978 }), "TASK_REGISTER_CONFIG_OBSERVER");
1979 return syncFuture.get();
1980 }
1981
OnRemoteDied(const wptr<IRemoteObject> & remote)1982 void AccessibleAbilityManagerService::ConfigCallbackDeathRecipient::OnRemoteDied(
1983 const wptr<IRemoteObject> &remote)
1984 {
1985 Singleton<AccessibleAbilityManagerService>::GetInstance().RemoveCallback(CONFIG_CALLBACK, this, remote);
1986 }
1987
OnRemoteDied(const wptr<IRemoteObject> & remote)1988 void AccessibleAbilityManagerService::BundleManagerDeathRecipient::OnRemoteDied(
1989 const wptr<IRemoteObject> &remote)
1990 {
1991 Singleton<AccessibleAbilityManagerService>::GetInstance().OnBundleManagerDied(remote);
1992 }
1993
UpdateConfigState()1994 void AccessibleAbilityManagerService::UpdateConfigState()
1995 {
1996 handler_->PostTask(std::bind([this]() -> void {
1997 HILOG_INFO("UpdateConfigState.");
1998 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData();
1999 if (!accountData) {
2000 HILOG_ERROR("Account data is null");
2001 return;
2002 }
2003
2004 uint32_t state = accountData->GetConfig()->GetConfigState();
2005 for (auto &callback : accountData->GetConfigCallbacks()) {
2006 if (callback) {
2007 callback->OnConfigStateChanged(state);
2008 }
2009 }
2010 }), "UpdateConfigState");
2011 }
2012
UpdateAudioBalance()2013 void AccessibleAbilityManagerService::UpdateAudioBalance()
2014 {
2015 handler_->PostTask(std::bind([this]() -> void {
2016 HILOG_INFO("UpdateAudioBalance.");
2017 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData();
2018 if (!accountData) {
2019 HILOG_ERROR("Account data is null");
2020 return;
2021 }
2022
2023 float audioBalance = accountData->GetConfig()->GetAudioBalance();
2024 for (auto &callback : accountData->GetConfigCallbacks()) {
2025 if (callback) {
2026 callback->OnAudioBalanceChanged(audioBalance);
2027 }
2028 }
2029 }), "UpdateAudioBalance");
2030 }
2031
UpdateBrightnessDiscount()2032 void AccessibleAbilityManagerService::UpdateBrightnessDiscount()
2033 {
2034 handler_->PostTask(std::bind([this]() -> void {
2035 HILOG_INFO("UpdateBrightnessDiscount.");
2036 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData();
2037 if (!accountData) {
2038 HILOG_ERROR("Account data is null");
2039 return;
2040 }
2041
2042 float brightnessDiscount = accountData->GetConfig()->GetBrightnessDiscount();
2043 for (auto &callback : accountData->GetConfigCallbacks()) {
2044 if (callback) {
2045 callback->OnBrightnessDiscountChanged(brightnessDiscount);
2046 }
2047 }
2048 }), "UpdateBrightnessDiscount");
2049 }
2050
UpdateContentTimeout()2051 void AccessibleAbilityManagerService::UpdateContentTimeout()
2052 {
2053 handler_->PostTask(std::bind([this]() -> void {
2054 HILOG_INFO("UpdateContentTimeout.");
2055 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData();
2056 if (!accountData) {
2057 HILOG_ERROR("Account data is null");
2058 return;
2059 }
2060
2061 uint32_t contentTimeout = accountData->GetConfig()->GetContentTimeout();
2062 for (auto &callback : accountData->GetConfigCallbacks()) {
2063 if (callback) {
2064 callback->OnContentTimeoutChanged(contentTimeout);
2065 }
2066 }
2067 }), "UpdateContentTimeout");
2068 }
2069
UpdateDaltonizationColorFilter()2070 void AccessibleAbilityManagerService::UpdateDaltonizationColorFilter()
2071 {
2072 handler_->PostTask(std::bind([this]() -> void {
2073 HILOG_INFO("UpdateDaltonizationColorFilter.");
2074 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData();
2075 if (!accountData) {
2076 HILOG_ERROR("Account data is null");
2077 return;
2078 }
2079
2080 uint32_t daltonizationColorFilter = accountData->GetConfig()->GetDaltonizationColorFilter();
2081 for (auto &callback : accountData->GetConfigCallbacks()) {
2082 if (callback) {
2083 callback->OnDaltonizationColorFilterChanged(daltonizationColorFilter);
2084 }
2085 }
2086 }), "UpdateDaltonizationColorFilter");
2087 }
2088
UpdateMouseAutoClick()2089 void AccessibleAbilityManagerService::UpdateMouseAutoClick()
2090 {
2091 handler_->PostTask(std::bind([this]() -> void {
2092 HILOG_INFO("UpdateMouseAutoClick.");
2093 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData();
2094 if (!accountData) {
2095 HILOG_ERROR("Account data is null");
2096 return;
2097 }
2098
2099 int32_t mouseAutoClick = accountData->GetConfig()->GetMouseAutoClick();
2100 for (auto &callback : accountData->GetConfigCallbacks()) {
2101 if (callback) {
2102 callback->OnMouseAutoClickChanged(mouseAutoClick);
2103 }
2104 }
2105 }), "UpdateMouseAutoClick");
2106 }
2107
UpdateShortkeyTarget()2108 void AccessibleAbilityManagerService::UpdateShortkeyTarget()
2109 {
2110 handler_->PostTask(std::bind([this]() -> void {
2111 HILOG_INFO("UpdateShortkeyTarget.");
2112 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData();
2113 if (!accountData) {
2114 HILOG_ERROR("Account data is null");
2115 return;
2116 }
2117
2118 std::string shortkeyTarget = accountData->GetConfig()->GetShortkeyTarget();
2119 for (auto &callback : accountData->GetConfigCallbacks()) {
2120 if (callback) {
2121 callback->OnShortkeyTargetChanged(shortkeyTarget);
2122 }
2123 }
2124 }), "UpdateShortkeyTarget");
2125 }
2126
RemoveCallback(CallBackID callback,const sptr<DeathRecipient> & recipient,const wptr<IRemoteObject> & remote)2127 void AccessibleAbilityManagerService::RemoveCallback(CallBackID callback,
2128 const sptr<DeathRecipient> &recipient, const wptr<IRemoteObject> &remote)
2129 {
2130 HILOG_INFO("remove callback[%{public}d]", callback);
2131 if (!handler_) {
2132 HILOG_ERROR("handler is nullptr");
2133 return;
2134 }
2135 handler_->PostTask(std::bind([=]() -> void {
2136 if (!remote.GetRefPtr()) {
2137 HILOG_ERROR("remote is null");
2138 return;
2139 }
2140 remote->RemoveDeathRecipient(recipient);
2141
2142 auto accountData = GetCurrentAccountData();
2143 if (!accountData) {
2144 HILOG_ERROR("Current account data is null");
2145 return;
2146 }
2147 switch (callback) {
2148 case STATE_CALLBACK:
2149 {
2150 auto iter = std::find_if(stateCallbacks_.begin(), stateCallbacks_.end(),
2151 [remote](const sptr<IAccessibleAbilityManagerStateObserver> &stateCallback) {
2152 return stateCallback->AsObject() == remote;
2153 });
2154 if (iter != stateCallbacks_.end()) {
2155 stateCallbacks_.erase(iter);
2156 }
2157 }
2158 break;
2159 case CAPTION_PROPERTY_CALLBACK:
2160 accountData->RemoveCaptionPropertyCallback(remote);
2161 break;
2162 case ENABLE_ABILITY_LISTS_CALLBACK:
2163 accountData->RemoveEnableAbilityListsObserver(remote);
2164 break;
2165 case CONFIG_CALLBACK:
2166 accountData->RemoveConfigCallback(remote);
2167 break;
2168 default:
2169 break;
2170 }
2171 }), "RemoveCallback");
2172 }
2173
OnBundleManagerDied(const wptr<IRemoteObject> & remote)2174 void AccessibleAbilityManagerService::OnBundleManagerDied(const wptr<IRemoteObject> &remote)
2175 {
2176 HILOG_INFO("OnBundleManagerDied ");
2177 if (!handler_) {
2178 HILOG_ERROR("handler is nullptr");
2179 return;
2180 }
2181
2182 handler_->PostTask(std::bind([=]() -> void {
2183 if (!remote.GetRefPtr() || !bundleManager_) {
2184 HILOG_ERROR("remote is null");
2185 return;
2186 }
2187
2188 bundleManager_->AsObject()->RemoveDeathRecipient(bundleManagerDeathRecipient_);
2189 bundleManager_ = nullptr;
2190 }), "OnBundleManagerDied");
2191 }
2192 } // namespace Accessibility
2193 } // namespace OHOS