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