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 <cinttypes> 19#include <new> 20#include <string> 21#include <unistd.h> 22#include <functional> 23#ifdef OHOS_BUILD_ENABLE_HITRACE 24#include <hitrace_meter.h> 25#endif // OHOS_BUILD_ENABLE_HITRACE 26 27#include "ability_info.h" 28#include "accessibility_event_info.h" 29#ifdef OHOS_BUILD_ENABLE_POWER_MANAGER 30#include "accessibility_power_manager.h" 31#endif 32#include "accessibility_short_key_dialog.h" 33#include "accessibility_window_manager.h" 34#include "hilog_wrapper.h" 35#include "input_manager.h" 36#include "iservice_registry.h" 37#include "os_account_manager.h" 38#include "parameter.h" 39#include "system_ability_definition.h" 40#include "utils.h" 41#include "xcollie_helper.h" 42#include <ipc_skeleton.h> 43#include "transaction/rs_interfaces.h" 44 45using namespace std; 46 47namespace OHOS { 48namespace Accessibility { 49namespace { 50 const std::string AAMS_SERVICE_NAME = "AccessibleAbilityManagerService"; 51 const std::string AAMS_ACTION_RUNNER_NAME = "AamsActionRunner"; 52 const std::string UI_TEST_BUNDLE_NAME = "ohos.uitest"; 53 const std::string UI_TEST_ABILITY_NAME = "uitestability"; 54 const std::string SYSTEM_PARAMETER_AAMS_NAME = "accessibility.config.ready"; 55 const std::string GRAPHIC_ANIMATION_SCALE_NAME = "persist.sys.graphic.animationscale"; 56 const std::string ARKUI_ANIMATION_SCALE_NAME = "persist.sys.arkui.animationscale"; 57 const std::string SCREEN_READER_BUNDLE_ABILITY_NAME = "com.huawei.hmos.screenreader/AccessibilityExtAbility"; 58 const std::string DEVICE_PROVISIONED = "device_provisioned"; 59 const std::string SCREEN_MAGNIFICATION_KEY = "accessibility_display_magnification_enabled"; 60 const std::string SCREEN_MAGNIFICATION_TYPE = "accessibility_magnification_capability"; 61 const std::string DELAY_UNLOAD_TASK = "TASK_UNLOAD_ACCESSIBILITY_SA"; 62 const std::string USER_SETUP_COMPLETED = "user_setup_complete"; 63 const std::string ACCESSIBILITY_CLONE_FLAG = "accessibility_config_clone"; 64 const std::string SHORTCUT_ENABLED = "accessibility_shortcut_enabled"; 65 constexpr int32_t INVALID_SHORTCUT_STATE = 2; 66 constexpr int32_t QUERY_USER_ID_RETRY_COUNT = 600; 67 constexpr int32_t QUERY_USER_ID_SLEEP_TIME = 50; 68 constexpr uint32_t TIME_OUT_OPERATOR = 5000; 69 constexpr int32_t REQUEST_ID_MAX = 0xFFFFFFFF; 70 constexpr int32_t REQUEST_ID_MIN = 0x0000FFFF; 71 constexpr int32_t DEFAULT_ACCOUNT_ID = 100; 72 constexpr int32_t ROOT_UID = 0; 73 constexpr int32_t UNLOAD_TASK_INTERNAL = 3 * 60 * 1000; // ms 74 constexpr int32_t TREE_ID_INVALID = 0; 75 constexpr uint32_t ELEMENT_MOVE_BIT = 40; 76 constexpr int32_t SINGLE_TREE_ID = 0; 77 constexpr int32_t TREE_ID_MAX = 0x00001FFF; 78 constexpr int32_t SHORT_KEY_TIMEOUT_BEFORE_USE = 3000; // ms 79 constexpr int32_t SHORT_KEY_TIMEOUT_AFTER_USE = 1000; // ms 80 constexpr int32_t WINDOW_ID_INVALID = -1; 81 constexpr int64_t ELEMENT_ID_INVALID = -1; 82 enum SCREENREADER_STATE : int32_t { 83 UNINIT = -1, 84 OFF = 0, 85 ON = 1, 86 }; 87 const std::string TIMER_REGISTER_STATE_OBSERVER = "accessibility:registerStateObServer"; 88 const std::string TIMER_REGISTER_CAPTION_OBSERVER = "accessibility:registerCaptionObServer"; 89 const std::string TIMER_REGISTER_ENABLEABILITY_OBSERVER = "accessibility:registerEnableAbilityObServer"; 90 const std::string TIMER_GET_ALL_CONFIG = "accessibility:getAllConfig"; 91 const std::string TIMER_REGISTER_CONFIG_OBSERVER = "accessibility:registerConfigObserver"; 92 constexpr int32_t XCOLLIE_TIMEOUT = 6; // s 93} // namespace 94 95const bool REGISTER_RESULT = 96 SystemAbility::MakeAndRegisterAbility(&Singleton<AccessibleAbilityManagerService>::GetInstance()); 97 98AccessibleAbilityManagerService::AccessibleAbilityManagerService() 99 : SystemAbility(ACCESSIBILITY_MANAGER_SERVICE_ID, true) 100{ 101 HILOG_INFO("AccessibleAbilityManagerService is constructed"); 102 dependentServicesStatus_[ABILITY_MGR_SERVICE_ID] = false; 103 dependentServicesStatus_[BUNDLE_MGR_SERVICE_SYS_ABILITY_ID] = false; 104 dependentServicesStatus_[COMMON_EVENT_SERVICE_ID] = false; 105 dependentServicesStatus_[DISPLAY_MANAGER_SERVICE_SA_ID] = false; 106 dependentServicesStatus_[SUBSYS_ACCOUNT_SYS_ABILITY_ID_BEGIN] = false; 107 dependentServicesStatus_[WINDOW_MANAGER_SERVICE_ID] = false; 108 dependentServicesStatus_[DISTRIBUTED_KV_DATA_SERVICE_ABILITY_ID] = false; 109 110 accessibilitySettings_ = std::make_shared<AccessibilitySettings>(); 111 accessibilityShortKey_ = std::make_shared<AccessibilityShortKey>(); 112} 113 114AccessibleAbilityManagerService::~AccessibleAbilityManagerService() 115{ 116 HILOG_INFO("AccessibleAbilityManagerService::~AccessibleAbilityManagerService"); 117 118 inputInterceptor_ = nullptr; 119 touchEventInjector_ = nullptr; 120 keyEventFilter_ = nullptr; 121 a11yAccountsData_.Clear(); 122} 123 124void AccessibleAbilityManagerService::OnStart() 125{ 126 HILOG_INFO("AccessibleAbilityManagerService::OnStart start"); 127 if (!runner_) { 128 runner_ = AppExecFwk::EventRunner::Create(AAMS_SERVICE_NAME, AppExecFwk::ThreadMode::FFRT); 129 if (!runner_) { 130 HILOG_ERROR("AccessibleAbilityManagerService::OnStart failed:create AAMS runner failed"); 131 return; 132 } 133 } 134 135 if (!handler_) { 136 handler_ = std::make_shared<AAMSEventHandler>(runner_); 137 if (!handler_) { 138 HILOG_ERROR("AccessibleAbilityManagerService::OnStart failed:create AAMS event handler failed"); 139 return; 140 } 141 } 142 143 if (!actionRunner_) { 144 actionRunner_ = AppExecFwk::EventRunner::Create(AAMS_ACTION_RUNNER_NAME, AppExecFwk::ThreadMode::FFRT); 145 if (!actionRunner_) { 146 HILOG_ERROR("AccessibleAbilityManagerService::OnStart failed:create AAMS action runner failed"); 147 return; 148 } 149 } 150 151 if (!actionHandler_) { 152 actionHandler_ = std::make_shared<AAMSEventHandler>(actionRunner_); 153 if (!actionHandler_) { 154 HILOG_ERROR("AccessibleAbilityManagerService::OnStart failed:create AAMS action handler failed"); 155 return; 156 } 157 } 158 159 SetParameter(SYSTEM_PARAMETER_AAMS_NAME.c_str(), "false"); 160 161 HILOG_DEBUG("AddAbilityListener!"); 162 AddSystemAbilityListener(ABILITY_MGR_SERVICE_ID); 163 AddSystemAbilityListener(BUNDLE_MGR_SERVICE_SYS_ABILITY_ID); 164 AddSystemAbilityListener(COMMON_EVENT_SERVICE_ID); 165 AddSystemAbilityListener(DISPLAY_MANAGER_SERVICE_SA_ID); 166 AddSystemAbilityListener(SUBSYS_ACCOUNT_SYS_ABILITY_ID_BEGIN); 167 AddSystemAbilityListener(WINDOW_MANAGER_SERVICE_ID); 168 AddSystemAbilityListener(DISTRIBUTED_KV_DATA_SERVICE_ABILITY_ID); 169 170 accessibilitySettings_->RegisterSettingsHandler(handler_); 171} 172 173void AccessibleAbilityManagerService::OnStop() 174{ 175 HILOG_INFO("stop AccessibleAbilityManagerService"); 176 if (!handler_) { 177 HILOG_ERROR("AccessibleAbilityManagerService::OnStop failed!"); 178 return; 179 } 180 181 ffrt::promise<void> syncPromise; 182 ffrt::future syncFuture = syncPromise.get_future(); 183 handler_->PostTask([this, &syncPromise]() { 184 HILOG_DEBUG(); 185 186 Singleton<AccessibilityCommonEvent>::GetInstance().UnSubscriberEvent(); 187 Singleton<AccessibilityDisplayManager>::GetInstance().UnregisterDisplayListener(); 188 Singleton<AccessibilityWindowManager>::GetInstance().DeregisterWindowListener(); 189 190 currentAccountId_ = -1; 191 a11yAccountsData_.Clear(); 192 stateObservers_.Clear(); 193 bundleManager_ = nullptr; 194 inputInterceptor_ = nullptr; 195 touchEventInjector_ = nullptr; 196 keyEventFilter_ = nullptr; 197 stateObserversDeathRecipient_ = nullptr; 198 bundleManagerDeathRecipient_ = nullptr; 199 200 syncPromise.set_value(); 201 }, "TASK_ONSTOP"); 202 syncFuture.wait(); 203 204 for (auto &iter : dependentServicesStatus_) { 205 iter.second = false; 206 } 207 208 isReady_ = false; 209 isPublished_ = false; 210 SetParameter(SYSTEM_PARAMETER_AAMS_NAME.c_str(), "false"); 211 HILOG_INFO("AccessibleAbilityManagerService::OnStop OK."); 212} 213 214void AccessibleAbilityManagerService::OnAddSystemAbility(int32_t systemAbilityId, const std::string &deviceId) 215{ 216 HILOG_DEBUG("systemAbilityId:%{public}d added!", systemAbilityId); 217 if (!handler_) { 218 HILOG_DEBUG("Event handler is nullptr."); 219 return; 220 } 221 222 handler_->PostTask([=]() { 223 auto iter = dependentServicesStatus_.find(systemAbilityId); 224 if (iter == dependentServicesStatus_.end()) { 225 HILOG_ERROR("SystemAbilityId is not found!"); 226 return; 227 } 228 229 dependentServicesStatus_[systemAbilityId] = true; 230 if (std::any_of(dependentServicesStatus_.begin(), dependentServicesStatus_.end(), 231 [](const std::map<int32_t, bool>::value_type &status) { return !status.second; })) { 232 HILOG_DEBUG("Not all the dependence is ready!"); 233 return; 234 } 235 236 if (Init() == false) { 237 HILOG_ERROR("AccessibleAbilityManagerService::Init failed!"); 238 return; 239 } 240 241 if (!isPublished_) { 242 if (Publish(this) == false) { 243 HILOG_ERROR("AccessibleAbilityManagerService::Publish failed!"); 244 return; 245 } 246 isPublished_ = true; 247 } 248 249 InitInnerResource(); 250 251 isReady_ = true; 252 SetParameter(SYSTEM_PARAMETER_AAMS_NAME.c_str(), "true"); 253 HILOG_DEBUG("AAMS is ready!"); 254 RegisterShortKeyEvent(); 255 PostDelayUnloadTask(); 256 RegisterScreenMagnificationState(); 257 RegisterScreenMagnificationType(); 258 }, "OnAddSystemAbility"); 259} 260 261void AccessibleAbilityManagerService::OnRemoveSystemAbility(int32_t systemAbilityId, const std::string &deviceId) 262{ 263 HILOG_INFO("systemAbilityId:%{public}d removed!", systemAbilityId); 264 if (!handler_) { 265 HILOG_DEBUG("Event handler is nullptr."); 266 return; 267 } 268 269 handler_->PostTask([=]() { 270 HILOG_INFO("Remove system ability start"); 271 auto iter = dependentServicesStatus_.find(systemAbilityId); 272 if (iter == dependentServicesStatus_.end()) { 273 HILOG_ERROR("SystemAbilityId is not found!"); 274 return; 275 } 276 277 dependentServicesStatus_[systemAbilityId] = false; 278 if (isReady_) { 279 SwitchedUser(-1); 280 Singleton<AccessibilityCommonEvent>::GetInstance().UnSubscriberEvent(); 281 Singleton<AccessibilityDisplayManager>::GetInstance().UnregisterDisplayListener(); 282 Singleton<AccessibilityWindowManager>::GetInstance().DeregisterWindowListener(); 283 Singleton<AccessibilityWindowManager>::GetInstance().DeInit(); 284 285 isReady_ = false; 286 SetParameter(SYSTEM_PARAMETER_AAMS_NAME.c_str(), "false"); 287 } 288 }, "OnRemoveSystemAbility"); 289} 290 291int AccessibleAbilityManagerService::Dump(int fd, const std::vector<std::u16string>& args) 292{ 293 HILOG_DEBUG("dump AccessibilityManagerServiceInfo"); 294 if (!handler_) { 295 HILOG_ERROR("Parameters check failed!"); 296 return RET_ERR_NULLPTR; 297 } 298 ffrt::promise<int> syncPromise; 299 ffrt::future syncFuture = syncPromise.get_future(); 300 handler_->PostTask([this, &syncPromise, fd, args]() { 301 if (!accessibilityDumper_) { 302 accessibilityDumper_ = new(std::nothrow) AccessibilityDumper(); 303 if (!accessibilityDumper_) { 304 HILOG_ERROR("accessibilityDumper_ is nullptr"); 305 syncPromise.set_value(-1); 306 return; 307 } 308 } 309 syncPromise.set_value(accessibilityDumper_->Dump(fd, args)); 310 }, "TASK_DUMP_INFO"); 311 return syncFuture.get(); 312} 313 314RetError AccessibleAbilityManagerService::VerifyingToKenId(const int32_t windowId, const int64_t elementId) 315{ 316 uint32_t tokenId = IPCSkeleton::GetCallingTokenID(); 317 int32_t treeId = (static_cast<uint64_t>(elementId) >> ELEMENT_MOVE_BIT); 318 HILOG_DEBUG("VerifyingToKenId: treeId[%{public}d], windowId[%{public}d], elementId[%{public}" PRId64 "]", 319 treeId, windowId, elementId); 320 if (elementId == ELEMENT_ID_INVALID || windowId == WINDOW_ID_INVALID) { 321 HILOG_DEBUG("windowId[%{public}d], elementId[%{public}" PRId64 "]", windowId, elementId); 322 return RET_OK; 323 } 324 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData(); 325 if (accountData == nullptr) { 326 Utils::RecordUnavailableEvent(A11yUnavailableEvent::CONNECT_EVENT, 327 A11yError::ERROR_CONNECT_TARGET_APPLICATION_FAILED); 328 HILOG_ERROR("Get current account data failed!!"); 329 return RET_ERR_CONNECTION_EXIST; 330 } 331 HILOG_DEBUG("treeId %{public}d, windowId %{public}d", treeId, windowId); 332 int32_t realId = 333 Singleton<AccessibilityWindowManager>::GetInstance().ConvertToRealWindowId(windowId, FOCUS_TYPE_INVALID); 334 sptr<AccessibilityWindowConnection> connection = accountData->GetAccessibilityWindowConnection(realId); 335 if (connection == nullptr) { 336 HILOG_ERROR("connection is empty."); 337 return RET_ERR_REGISTER_EXIST; 338 } 339 uint32_t expectTokenId = connection->GetTokenIdMap(treeId); 340 if (tokenId != expectTokenId) { 341 HILOG_DEBUG("tokenId error!"); 342 return RET_ERR_TOKEN_ID; 343 } 344 345 return RET_OK; 346} 347 348RetError AccessibleAbilityManagerService::SendEvent(const AccessibilityEventInfo &uiEvent, const int32_t flag) 349{ 350 HILOG_DEBUG("eventType[%{public}d] gestureId[%{public}d] windowId[%{public}d] compnentId: %{public}" PRId64 " " 351 "elementId: %{public}" PRId64 " winId: %{public}d treeId: %{public}d", 352 uiEvent.GetEventType(), uiEvent.GetGestureType(), uiEvent.GetWindowId(), uiEvent.GetAccessibilityId(), 353 uiEvent.GetElementInfo().GetAccessibilityId(), 354 uiEvent.GetElementInfo().GetWindowId(), uiEvent.GetElementInfo().GetBelongTreeId()); 355 if (!handler_) { 356 HILOG_ERROR("Parameters check failed!"); 357 return RET_ERR_NULLPTR; 358 } 359 if (flag) { 360 if (VerifyingToKenId(uiEvent.GetElementInfo().GetWindowId(), 361 uiEvent.GetElementInfo().GetAccessibilityId()) == RET_OK) { 362 HILOG_DEBUG("VerifyingToKenId ok"); 363 } else { 364 HILOG_DEBUG("VerifyingToKenId failed"); 365 return RET_ERR_CONNECTION_EXIST; 366 } 367 } 368 369 UpdateAccessibilityWindowStateByEvent(uiEvent); 370 handler_->PostTask([this, uiEvent]() { 371 HILOG_DEBUG(); 372 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData(); 373 if (!accountData) { 374 HILOG_ERROR("accountData is nullptr."); 375 return; 376 } 377 378 const_cast<AccessibilityEventInfo&>(uiEvent).SetTimeStamp(Utils::GetSystemTime()); 379 map<string, sptr<AccessibleAbilityConnection>> abilities = accountData->GetConnectedA11yAbilities(); 380 for (auto &ability : abilities) { 381 if (ability.second) { 382 ability.second->OnAccessibilityEvent(const_cast<AccessibilityEventInfo&>(uiEvent)); 383 } 384 } 385 }, "TASK_SEND_EVENT"); 386 return RET_OK; 387} 388 389uint32_t AccessibleAbilityManagerService::RegisterStateObserver( 390 const sptr<IAccessibleAbilityManagerStateObserver>& stateObserver) 391{ 392 HILOG_DEBUG(); 393 if (!stateObserver || !handler_) { 394 HILOG_ERROR("parameters check failed!"); 395 return 0; 396 } 397 XCollieHelper timer(TIMER_REGISTER_STATE_OBSERVER, XCOLLIE_TIMEOUT); 398 std::lock_guard<ffrt::mutex> lock(mutex_); 399 if (!stateObserversDeathRecipient_) { 400 stateObserversDeathRecipient_ = new(std::nothrow) StateCallbackDeathRecipient(); 401 if (!stateObserversDeathRecipient_) { 402 HILOG_ERROR("stateObserversDeathRecipient_ is null"); 403 return 0; 404 } 405 } 406 407 if (!stateObserver->AsObject()) { 408 HILOG_ERROR("object is null"); 409 return 0; 410 } 411 412 stateObserver->AsObject()->AddDeathRecipient(stateObserversDeathRecipient_); 413 stateObservers_.AddStateObserver(stateObserver); 414 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData(); 415 if (accountData == nullptr) { 416 return 0; 417 } 418 419 return accountData->GetAccessibilityState(); 420} 421 422void AccessibleAbilityManagerService::GetRealWindowAndElementId(int32_t& windowId, int64_t& elementId) 423{ 424 HILOG_DEBUG("real windowId %{public}d", windowId); 425 if (!handler_) { 426 return; 427 } 428 429 ffrt::promise<void> syncPromise; 430 ffrt::future syncFuture = syncPromise.get_future(); 431 handler_->PostTask([&, this]() { 432 Singleton<AccessibilityWindowManager>::GetInstance().GetRealWindowAndElementId(windowId, elementId); 433 syncPromise.set_value(); 434 }, "GET_REAL_WINDOW_AND_ELEMENT_ID"); 435 return syncFuture.get(); 436} 437 438void AccessibleAbilityManagerService::GetSceneBoardInnerWinId(int32_t windowId, int64_t elementId, 439 int32_t& innerWid) 440{ 441 HILOG_DEBUG("real windowId %{public}d", windowId); 442 if (!handler_) { 443 return; 444 } 445 446 ffrt::promise<void> syncPromise; 447 ffrt::future syncFuture = syncPromise.get_future(); 448 handler_->PostTask([&, this]() { 449 Singleton<AccessibilityWindowManager>::GetInstance().GetSceneBoardInnerWinId(windowId, elementId, innerWid); 450 syncPromise.set_value(); 451 }, "GET_SCENE_BOARD_INNER_WINDOW_ID"); 452 return syncFuture.get(); 453} 454 455sptr<AccessibilityWindowConnection> AccessibleAbilityManagerService::GetRealIdConnection() 456{ 457 HILOG_DEBUG(); 458 int32_t windowId = ANY_WINDOW_ID; 459 int32_t focusType = FOCUS_TYPE_ACCESSIBILITY; 460 int32_t realId = Singleton<AccessibilityWindowManager>::GetInstance().ConvertToRealWindowId(windowId, focusType); 461 462 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData(); 463 if (!accountData) { 464 HILOG_ERROR("GetCurrentAccountData failed"); 465 return sptr<AccessibilityWindowConnection>(); 466 } 467 return accountData->GetAccessibilityWindowConnection(realId); 468} 469 470bool AccessibleAbilityManagerService::FindFocusedElementByConnection(sptr<AccessibilityWindowConnection> connection, 471 AccessibilityElementInfo &elementInfo) 472{ 473 HILOG_DEBUG(); 474 int64_t elementId = -1; 475 int32_t focusType = FOCUS_TYPE_ACCESSIBILITY; 476 if (!connection || !connection->GetProxy()) { 477 HILOG_ERROR("GetAccessibilityWindowConnection failed"); 478 return false; 479 } 480 481 uint32_t timeOut = 5000; 482 sptr<ElementOperatorCallbackImpl> focusCallback = new(std::nothrow) ElementOperatorCallbackImpl(); 483 if (!focusCallback) { 484 HILOG_ERROR("Failed to create focusCallback."); 485 return false; 486 } 487 ffrt::future<void> focusFuture = focusCallback->promise_.get_future(); 488 connection->GetProxy()->FindFocusedElementInfo(elementId, focusType, GenerateRequestId(), focusCallback); 489 ffrt::future_status waitFocus = focusFuture.wait_for(std::chrono::milliseconds(timeOut)); 490 if (waitFocus != ffrt::future_status::ready) { 491 HILOG_ERROR("FindFocusedElementInfo Failed to wait result"); 492 return false; 493 } 494 elementInfo = focusCallback->accessibilityInfoResult_; 495 return true; 496} 497 498bool AccessibleAbilityManagerService::FindFocusedElement(AccessibilityElementInfo &elementInfo) 499{ 500 HILOG_DEBUG(); 501 sptr<AccessibilityWindowConnection> connection = GetRealIdConnection(); 502 FindFocusedElementByConnection(connection, elementInfo); 503 if (elementInfo.GetAccessibilityId() >= 0) { 504 HILOG_DEBUG("find focused element success."); 505 return true; 506 } 507 int32_t windowId = GetFocusWindowId(); 508 int64_t elementId = GetFocusElementId(); 509 sptr<IAccessibilityElementOperator> elementOperator = nullptr; 510 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData(); 511 if (accountData == nullptr) { 512 HILOG_ERROR("GetCurrentAccountData failed"); 513 return false; 514 } 515 connection = accountData->GetAccessibilityWindowConnection(windowId); 516 HILOG_DEBUG("windowId[%{public}d], elementId[%{public}" PRId64 "]", windowId, elementId); 517 if (connection == nullptr) { 518 HILOG_ERROR("connection is nullptr"); 519 return false; 520 } 521 sptr<ElementOperatorCallbackImpl> callBack = new(std::nothrow) ElementOperatorCallbackImpl(); 522 if (callBack == nullptr) { 523 HILOG_ERROR("Failed to create callBack."); 524 return false; 525 } 526 ffrt::future<void> promiseFuture = callBack->promise_.get_future(); 527 GetElementOperatorConnection(connection, elementId, elementOperator); 528 if (elementOperator == nullptr) { 529 HILOG_ERROR("elementOperator is nullptr"); 530 return false; 531 } 532 elementOperator->SearchElementInfoByAccessibilityId(elementId, GenerateRequestId(), callBack, 0); 533 ffrt::future_status waitFocus = promiseFuture.wait_for(std::chrono::milliseconds(TIME_OUT_OPERATOR)); 534 if (waitFocus != ffrt::future_status::ready) { 535 ipcTimeoutNum_++; 536 HILOG_ERROR("Failed to wait result, number %{public}" PRId64 "", ipcTimeoutNum_); 537 return false; 538 } 539 540 if (callBack->elementInfosResult_.size() <= 0) { 541 HILOG_ERROR("SearchElementInfoByAccessibilityId return null"); 542 return false; 543 } 544 elementInfo = callBack->elementInfosResult_[0]; 545 return true; 546} 547 548void AccessibleAbilityManagerService::GetElementOperatorConnection(sptr<AccessibilityWindowConnection> &connection, 549 const int64_t elementId, sptr<IAccessibilityElementOperator> &elementOperator) 550{ 551 int32_t treeId = 0; 552 if (elementId > 0) { 553 treeId = GetTreeIdBySplitElementId(elementId); 554 elementOperator = connection->GetCardProxy(treeId); 555 } else { 556 elementOperator = connection->GetProxy(); 557 } 558 HILOG_DEBUG("elementId:%{public}" PRId64 " treeId:%{public}d", elementId, treeId); 559} 560 561bool AccessibleAbilityManagerService::ExecuteActionOnAccessibilityFocused(const ActionType &action) 562{ 563 HILOG_DEBUG(); 564 int32_t windowId = GetFocusWindowId(); 565 int64_t elementId = GetFocusElementId(); 566 uint32_t timeOut = 5000; 567 int32_t treeId = GetTreeIdBySplitElementId(elementId); 568 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData(); 569 if (accountData == nullptr) { 570 HILOG_ERROR("GetCurrentAccountData failed"); 571 return false; 572 } 573 sptr<AccessibilityWindowConnection> connection = accountData->GetAccessibilityWindowConnection(windowId); 574 HILOG_DEBUG("windowId[%{public}d], elementId[%{public}" PRId64 "], action[%{public}d", windowId, elementId, 575 action); 576 if (connection == nullptr) { 577 HILOG_ERROR("connection is nullptr"); 578 return false; 579 } 580 std::map<std::string, std::string> actionArguments {}; 581 sptr<ElementOperatorCallbackImpl> actionCallback = new(std::nothrow) ElementOperatorCallbackImpl(); 582 if (actionCallback == nullptr) { 583 HILOG_ERROR("Failed to create actionCallback."); 584 return false; 585 } 586 ffrt::future<void> actionFuture = actionCallback->promise_.get_future(); 587 if (treeId > TREE_ID_INVALID) { 588 if (connection->GetCardProxy(treeId) != nullptr) { 589 connection->GetCardProxy(treeId)->ExecuteAction(elementId, action, 590 actionArguments, GenerateRequestId(), actionCallback); 591 } else { 592 HILOG_ERROR("get operation is nullptr"); 593 return false; 594 } 595 } else { 596 if (connection->GetProxy() != nullptr) { 597 connection->GetProxy()->ExecuteAction(elementId, action, actionArguments, GenerateRequestId(), 598 actionCallback); 599 } else { 600 HILOG_ERROR("get operation is nullptr"); 601 return false; 602 } 603 } 604 ffrt::future_status waitAction = actionFuture.wait_for(std::chrono::milliseconds(timeOut)); 605 if (waitAction != ffrt::future_status::ready) { 606 HILOG_ERROR("ExecuteAction Failed to wait result"); 607 return false; 608 } 609 610 return actionCallback->executeActionResult_; 611} 612 613void AccessibleAbilityManagerService::SetFocusWindowId(const int32_t focusWindowId) 614{ 615 focusWindowId_ = focusWindowId; 616} 617 618int32_t AccessibleAbilityManagerService::GetFocusWindowId() 619{ 620 return focusWindowId_; 621} 622 623void AccessibleAbilityManagerService::SetFocusElementId(const int64_t focusElementId) 624{ 625 focusElementId_ = focusElementId; 626} 627 628int64_t AccessibleAbilityManagerService::GetFocusElementId() 629{ 630 return focusElementId_; 631} 632 633uint32_t AccessibleAbilityManagerService::RegisterCaptionObserver( 634 const sptr<IAccessibleAbilityManagerCaptionObserver> &callback) 635{ 636 HILOG_DEBUG(); 637 if (!callback || !actionHandler_) { 638 HILOG_ERROR("Parameters check failed!"); 639 return ERR_INVALID_VALUE; 640 } 641 642 XCollieHelper timer(TIMER_REGISTER_CAPTION_OBSERVER, XCOLLIE_TIMEOUT); 643 std::shared_ptr<ffrt::promise<uint32_t>> syncPromise = std::make_shared<ffrt::promise<uint32_t>>(); 644 ffrt::future syncFuture = syncPromise->get_future(); 645 actionHandler_->PostTask([this, syncPromise, callback]() { 646 HILOG_DEBUG(); 647 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData(); 648 if (!accountData) { 649 HILOG_ERROR("Account data is null"); 650 syncPromise->set_value(ERR_INVALID_VALUE); 651 return; 652 } 653 if (!captionPropertyCallbackDeathRecipient_) { 654 captionPropertyCallbackDeathRecipient_ = new(std::nothrow) CaptionPropertyCallbackDeathRecipient(); 655 if (!captionPropertyCallbackDeathRecipient_) { 656 HILOG_ERROR("captionPropertyCallbackDeathRecipient_ is null"); 657 syncPromise->set_value(ERR_INVALID_VALUE); 658 return; 659 } 660 } 661 if (!callback->AsObject()) { 662 HILOG_ERROR("object is null"); 663 syncPromise->set_value(0); 664 return; 665 } 666 callback->AsObject()->AddDeathRecipient(captionPropertyCallbackDeathRecipient_); 667 accountData->AddCaptionPropertyCallback(callback); 668 HILOG_DEBUG("the size of caption property callbacks is %{public}zu", 669 accountData->GetCaptionPropertyCallbacks().size()); 670 syncPromise->set_value(NO_ERROR); 671 }, "TASK_REGISTER_CAPTION_OBSERVER"); 672 673 ffrt::future_status wait = syncFuture.wait_for(std::chrono::milliseconds(TIME_OUT_OPERATOR)); 674 if (wait != ffrt::future_status::ready) { 675 HILOG_ERROR("Failed to wait RegisterCaptionObserver result"); 676 return RET_ERR_TIME_OUT; 677 } 678 return syncFuture.get(); 679} 680 681void AccessibleAbilityManagerService::RegisterEnableAbilityListsObserver( 682 const sptr<IAccessibilityEnableAbilityListsObserver> &observer) 683{ 684 HILOG_DEBUG(); 685 if (!observer || !actionHandler_) { 686 HILOG_ERROR("Parameters check failed!"); 687 return; 688 } 689 XCollieHelper timer(TIMER_REGISTER_ENABLEABILITY_OBSERVER, XCOLLIE_TIMEOUT); 690 std::shared_ptr<ffrt::promise<void>> syncPromisePtr = std::make_shared<ffrt::promise<void>>(); 691 ffrt::future syncFuture = syncPromisePtr->get_future(); 692 actionHandler_->PostTask([this, syncPromisePtr, observer]() { 693 HILOG_DEBUG(); 694 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData(); 695 if (!accountData) { 696 HILOG_ERROR("Account data is null"); 697 syncPromisePtr->set_value(); 698 return; 699 } 700 if (!enableAbilityListsObserverDeathRecipient_) { 701 enableAbilityListsObserverDeathRecipient_ = new(std::nothrow) EnableAbilityListsObserverDeathRecipient(); 702 if (!enableAbilityListsObserverDeathRecipient_) { 703 HILOG_ERROR("enableAbilityListsObserverDeathRecipient_ is null"); 704 syncPromisePtr->set_value(); 705 return; 706 } 707 } 708 if (!observer->AsObject()) { 709 HILOG_ERROR("object is null"); 710 syncPromisePtr->set_value(); 711 return; 712 } 713 observer->AsObject()->AddDeathRecipient(enableAbilityListsObserverDeathRecipient_); 714 accountData->AddEnableAbilityListsObserver(observer); 715 syncPromisePtr->set_value(); 716 }, "TASK_REGISTER_ENABLE_ABILITY_LISTS_OBSERVER"); 717 718 ffrt::future_status wait = syncFuture.wait_for(std::chrono::milliseconds(TIME_OUT_OPERATOR)); 719 if (wait != ffrt::future_status::ready) { 720 HILOG_ERROR("Failed to wait RegisterEnableAbilityListsObserver result"); 721 return; 722 } 723 return syncFuture.get(); 724} 725 726RetError AccessibleAbilityManagerService::GetAbilityList(const uint32_t abilityTypes, const int32_t stateType, 727 std::vector<AccessibilityAbilityInfo> &infos) 728{ 729 HILOG_DEBUG("abilityTypes(%{public}d) stateType(%{public}d)", abilityTypes, stateType); 730 if (!handler_ || (stateType > ABILITY_STATE_INSTALLED) || (stateType < ABILITY_STATE_ENABLE)) { 731 HILOG_ERROR("Parameters check failed! stateType:%{public}d", stateType); 732 return RET_ERR_INVALID_PARAM; 733 } 734 735 ffrt::promise<RetError> syncPromise; 736 ffrt::future syncFuture = syncPromise.get_future(); 737 handler_->PostTask([this, &syncPromise, &infos, abilityTypes, stateType]() { 738 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData(); 739 if (!accountData) { 740 HILOG_ERROR("Get current account data failed!!"); 741 syncPromise.set_value(RET_ERR_FAILED); 742 return; 743 } 744 745 vector<AccessibilityAbilityInfo> abilities; 746 accountData->GetAbilitiesByState(static_cast<AbilityStateType>(stateType), abilities); 747 HILOG_DEBUG("abilityes count is %{public}zu", abilities.size()); 748 for (auto &ability : abilities) { 749 if (abilityTypes == AccessibilityAbilityTypes::ACCESSIBILITY_ABILITY_TYPE_ALL || 750 (ability.GetAccessibilityAbilityType() & abilityTypes)) { 751 infos.push_back(ability); 752 } 753 } 754 HILOG_DEBUG("infos count is %{public}zu", infos.size()); 755 syncPromise.set_value(RET_OK); 756 }, "TASK_GET_ABILITY_LIST"); 757 return syncFuture.get(); 758} 759 760RetError AccessibleAbilityManagerService::RegisterElementOperator( 761 const int32_t windowId, const sptr<IAccessibilityElementOperator> &operation, bool isApp) 762{ 763 if (!handler_) { 764 Utils::RecordUnavailableEvent(A11yUnavailableEvent::CONNECT_EVENT, 765 A11yError::ERROR_CONNECT_TARGET_APPLICATION_FAILED); 766 HILOG_ERROR("handler_ is nullptr."); 767 return RET_ERR_NULLPTR; 768 } 769 uint32_t tokenId = IPCSkeleton::GetCallingTokenID(); 770 if (CheckCallingUid() != RET_OK) { 771 return RET_ERR_SAMGR; 772 } 773 handler_->PostTask([=]() { 774 HILOG_INFO("Register windowId[%{public}d]", windowId); 775#ifdef OHOS_BUILD_ENABLE_HITRACE 776 HITRACE_METER_NAME(HITRACE_TAG_ACCESSIBILITY_MANAGER, "RegisterElementOperator"); 777#endif // OHOS_BUILD_ENABLE_HITRACE 778 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData(); 779 if (!accountData) { 780 Utils::RecordUnavailableEvent(A11yUnavailableEvent::CONNECT_EVENT, 781 A11yError::ERROR_CONNECT_TARGET_APPLICATION_FAILED); 782 HILOG_ERROR("Get current account data failed!!"); 783 return; 784 } 785 sptr<AccessibilityWindowConnection> oldConnection = accountData->GetAccessibilityWindowConnection(windowId); 786 if (isApp && oldConnection) { 787 HILOG_WARN("no need to register again."); 788 return; 789 } 790 DeleteConnectionAndDeathRecipient(windowId, oldConnection); 791 sptr<AccessibilityWindowConnection> connection = 792 new(std::nothrow) AccessibilityWindowConnection(windowId, operation, currentAccountId_); 793 if (!connection) { 794 Utils::RecordUnavailableEvent(A11yUnavailableEvent::CONNECT_EVENT, 795 A11yError::ERROR_CONNECT_TARGET_APPLICATION_FAILED); 796 HILOG_ERROR("New AccessibilityWindowConnection failed!!"); 797 return; 798 } 799 connection->SetTokenIdMap(SINGLE_TREE_ID, tokenId); 800 accountData->AddAccessibilityWindowConnection(windowId, connection); 801 802 IsCheckWindowIdEventExist(windowId); 803 if (operation && operation->AsObject()) { 804 sptr<IRemoteObject::DeathRecipient> deathRecipient = 805 new(std::nothrow) InteractionOperationDeathRecipient(windowId, currentAccountId_); 806 if (!deathRecipient) { 807 Utils::RecordUnavailableEvent(A11yUnavailableEvent::CONNECT_EVENT, 808 A11yError::ERROR_CONNECT_TARGET_APPLICATION_FAILED); 809 HILOG_ERROR("Create interactionOperationDeathRecipient failed"); 810 return; 811 } 812 813 bool result = operation->AsObject()->AddDeathRecipient(deathRecipient); 814 interactionOperationDeathRecipients_[windowId] = deathRecipient; 815 HILOG_DEBUG("The result of adding operation's death recipient is %{public}d", result); 816 } 817 }, "TASK_REGISTER_ELEMENT_OPERATOR"); 818 return RET_OK; 819} 820 821void AccessibleAbilityManagerService::IsCheckWindowIdEventExist(const int32_t windowId) 822{ 823 if (CheckWindowIdEventExist(windowId)) { 824 SendEvent(windowFocusEventMap_[windowId]); 825 windowFocusEventMap_.erase(windowId); 826 } 827} 828 829RetError AccessibleAbilityManagerService::RegisterElementOperatorChildWork(const Registration ¶meter, 830 const int32_t treeId, const int64_t nodeId, const sptr<IAccessibilityElementOperator> &operation, 831 const uint32_t tokenId, bool isApp) 832{ 833 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData(); 834 if (accountData == nullptr) { 835 Utils::RecordUnavailableEvent(A11yUnavailableEvent::CONNECT_EVENT, 836 A11yError::ERROR_CONNECT_TARGET_APPLICATION_FAILED); 837 HILOG_ERROR("Get current account data failed!!"); 838 return RET_ERR_REGISTER_EXIST; 839 } 840 841 sptr<AccessibilityWindowConnection> parentConnection = 842 accountData->GetAccessibilityWindowConnection(parameter.parentWindowId); 843 if (isApp && parentConnection) { 844 sptr<IAccessibilityElementOperator> parentAamsOper = 845 parentConnection->GetCardProxy(parameter.parentTreeId); 846 if (parentAamsOper != nullptr) { 847 parentAamsOper->SetChildTreeIdAndWinId(nodeId, treeId, parameter.windowId); 848 } else { 849 HILOG_DEBUG("parentAamsOper is nullptr"); 850 } 851 } else { 852 return RET_ERR_NO_CONNECTION; 853 } 854 855 operation->SetBelongTreeId(treeId); 856 operation->SetParentWindowId(parameter.parentWindowId); 857 sptr<AccessibilityWindowConnection> oldConnection = 858 accountData->GetAccessibilityWindowConnection(parameter.windowId); 859 if (isApp && oldConnection) { 860 if (oldConnection->GetCardProxy(treeId) != nullptr) { 861 HILOG_WARN("no need to register again."); 862 return RET_ERR_REGISTER_EXIST; 863 } else { 864 oldConnection->SetCardProxy(treeId, operation); 865 SetTokenIdMapAndRootParentId(oldConnection, treeId, nodeId, tokenId); 866 } 867 } 868 return RET_OK; 869} 870 871void AccessibleAbilityManagerService::SetTokenIdMapAndRootParentId( 872 const sptr<AccessibilityWindowConnection> connection, 873 const int32_t treeId, const int64_t nodeId, const uint32_t tokenId) 874{ 875 connection->SetTokenIdMap(treeId, tokenId); 876 connection->SetRootParentId(treeId, nodeId); 877} 878 879RetError AccessibleAbilityManagerService::RegisterElementOperator(Registration parameter, 880 const sptr<IAccessibilityElementOperator> &operation, bool isApp) 881{ 882 if (CheckCallingUid() != RET_OK) { 883 return RET_ERR_SAMGR; 884 } 885 static std::atomic<int32_t> treeId(1); 886 int32_t treeIdSingle = treeId.fetch_add(1, std::memory_order_relaxed); 887 if (treeIdSingle > TREE_ID_MAX) { 888 HILOG_ERROR("TreeId more than 13."); 889 return RET_ERR_TREE_TOO_BIG; 890 } 891 uint32_t tokenId = IPCSkeleton::GetCallingTokenID(); 892 int64_t nodeId = parameter.elementId; 893 HILOG_INFO("get treeId element and treeid - treeId: %{public}d parameter.elementId[%{public}" PRId64 "]" 894 "element[%{public}" PRId64 "]", 895 treeIdSingle, parameter.elementId, nodeId); 896 897 if (!handler_) { 898 Utils::RecordUnavailableEvent(A11yUnavailableEvent::CONNECT_EVENT, 899 A11yError::ERROR_CONNECT_TARGET_APPLICATION_FAILED); 900 HILOG_ERROR("handler_ is nullptr."); 901 return RET_ERR_NULLPTR; 902 } 903 handler_->PostTask([=]() { 904 HILOG_INFO("Register windowId[%{public}d]", parameter.windowId); 905#ifdef OHOS_BUILD_ENABLE_HITRACE 906 HITRACE_METER_NAME(HITRACE_TAG_ACCESSIBILITY_MANAGER, "RegisterElementOperator"); 907#endif // OHOS_BUILD_ENABLE_HITRACE 908 if (RET_OK != RegisterElementOperatorChildWork(parameter, treeIdSingle, nodeId, operation, tokenId, isApp)) { 909 return; 910 } 911 if (CheckWindowIdEventExist(parameter.windowId)) { 912 SendEvent(windowFocusEventMap_[parameter.windowId]); 913 windowFocusEventMap_.erase(parameter.windowId); 914 } 915 if (operation && operation->AsObject()) { 916 sptr<IRemoteObject::DeathRecipient> deathRecipient = 917 new(std::nothrow) InteractionOperationDeathRecipient(parameter.windowId, treeIdSingle, 918 currentAccountId_); 919 if (deathRecipient == nullptr) { 920 Utils::RecordUnavailableEvent(A11yUnavailableEvent::CONNECT_EVENT, 921 A11yError::ERROR_CONNECT_TARGET_APPLICATION_FAILED); 922 HILOG_ERROR("Create interactionOperationDeathRecipient failed"); 923 return; 924 } 925 bool result = operation->AsObject()->AddDeathRecipient(deathRecipient); 926 interactionOperationDeathMap_[parameter.windowId][treeIdSingle] = deathRecipient; 927 HILOG_DEBUG("The result of adding operation's death recipient is %{public}d", result); 928 } 929 }, "TASK_REGISTER_ELEMENT_OPERATOR"); 930 return RET_OK; 931} 932 933void AccessibleAbilityManagerService::DeleteConnectionAndDeathRecipient( 934 const int32_t windowId, const sptr<AccessibilityWindowConnection> &connection) 935{ 936 HILOG_DEBUG(); 937 if (!connection) { 938 HILOG_ERROR("connection is nullptr"); 939 return; 940 } 941 942 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData(); 943 if (!accountData) { 944 Utils::RecordUnavailableEvent(A11yUnavailableEvent::CONNECT_EVENT, 945 A11yError::ERROR_CONNECT_TARGET_APPLICATION_FAILED); 946 HILOG_ERROR("Get current account data failed!!"); 947 return; 948 } 949 950 accountData->RemoveAccessibilityWindowConnection(windowId); 951 if (!connection->GetProxy()) { 952 HILOG_WARN("proxy is null"); 953 return; 954 } 955 auto object = connection->GetProxy()->AsObject(); 956 if (object) { 957 auto iter = interactionOperationDeathRecipients_.find(windowId); 958 if (iter != interactionOperationDeathRecipients_.end()) { 959 sptr<IRemoteObject::DeathRecipient> deathRecipient = iter->second; 960 bool result = object->RemoveDeathRecipient(deathRecipient); 961 HILOG_DEBUG("The result of deleting connection's death recipient is %{public}d", result); 962 interactionOperationDeathRecipients_.erase(iter); 963 } 964 } 965} 966 967RetError AccessibleAbilityManagerService::DeregisterElementOperator(int32_t windowId) 968{ 969 if (!handler_) { 970 HILOG_ERROR("handler_ is nullptr."); 971 return RET_ERR_NULLPTR; 972 } 973 974 handler_->PostTask([=]() { 975 HILOG_INFO("Deregister windowId[%{public}d]", windowId); 976 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData(); 977 if (!accountData) { 978 HILOG_ERROR("accountData is nullptr."); 979 return; 980 } 981 sptr<AccessibilityWindowConnection> connection = accountData->GetAccessibilityWindowConnection(windowId); 982 if (!connection) { 983 HILOG_WARN("The operation of windowId[%{public}d] has not been registered.", windowId); 984 return; 985 } 986 accountData->RemoveAccessibilityWindowConnection(windowId); 987 StopCallbackWait(windowId); 988 989 if (!connection->GetProxy()) { 990 HILOG_ERROR("proxy is null"); 991 return; 992 } 993 994 auto object = connection->GetProxy()->AsObject(); 995 if (object) { 996 auto iter = interactionOperationDeathRecipients_.find(windowId); 997 if (iter != interactionOperationDeathRecipients_.end()) { 998 sptr<IRemoteObject::DeathRecipient> deathRecipient = iter->second; 999 bool result = object->RemoveDeathRecipient(deathRecipient); 1000 HILOG_DEBUG("The result of deleting operation's death recipient is %{public}d", result); 1001 interactionOperationDeathRecipients_.erase(iter); 1002 } else { 1003 HILOG_INFO("cannot find remote object. windowId[%{public}d]", windowId); 1004 } 1005 } 1006 }, "TASK_DEREGISTER_ELEMENT_OPERATOR"); 1007 return RET_OK; 1008} 1009 1010RetError AccessibleAbilityManagerService::DeregisterElementOperator(int32_t windowId, const int32_t treeId) 1011{ 1012 if (!handler_) { 1013 HILOG_ERROR("handler_ is nullptr."); 1014 return RET_ERR_NULLPTR; 1015 } 1016 1017 handler_->PostTask([=]() { 1018 HILOG_INFO("Deregister windowId[%{public}d], treeId[%{public}d] start", windowId, treeId); 1019 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData(); 1020 if (!accountData) { 1021 HILOG_ERROR("accountData is nullptr."); 1022 return; 1023 } 1024 sptr<AccessibilityWindowConnection> connection = accountData->GetAccessibilityWindowConnection(windowId); 1025 if (connection == nullptr) { 1026 HILOG_WARN("The operation of windowId[%{public}d] has not been registered.", windowId); 1027 return; 1028 } 1029 StopCallbackWait(windowId, treeId); 1030 1031 if (!connection->GetCardProxy(treeId)) { 1032 HILOG_ERROR("proxy is null"); 1033 return; 1034 } 1035 1036 auto object = connection->GetCardProxy(treeId)->AsObject(); 1037 if (object) { 1038 RemoveTreeDeathRecipient(windowId, treeId, connection); 1039 } 1040 }, "TASK_DEREGISTER_ELEMENT_OPERATOR"); 1041 return RET_OK; 1042} 1043 1044void AccessibleAbilityManagerService::RemoveTreeDeathRecipient(const int32_t windowId, const int32_t treeId, 1045 const sptr<AccessibilityWindowConnection> connection) 1046{ 1047 auto object = connection->GetCardProxy(treeId); 1048 if (object == nullptr) { 1049 HILOG_ERROR("GetCardProxy is null"); 1050 return; 1051 } 1052 auto remoteObject = object->AsObject(); 1053 connection->EraseProxy(treeId); 1054 auto iter = interactionOperationDeathMap_.find(windowId); 1055 if (iter != interactionOperationDeathMap_.end()) { 1056 auto iterTree = iter->second.find(treeId); 1057 if (iterTree != iter->second.end()) { 1058 sptr<IRemoteObject::DeathRecipient> deathRecipient = iterTree->second; 1059 bool result = remoteObject->RemoveDeathRecipient(deathRecipient); 1060 HILOG_DEBUG("The result of deleting operation's death recipient is %{public}d", result); 1061 iter->second.erase(iterTree); 1062 } else { 1063 HILOG_ERROR("cannot find remote object. treeId[%{public}d]", treeId); 1064 } 1065 } else { 1066 HILOG_ERROR("cannot find remote object. windowId[%{public}d]", windowId); 1067 } 1068} 1069 1070RetError AccessibleAbilityManagerService::GetCaptionProperty(AccessibilityConfig::CaptionProperty &caption) 1071{ 1072 return accessibilitySettings_->GetCaptionProperty(caption); 1073} 1074 1075RetError AccessibleAbilityManagerService::SetCaptionProperty(const AccessibilityConfig::CaptionProperty &caption) 1076{ 1077 return accessibilitySettings_->SetCaptionProperty(caption); 1078} 1079 1080RetError AccessibleAbilityManagerService::SetCaptionState(const bool state) 1081{ 1082 return accessibilitySettings_->SetCaptionState(state); 1083} 1084 1085bool AccessibleAbilityManagerService::GetEnabledState() 1086{ 1087 HILOG_DEBUG(); 1088 if (!handler_) { 1089 HILOG_ERROR("handler_ is nullptr."); 1090 return false; 1091 } 1092 1093 ffrt::promise<bool> syncPromise; 1094 ffrt::future syncFuture = syncPromise.get_future(); 1095 handler_->PostTask([this, &syncPromise]() { 1096 HILOG_DEBUG(); 1097 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData(); 1098 if (!accountData) { 1099 HILOG_ERROR("accountData is nullptr"); 1100 syncPromise.set_value(false); 1101 return; 1102 } 1103 bool result = accountData->GetConfig()->GetEnabledState(); 1104 syncPromise.set_value(result); 1105 }, "TASK_GET_ENABLE_STATE"); 1106 return syncFuture.get(); 1107} 1108 1109RetError AccessibleAbilityManagerService::GetCaptionState(bool &state) 1110{ 1111 return accessibilitySettings_->GetCaptionState(state); 1112} 1113 1114bool AccessibleAbilityManagerService::GetTouchGuideState() 1115{ 1116 HILOG_DEBUG(); 1117 if (!handler_) { 1118 HILOG_ERROR("handler_ is nullptr."); 1119 return false; 1120 } 1121 1122 ffrt::promise<bool> syncPromise; 1123 ffrt::future syncFuture = syncPromise.get_future(); 1124 handler_->PostTask([this, &syncPromise]() { 1125 HILOG_DEBUG(); 1126 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData(); 1127 if (!accountData) { 1128 HILOG_ERROR("accountData is nullptr"); 1129 syncPromise.set_value(false); 1130 return; 1131 } 1132 bool result = accountData->GetConfig()->GetTouchGuideState(); 1133 syncPromise.set_value(result); 1134 }, "TASK_GET_TOUCH_GUIDE_STATE"); 1135 return syncFuture.get(); 1136} 1137 1138bool AccessibleAbilityManagerService::GetGestureState() 1139{ 1140 HILOG_DEBUG(); 1141 if (!handler_) { 1142 HILOG_ERROR("handler_ is nullptr."); 1143 return false; 1144 } 1145 1146 ffrt::promise<bool> syncPromise; 1147 ffrt::future syncFuture = syncPromise.get_future(); 1148 handler_->PostTask([this, &syncPromise]() { 1149 HILOG_DEBUG(); 1150 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData(); 1151 if (!accountData) { 1152 HILOG_ERROR("accountData is nullptr"); 1153 syncPromise.set_value(false); 1154 return; 1155 } 1156 bool result = accountData->GetConfig()->GetGestureState(); 1157 syncPromise.set_value(result); 1158 }, "TASK_GET_GESTURE_STATE"); 1159 return syncFuture.get(); 1160} 1161 1162bool AccessibleAbilityManagerService::GetKeyEventObserverState() 1163{ 1164 HILOG_DEBUG(); 1165 if (!handler_) { 1166 HILOG_ERROR("handler_ is nullptr."); 1167 return false; 1168 } 1169 1170 ffrt::promise<bool> syncPromise; 1171 ffrt::future syncFuture = syncPromise.get_future(); 1172 handler_->PostTask([this, &syncPromise]() { 1173 HILOG_DEBUG(); 1174 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData(); 1175 if (!accountData) { 1176 HILOG_ERROR("accountData is nullptr"); 1177 syncPromise.set_value(false); 1178 return; 1179 } 1180 bool result = accountData->GetConfig()->GetKeyEventObserverState(); 1181 syncPromise.set_value(result); 1182 }, "TASK_GET_KEY_EVENT_OBSERVER_STATE"); 1183 return syncFuture.get(); 1184} 1185 1186RetError AccessibleAbilityManagerService::EnableAbility(const std::string &name, const uint32_t capabilities) 1187{ 1188 HILOG_DEBUG(); 1189 if (!handler_) { 1190 HILOG_ERROR("handler_ is nullptr."); 1191 return RET_ERR_NULLPTR; 1192 } 1193 1194 ffrt::promise<RetError> syncPromise; 1195 ffrt::future syncFuture = syncPromise.get_future(); 1196 handler_->PostTask([this, &syncPromise, &name, &capabilities]() { 1197 HILOG_DEBUG(); 1198 RetError result = InnerEnableAbility(name, capabilities); 1199 syncPromise.set_value(result); 1200 }, "TASK_ENABLE_ABILITIES"); 1201 return syncFuture.get(); 1202} 1203 1204bool AccessibleAbilityManagerService::SetTargetAbility(const int32_t targetAbilityValue) 1205{ 1206 HILOG_DEBUG(); 1207 1208 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData(); 1209 if (!accountData) { 1210 HILOG_ERROR("accountData is nullptr"); 1211 return false; 1212 } 1213 1214 bool state; 1215 switch (targetAbilityValue) { 1216 case HIGH_CONTRAST_TEXT: 1217 state = accountData->GetConfig()->GetHighContrastTextState(); 1218 return SetHighContrastTextState(!state) == RET_OK; 1219 case INVERT_COLOR: 1220 state = accountData->GetConfig()->GetInvertColorState(); 1221 return SetInvertColorState(!state) == RET_OK; 1222 case ANIMATION_OFF: 1223 state = accountData->GetConfig()->GetAnimationOffState(); 1224 return SetAnimationOffState(!state) == RET_OK; 1225 case SCREEN_MAGNIFICATION: 1226 state = accountData->GetConfig()->GetScreenMagnificationState(); 1227 return SetScreenMagnificationState(!state) == RET_OK; 1228 case AUDIO_MONO: 1229 state = accountData->GetConfig()->GetAudioMonoState(); 1230 return SetAudioMonoState(!state) == RET_OK; 1231 case MOUSE_KEY: 1232 state = accountData->GetConfig()->GetMouseKeyState(); 1233 return SetMouseKeyState(!state) == RET_OK; 1234 case CAPTION_STATE: 1235 state = accountData->GetConfig()->GetCaptionState(); 1236 return SetCaptionState(!state) == RET_OK; 1237 default: 1238 return false; 1239 } 1240} 1241 1242RetError AccessibleAbilityManagerService::InnerEnableAbility(const std::string &name, const uint32_t capabilities) 1243{ 1244 HILOG_DEBUG(); 1245 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData(); 1246 if (!accountData) { 1247 HILOG_ERROR("accountData is nullptr"); 1248 return RET_ERR_NULLPTR; 1249 } 1250 auto iter = removedAutoStartAbilities_.begin(); 1251 for (; iter != removedAutoStartAbilities_.end(); ++iter) { 1252 if (*iter == name) { 1253 removedAutoStartAbilities_.erase(iter); 1254 break; 1255 } 1256 } 1257 return accountData->EnableAbility(name, capabilities); 1258} 1259 1260RetError AccessibleAbilityManagerService::GetEnabledAbilities(std::vector<std::string> &enabledAbilities) 1261{ 1262 HILOG_DEBUG(); 1263 if (!handler_) { 1264 HILOG_ERROR("handler_ is nullptr."); 1265 return RET_ERR_NULLPTR; 1266 } 1267 1268 ffrt::promise<RetError> syncPromise; 1269 ffrt::future syncFuture = syncPromise.get_future(); 1270 handler_->PostTask([this, &syncPromise, &enabledAbilities]() { 1271 HILOG_DEBUG(); 1272 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData(); 1273 if (!accountData) { 1274 HILOG_ERROR("accountData is nullptr"); 1275 syncPromise.set_value(RET_ERR_NULLPTR); 1276 return; 1277 } 1278 enabledAbilities = accountData->GetEnabledAbilities(); 1279 syncPromise.set_value(RET_OK); 1280 }, "TASK_GET_ENABLE_ABILITIES"); 1281 return syncFuture.get(); 1282} 1283 1284RetError AccessibleAbilityManagerService::SetCurtainScreenUsingStatus(bool isEnable) 1285{ 1286 HILOG_DEBUG(); 1287 auto rsInterfaces = &(Rosen::RSInterfaces::GetInstance()); 1288 if (rsInterfaces == nullptr) { 1289 HILOG_ERROR("rsInterfaces is nullptr."); 1290 return RET_ERR_NULLPTR; 1291 } 1292 HILOG_INFO("SetCurtainScreenUsingStatus: status = %{public}d", isEnable); 1293 rsInterfaces->SetCurtainScreenUsingStatus(isEnable); 1294 return RET_OK; 1295} 1296 1297RetError AccessibleAbilityManagerService::DisableAbility(const std::string &name) 1298{ 1299 HILOG_INFO(); 1300 if (!actionHandler_) { 1301 HILOG_ERROR("actionHandler_ is nullptr."); 1302 return RET_ERR_NULLPTR; 1303 } 1304 1305 ffrt::promise<RetError> syncPromise; 1306 ffrt::future syncFuture = syncPromise.get_future(); 1307 actionHandler_->PostTask([this, &syncPromise, &name]() { 1308 HILOG_DEBUG(); 1309 RetError result = InnerDisableAbility(name); 1310 syncPromise.set_value(result); 1311 }, "TASK_DISABLE_ABILITIES"); 1312 return syncFuture.get(); 1313} 1314 1315RetError AccessibleAbilityManagerService::InnerDisableAbility(const std::string &name) 1316{ 1317 HILOG_INFO(); 1318#ifdef OHOS_BUILD_ENABLE_HITRACE 1319 HITRACE_METER_NAME(HITRACE_TAG_ACCESSIBILITY_MANAGER, "InnerDisableAbility:" + name); 1320#endif // OHOS_BUILD_ENABLE_HITRACE 1321 1322 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData(); 1323 if (!accountData) { 1324 HILOG_ERROR("accountData is nullptr"); 1325 return RET_ERR_NULLPTR; 1326 } 1327 if (accountData->GetConnectingA11yAbility(name) != nullptr) { 1328 HILOG_WARN("refuse to disconnect ability %{public}s when connecting", name.c_str()); 1329 return RET_OK; 1330 } 1331 if (name == SCREEN_READER_BUNDLE_ABILITY_NAME) { 1332 ExecuteActionOnAccessibilityFocused(ACCESSIBILITY_ACTION_CLEAR_ACCESSIBILITY_FOCUS); 1333 SetCurtainScreenUsingStatus(false); 1334 } 1335 RetError ret = accountData->RemoveEnabledAbility(name); 1336 if (ret != RET_OK) { 1337 HILOG_ERROR("RemoveEnabledAbility failed"); 1338 return ret; 1339 } 1340 accountData->SetAbilityAutoStartState(name, false); 1341 accountData->RemoveConnectingA11yAbility(name); 1342 accountData->UpdateAbilities(); 1343 return RET_OK; 1344} 1345 1346RetError AccessibleAbilityManagerService::EnableUITestAbility(const sptr<IRemoteObject> &obj) 1347{ 1348 HILOG_DEBUG(); 1349 if (!handler_) { 1350 HILOG_ERROR("handler_ is nullptr."); 1351 return RET_ERR_NULLPTR; 1352 } 1353 1354 if (!obj) { 1355 HILOG_ERROR("obj is nullptr."); 1356 return RET_ERR_NULLPTR; 1357 } 1358 1359 ffrt::promise<RetError> syncPromise; 1360 ffrt::future syncFuture = syncPromise.get_future(); 1361 handler_->PostTask([this, &syncPromise, obj]() { 1362 HILOG_DEBUG(); 1363 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData(); 1364 if (!accountData) { 1365 HILOG_ERROR("accountData is nullptr"); 1366 syncPromise.set_value(RET_ERR_NULLPTR); 1367 return; 1368 } 1369 std::string uiTestUri = Utils::GetUri(UI_TEST_BUNDLE_NAME, UI_TEST_ABILITY_NAME); 1370 sptr<AccessibleAbilityConnection> connection = accountData->GetAccessibleAbilityConnection(uiTestUri); 1371 if (connection) { 1372 HILOG_ERROR("connection is existed!!"); 1373 syncPromise.set_value(RET_ERR_CONNECTION_EXIST); 1374 return; 1375 } 1376 1377 std::function<void()> addUITestClientFunc = std::bind(&AccessibilityAccountData::AddUITestClient, accountData, 1378 obj, UI_TEST_BUNDLE_NAME, UI_TEST_ABILITY_NAME); 1379 handler_->PostTask(addUITestClientFunc, "AddUITestClient"); 1380 syncPromise.set_value(RET_OK); 1381 }, "TASK_ENABLE_UI_TEST_ABILITIES"); 1382 return syncFuture.get(); 1383} 1384 1385RetError AccessibleAbilityManagerService::DisableUITestAbility() 1386{ 1387 HILOG_DEBUG(); 1388 if (!handler_) { 1389 HILOG_ERROR("handler_ is nullptr."); 1390 return RET_ERR_NULLPTR; 1391 } 1392 1393 std::shared_ptr<ffrt::promise<RetError>> syncPromise = std::make_shared<ffrt::promise<RetError>>(); 1394 ffrt::future syncFuture = syncPromise->get_future(); 1395 handler_->PostTask([this, syncPromise]() { 1396 HILOG_DEBUG(); 1397 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData(); 1398 if (!accountData) { 1399 HILOG_ERROR("accountData is nullptr"); 1400 syncPromise->set_value(RET_ERR_NULLPTR); 1401 return; 1402 } 1403 std::string uiTestUri = Utils::GetUri(UI_TEST_BUNDLE_NAME, UI_TEST_ABILITY_NAME); 1404 sptr<AccessibleAbilityConnection> connection = accountData->GetAccessibleAbilityConnection(uiTestUri); 1405 if (!connection) { 1406 HILOG_ERROR("connection is not existed!!"); 1407 syncPromise->set_value(RET_ERR_NO_CONNECTION); 1408 return; 1409 } 1410 std::function<void()> removeUITestClientFunc = 1411 std::bind(&AccessibilityAccountData::RemoveUITestClient, accountData, connection, UI_TEST_BUNDLE_NAME); 1412 handler_->PostTask(removeUITestClientFunc, "RemoveUITestClient"); 1413 syncPromise->set_value(RET_OK); 1414 }, "TASK_DISABLE_UI_TEST_ABILITIES"); 1415 1416 ffrt::future_status wait = syncFuture.wait_for(std::chrono::milliseconds(TIME_OUT_OPERATOR)); 1417 if (wait != ffrt::future_status::ready) { 1418 HILOG_ERROR("Failed to wait DisableUITestAbility result"); 1419 return RET_ERR_TIME_OUT; 1420 } 1421 return syncFuture.get(); 1422} 1423 1424int32_t AccessibleAbilityManagerService::GetActiveWindow() 1425{ 1426 HILOG_DEBUG(); 1427 return Singleton<AccessibilityWindowManager>::GetInstance().GetActiveWindowId(); 1428} 1429 1430bool AccessibleAbilityManagerService::Init() 1431{ 1432 HILOG_DEBUG(); 1433 Singleton<AccessibilityCommonEvent>::GetInstance().SubscriberEvent(handler_); 1434 Singleton<AccessibilityDisplayManager>::GetInstance().RegisterDisplayListener(handler_); 1435 Singleton<AccessibilityWindowManager>::GetInstance().RegisterWindowListener(handler_); 1436 bool result = Singleton<AccessibilityWindowManager>::GetInstance().Init(); 1437 HILOG_DEBUG("wms init result is %{public}d", result); 1438 1439 int32_t retry = QUERY_USER_ID_RETRY_COUNT; 1440 int32_t sleepTime = QUERY_USER_ID_SLEEP_TIME; 1441 std::vector<int32_t> accountIds; 1442 ErrCode ret = AccountSA::OsAccountManager::QueryActiveOsAccountIds(accountIds); 1443 while (ret != ERR_OK || accountIds.size() == 0) { 1444 HILOG_DEBUG("Query account information failed, left retry count:%{public}d", retry); 1445 if (retry == 0) { 1446 HILOG_ERROR("Query account information failed!!!"); 1447 break; 1448 } 1449 std::this_thread::sleep_for(std::chrono::milliseconds(sleepTime)); 1450 ret = AccountSA::OsAccountManager::QueryActiveOsAccountIds(accountIds); 1451 retry--; 1452 } 1453 1454 if (accountIds.size() > 0) { 1455 HILOG_DEBUG("Query account information success, account id:%{public}d", accountIds[0]); 1456 SwitchedUser(accountIds[0]); 1457 } 1458 1459 return true; 1460} 1461 1462void AccessibleAbilityManagerService::InitInnerResource() 1463{ 1464 UpdateSettingsInAtoHosTask(); 1465} 1466 1467void AccessibleAbilityManagerService::InteractionOperationDeathRecipient::OnRemoteDied( 1468 const wptr<IRemoteObject> &remote) 1469{ 1470 Utils::RecordUnavailableEvent(A11yUnavailableEvent::CONNECT_EVENT, 1471 A11yError::ERROR_TARGET_APPLICATION_DISCONNECT_ABNORMALLY); 1472 HILOG_INFO(); 1473 sptr<AccessibilityAccountData> accountData = 1474 Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData(); 1475 if (accountData == nullptr) { 1476 HILOG_ERROR("get accountData failed"); 1477 return; 1478 } 1479 int32_t currentAccountId = accountData->GetAccountId(); 1480 if (currentAccountId != accountId_) { 1481 HILOG_ERROR("check accountId failed"); 1482 return; 1483 } 1484 1485 if (treeId_ > 0) { 1486 Singleton<AccessibleAbilityManagerService>::GetInstance().DeregisterElementOperator(windowId_, treeId_); 1487 } else { 1488 Singleton<AccessibleAbilityManagerService>::GetInstance().DeregisterElementOperator(windowId_); 1489 } 1490} 1491 1492sptr<AccessibilityAccountData> AccessibleAbilityManagerService::GetCurrentAccountData() 1493{ 1494 HILOG_DEBUG(); 1495 if (currentAccountId_ == -1) { 1496 HILOG_ERROR("current account id is wrong"); 1497 return nullptr; 1498 } 1499 1500 return a11yAccountsData_.GetCurrentAccountData(currentAccountId_); 1501} 1502 1503sptr<AccessibilityAccountData> AccessibleAbilityManagerService::GetAccountData(int32_t accountId) 1504{ 1505 HILOG_DEBUG(); 1506 return a11yAccountsData_.GetAccountData(accountId); 1507} 1508 1509std::vector<int32_t> AccessibleAbilityManagerService::GetAllAccountIds() 1510{ 1511 HILOG_DEBUG(); 1512 return a11yAccountsData_.GetAllAccountIds(); 1513} 1514 1515sptr<AppExecFwk::IBundleMgr> AccessibleAbilityManagerService::GetBundleMgrProxy() 1516{ 1517 HILOG_DEBUG(); 1518 if (bundleManager_) { 1519 return bundleManager_; 1520 } 1521 1522 sptr<ISystemAbilityManager> systemAbilityManager = 1523 SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager(); 1524 if (!systemAbilityManager) { 1525 HILOG_ERROR("failed:fail to get system ability mgr."); 1526 return nullptr; 1527 } 1528 1529 sptr<IRemoteObject> remoteObject = systemAbilityManager->GetSystemAbility(BUNDLE_MGR_SERVICE_SYS_ABILITY_ID); 1530 if (!remoteObject) { 1531 HILOG_ERROR("failed:fail to get bundle manager proxy."); 1532 return nullptr; 1533 } 1534 1535 bundleManager_ = iface_cast<AppExecFwk::IBundleMgr>(remoteObject); 1536 if (!bundleManager_) { 1537 HILOG_ERROR("fail to new bundle manager."); 1538 return nullptr; 1539 } 1540 1541 if (!bundleManagerDeathRecipient_) { 1542 bundleManagerDeathRecipient_ = new(std::nothrow) BundleManagerDeathRecipient(); 1543 if (!bundleManagerDeathRecipient_) { 1544 HILOG_ERROR("bundleManagerDeathRecipient_ is null"); 1545 return nullptr; 1546 } 1547 } 1548 1549 bundleManager_->AsObject()->AddDeathRecipient(bundleManagerDeathRecipient_); 1550 return bundleManager_; 1551} 1552 1553sptr<AccessibilityWindowConnection> AccessibleAbilityManagerService::GetAccessibilityWindowConnection( 1554 int32_t windowId) 1555{ 1556 HILOG_DEBUG("windowId(%{public}d)", windowId); 1557 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData(); 1558 if (!accountData) { 1559 HILOG_ERROR("Get account data failed"); 1560 return nullptr; 1561 } 1562 return accountData->GetAccessibilityWindowConnection(windowId); 1563} 1564 1565void AccessibleAbilityManagerService::ClearFocus(int32_t windowId) 1566{ 1567 HILOG_DEBUG(); 1568 sptr<AccessibilityWindowConnection> connection = GetAccessibilityWindowConnection(windowId); 1569 if (connection && connection->GetProxy()) { 1570 connection->GetProxy()->ClearFocus(); 1571 } 1572} 1573 1574void AccessibleAbilityManagerService::OutsideTouch(int32_t windowId) 1575{ 1576 HILOG_DEBUG(); 1577 sptr<AccessibilityWindowConnection> connection = GetAccessibilityWindowConnection(windowId); 1578 if (connection && connection->GetProxy()) { 1579 connection->GetProxy()->OutsideTouch(); 1580 } 1581} 1582 1583void AccessibleAbilityManagerService::SetTouchEventInjector(const sptr<TouchEventInjector> &touchEventInjector) 1584{ 1585 HILOG_DEBUG(); 1586 touchEventInjector_ = touchEventInjector; 1587} 1588 1589void AccessibleAbilityManagerService::SetKeyEventFilter(const sptr<KeyEventFilter> &keyEventFilter) 1590{ 1591 HILOG_DEBUG(); 1592 keyEventFilter_ = keyEventFilter; 1593} 1594 1595void AccessibleAbilityManagerService::StateCallbackDeathRecipient::OnRemoteDied(const wptr<IRemoteObject> &remote) 1596{ 1597 Singleton<AccessibleAbilityManagerService>::GetInstance().RemoveCallback(STATE_CALLBACK, this, remote); 1598} 1599 1600void AccessibleAbilityManagerService::CaptionPropertyCallbackDeathRecipient::OnRemoteDied( 1601 const wptr<IRemoteObject> &remote) 1602{ 1603 Singleton<AccessibleAbilityManagerService>::GetInstance().RemoveCallback(CAPTION_PROPERTY_CALLBACK, this, remote); 1604} 1605 1606void AccessibleAbilityManagerService::EnableAbilityListsObserverDeathRecipient::OnRemoteDied( 1607 const wptr<IRemoteObject> &remote) 1608{ 1609 Singleton<AccessibleAbilityManagerService>::GetInstance().RemoveCallback( 1610 ENABLE_ABILITY_LISTS_CALLBACK, this, remote); 1611} 1612 1613void AccessibleAbilityManagerService::AddedUser(int32_t accountId) 1614{ 1615 HILOG_DEBUG(); 1616 a11yAccountsData_.AddAccountData(accountId); 1617} 1618 1619void AccessibleAbilityManagerService::RemovedUser(int32_t accountId) 1620{ 1621 HILOG_DEBUG(); 1622 if (accountId == currentAccountId_) { 1623 HILOG_ERROR("Remove user failed, this account is current account."); 1624 return; 1625 } 1626 1627 auto accountData = a11yAccountsData_.RemoveAccountData(accountId); 1628 if (accountData) { 1629 accountData->GetConfig()->ClearData(); 1630 return; 1631 } 1632 1633 HILOG_ERROR("accountId is not exist"); 1634} 1635 1636void AccessibleAbilityManagerService::SwitchedUser(int32_t accountId) 1637{ 1638 HILOG_DEBUG(); 1639 1640 if (accountId == currentAccountId_) { 1641 HILOG_WARN("The account is current account id."); 1642 return; 1643 } 1644 OffZoomGesture(); 1645 1646 std::map<std::string, uint32_t> importantEnabledAbilities; 1647 SCREENREADER_STATE screenReaderState = SCREENREADER_STATE::UNINIT; 1648 if (currentAccountId_ != -1) { 1649 HILOG_DEBUG(); 1650 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData(); 1651 if (!accountData) { 1652 HILOG_ERROR("Current account data is null"); 1653 return; 1654 } 1655 defaultConfigCallbacks_ = accountData->GetConfigCallbacks(); 1656 screenReaderState = accountData->GetDefaultUserScreenReaderState() ? 1657 SCREENREADER_STATE::ON : SCREENREADER_STATE::OFF; 1658 accountData->GetImportantEnabledAbilities(importantEnabledAbilities); 1659 accountData->OnAccountSwitched(); 1660 UpdateAccessibilityManagerService(); 1661 } 1662 currentAccountId_ = accountId; 1663 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData(); 1664 if (!accountData) { 1665 HILOG_ERROR("accountData is nullptr."); 1666 return; 1667 } 1668 accountData->Init(); 1669 accountData->SetConfigCallbacks(defaultConfigCallbacks_); 1670#ifdef OHOS_BUILD_ENABLE_POWER_MANAGER 1671 float discount = accountData->GetConfig()->GetBrightnessDiscount(); 1672 if (!Singleton<AccessibilityPowerManager>::GetInstance().DiscountBrightness(discount)) { 1673 HILOG_ERROR("Failed to set brightness discount"); 1674 } 1675#endif 1676 AccountSA::OsAccountType accountType = accountData->GetAccountType(); 1677 if (screenReaderState != SCREENREADER_STATE::UNINIT && 1678 (accountType == AccountSA::OsAccountType::PRIVATE || accountType == AccountSA::OsAccountType::ADMIN)) { 1679 bool state = (screenReaderState == SCREENREADER_STATE::ON) ? true : false; 1680 accountData->SetAbilityAutoStartState(SCREEN_READER_BUNDLE_ABILITY_NAME, state); 1681 HILOG_INFO("set screenreader auto-start state = %{public}d", true); 1682 } 1683 1684 if (accountData->GetInstalledAbilitiesFromBMS()) { 1685 accountData->UpdateImportantEnabledAbilities(importantEnabledAbilities); 1686 accountData->UpdateAbilities(); 1687 UpdateAccessibilityManagerService(); 1688 } 1689 UpdateAllSetting(); 1690 UpdateAutoStartAbilities(); 1691 RegisterShortKeyEvent(); 1692 RegisterScreenMagnificationState(); 1693 RegisterScreenMagnificationType(); 1694} 1695 1696void AccessibleAbilityManagerService::PackageRemoved(const std::string &bundleName) 1697{ 1698 sptr<AccessibilityAccountData> packageAccount = GetCurrentAccountData(); 1699 if (!packageAccount) { 1700 HILOG_ERROR("packageAccount is nullptr."); 1701 return; 1702 } 1703 1704 packageAccount->DelAutoStartPrefKeyInRemovePkg(bundleName); 1705 std::vector<std::string> multiTarget = packageAccount->GetConfig()->GetShortkeyMultiTarget(); 1706 std::string name = packageAccount->GetConfig()->GetShortkeyTarget(); 1707 auto installedAbilities_ = packageAccount->GetInstalledAbilities(); 1708 for (auto &installAbility : installedAbilities_) { 1709 std::string abilityId = installAbility.GetId(); 1710 HILOG_DEBUG("abilityId%{public}s", abilityId.c_str()); 1711 if (bundleName != installAbility.GetPackageName()) { 1712 continue; 1713 } 1714 if (std::find(removedAutoStartAbilities_.begin(), removedAutoStartAbilities_.end(), abilityId) 1715 == removedAutoStartAbilities_.end()) { 1716 removedAutoStartAbilities_.push_back(abilityId); 1717 } 1718 // no use later version 1719 if (abilityId == name) { 1720 std::string targetName = ""; 1721 packageAccount->GetConfig()->SetShortkeyTarget(targetName); 1722 UpdateShortkeyTarget(); 1723 } 1724 // multi 1725 for (const auto &target : multiTarget) { 1726 if (target == abilityId) { 1727 packageAccount->GetConfig()->SetShortkeyMultiTargetInPkgRemove(abilityId); 1728 UpdateShortkeyMultiTarget(); 1729 } 1730 } 1731 } 1732 1733 if (packageAccount->RemoveAbility(bundleName)) { 1734 HILOG_DEBUG("ability%{public}s removed!", bundleName.c_str()); 1735 UpdateAccessibilityManagerService(); 1736 } 1737} 1738 1739void AccessibleAbilityManagerService::PackageAdd(const std::string &bundleName) 1740{ 1741 sptr<AccessibilityAccountData> packageAccount = GetCurrentAccountData(); 1742 if (!packageAccount) { 1743 HILOG_ERROR("packageAccount is nullptr"); 1744 return; 1745 } 1746 for (auto &abilityId : removedAutoStartAbilities_) { 1747 if (packageAccount->GetAbilityAutoStartState(abilityId)) { 1748 packageAccount->SetAbilityAutoStartState(abilityId, false); 1749 } 1750 } 1751 packageAccount->AddAbility(bundleName); 1752} 1753 1754void AccessibleAbilityManagerService::PackageChanged(const std::string &bundleName) 1755{ 1756 sptr<AccessibilityAccountData> packageAccount = GetCurrentAccountData(); 1757 if (!packageAccount) { 1758 HILOG_ERROR("packageAccount is nullptr"); 1759 return; 1760 } 1761 1762 bool isNeedUpdateShortKeyTarget = false; 1763 std::string target = packageAccount->GetConfig()->GetShortkeyTarget(); 1764 if (target.substr(0, target.find("/")) == bundleName) { 1765 isNeedUpdateShortKeyTarget = true; 1766 } 1767 std::vector<std::string> multiTarget = packageAccount->GetConfig()->GetShortkeyMultiTarget(); 1768 1769 packageAccount->ChangeAbility(bundleName); 1770 UpdateAccessibilityManagerService(); 1771 1772 std::vector<std::string> sameBundleTarget; 1773 auto installedAbilities_ = packageAccount->GetInstalledAbilities(); 1774 for (auto &installAbility : installedAbilities_) { 1775 std::string abilityId = installAbility.GetId(); 1776 if (bundleName != installAbility.GetPackageName()) { 1777 continue; 1778 } 1779 if (abilityId == target) { 1780 isNeedUpdateShortKeyTarget = false; 1781 } 1782 sameBundleTarget.push_back(abilityId); 1783 } 1784 1785 if (isNeedUpdateShortKeyTarget) { 1786 packageAccount->GetConfig()->SetShortkeyTarget(""); 1787 UpdateShortkeyTarget(); 1788 } 1789 std::vector<std::string> tmpAbilities = multiTarget; 1790 bool isNeedUpdateShortKeyMultiTarget = false; 1791 Utils::SelectUsefulFromVecWithSameBundle(tmpAbilities, sameBundleTarget, 1792 isNeedUpdateShortKeyMultiTarget, bundleName); 1793 if (isNeedUpdateShortKeyMultiTarget) { 1794 packageAccount->GetConfig()->SetShortkeyMultiTarget(tmpAbilities); 1795 UpdateShortkeyMultiTarget(); 1796 } 1797} 1798 1799void AccessibleAbilityManagerService::ElementOperatorCallbackImpl::SetFindFocusedElementInfoResult( 1800 const AccessibilityElementInfo &info, const int32_t requestId) 1801{ 1802 HILOG_DEBUG("Response [requestId:%{public}d]", requestId); 1803 if (Singleton<AccessibleAbilityManagerService>::GetInstance().VerifyingToKenId(info.GetWindowId(), 1804 info.GetAccessibilityId()) == RET_OK) { 1805 HILOG_DEBUG("VerifyingToKenId ok"); 1806 accessibilityInfoResult_ = info; 1807 promise_.set_value(); 1808 } else { 1809 HILOG_DEBUG("VerifyingToKenId failed"); 1810 promise_.set_value(); 1811 } 1812} 1813 1814void AccessibleAbilityManagerService::ElementOperatorCallbackImpl::SetSearchElementInfoByTextResult( 1815 const std::vector<AccessibilityElementInfo> &infos, const int32_t requestId) 1816{ 1817 HILOG_DEBUG("Response [requestId:%{public}d]", requestId); 1818 for (auto info : infos) { 1819 if (Singleton<AccessibleAbilityManagerService>::GetInstance().VerifyingToKenId(info.GetWindowId(), 1820 info.GetAccessibilityId()) == RET_OK) { 1821 HILOG_DEBUG("VerifyingToKenId ok"); 1822 } else { 1823 HILOG_DEBUG("VerifyingToKenId failed"); 1824 elementInfosResult_.clear(); 1825 promise_.set_value(); 1826 return; 1827 } 1828 elementInfosResult_ = infos; 1829 } 1830 promise_.set_value(); 1831} 1832 1833void AccessibleAbilityManagerService::ElementOperatorCallbackImpl::SetSearchElementInfoByAccessibilityIdResult( 1834 const std::vector<AccessibilityElementInfo> &infos, const int32_t requestId) 1835{ 1836 HILOG_DEBUG("Response [requestId:%{public}d]", requestId); 1837 for (auto info : infos) { 1838 if (Singleton<AccessibleAbilityManagerService>::GetInstance().VerifyingToKenId(info.GetWindowId(), 1839 info.GetAccessibilityId()) == RET_OK) { 1840 HILOG_DEBUG("VerifyingToKenId ok"); 1841 } else { 1842 HILOG_DEBUG("VerifyingToKenId failed"); 1843 elementInfosResult_.clear(); 1844 promise_.set_value(); 1845 return; 1846 } 1847 elementInfosResult_ = infos; 1848 } 1849 promise_.set_value(); 1850} 1851 1852void AccessibleAbilityManagerService::ElementOperatorCallbackImpl::SetFocusMoveSearchResult( 1853 const AccessibilityElementInfo &info, const int32_t requestId) 1854{ 1855 HILOG_DEBUG("Response [requestId:%{public}d]", requestId); 1856 if (Singleton<AccessibleAbilityManagerService>::GetInstance().VerifyingToKenId(info.GetWindowId(), 1857 info.GetAccessibilityId()) == RET_OK) { 1858 HILOG_DEBUG("VerifyingToKenId ok"); 1859 accessibilityInfoResult_ = info; 1860 promise_.set_value(); 1861 } else { 1862 HILOG_DEBUG("VerifyingToKenId failed"); 1863 promise_.set_value(); 1864 } 1865} 1866 1867void AccessibleAbilityManagerService::ElementOperatorCallbackImpl::SetExecuteActionResult(const bool succeeded, 1868 const int32_t requestId) 1869{ 1870 HILOG_DEBUG("Response [result:%{public}d, requestId:%{public}d]", succeeded, requestId); 1871 executeActionResult_ = succeeded; 1872 promise_.set_value(); 1873} 1874 1875void AccessibleAbilityManagerService::ElementOperatorCallbackImpl::SetCursorPositionResult(const int32_t cursorPosition, 1876 const int32_t requestId) 1877{ 1878 HILOG_INFO("ElementOperatorCallbackImpl::SetCursorPositionResult [result:%{public}d]", 1879 cursorPosition); 1880 HILOG_DEBUG("cursorPosition [result:%{public}d, requestId:%{public}d]", cursorPosition, requestId); 1881 callCursorPosition_ = cursorPosition; 1882 promise_.set_value(); 1883} 1884 1885bool AccessibleAbilityManagerService::GetParentElementRecursively(int32_t windowId, int64_t elementId, 1886 std::vector<AccessibilityElementInfo>& infos) 1887{ 1888 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData(); 1889 if (!accountData) { 1890 HILOG_ERROR("GetCurrentAccountData failed"); 1891 return false; 1892 } 1893 1894 int32_t treeId = 0; 1895 sptr<IAccessibilityElementOperator> elementOperator = nullptr; 1896 sptr<AccessibilityWindowConnection> connection = accountData->GetAccessibilityWindowConnection(windowId); 1897 if (!connection) { 1898 HILOG_ERROR("GetAccessibilityWindowConnection failed"); 1899 return false; 1900 } 1901 1902 if (elementId > 0) { 1903 treeId = GetTreeIdBySplitElementId(elementId); 1904 elementOperator = connection->GetCardProxy(treeId); 1905 } else { 1906 elementOperator = connection->GetProxy(); 1907 } 1908 if (elementOperator == nullptr) { 1909 HILOG_DEBUG("elementOperator failed elementId: %{public}" PRId64 " winId: %{public}d treeId: %{public}d", 1910 elementId, windowId, treeId); 1911 return false; 1912 } 1913 sptr<ElementOperatorCallbackImpl> callBack = new(std::nothrow) ElementOperatorCallbackImpl(); 1914 if (callBack == nullptr) { 1915 HILOG_ERROR("Failed to create callBack."); 1916 return false; 1917 } 1918 1919 ffrt::future<void> promiseFuture = callBack->promise_.get_future(); 1920 elementOperator->SearchElementInfoByAccessibilityId(elementId, GenerateRequestId(), callBack, 0); 1921 ffrt::future_status waitFocus = promiseFuture.wait_for(std::chrono::milliseconds(TIME_OUT_OPERATOR)); 1922 if (waitFocus != ffrt::future_status::ready) { 1923 ipcTimeoutNum_++; 1924 HILOG_ERROR("Failed to wait result, number %{public}" PRId64 "", ipcTimeoutNum_); 1925 return false; 1926 } 1927 1928 for (auto& info : callBack->elementInfosResult_) { 1929 if (info.GetAccessibilityId() == AccessibilityElementInfo::UNDEFINED_ACCESSIBILITY_ID) { 1930 HILOG_ERROR("SearchElementInfoByAccessibilityId elementInfo from ace is wrong"); 1931 return false; 1932 } 1933 } 1934 1935 infos = callBack->elementInfosResult_; 1936 HILOG_DEBUG("Get parent element success, size %{public}zu", infos.size()); 1937 return true; 1938} 1939 1940void AccessibleAbilityManagerService::FindInnerWindowId(const AccessibilityEventInfo &event, int32_t& windowId) 1941{ 1942 HILOG_DEBUG(); 1943 auto mapTable = Singleton<AccessibilityWindowManager>::GetInstance().sceneBoardElementIdMap_.GetAllPairs(); 1944 int64_t elementId = event.GetAccessibilityId(); 1945 while (1) { 1946 for (auto iter = mapTable.begin(); iter != mapTable.end(); iter++) { 1947 if (elementId == iter->second) { 1948 windowId = iter->first; 1949 HILOG_DEBUG("inner windowId %{public}d", windowId); 1950 return; 1951 } 1952 } 1953 1954 std::vector<AccessibilityElementInfo> infos = {}; 1955 if (GetParentElementRecursively(event.GetWindowId(), elementId, infos) == false || infos.size() == 0) { 1956 HILOG_ERROR("find parent element failed"); 1957 return; 1958 } 1959 1960 if (infos[0].GetComponentType() == "root") { 1961 HILOG_ERROR("can not find parent element, has reach root node"); 1962 return; 1963 } 1964 1965 elementId = infos[0].GetParentNodeId(); 1966 } 1967} 1968 1969void AccessibleAbilityManagerService::UpdateAccessibilityWindowStateByEvent(const AccessibilityEventInfo &event) 1970{ 1971 EventType evtType = event.GetEventType(); 1972 HILOG_DEBUG("windowId is %{public}d", event.GetWindowId()); 1973 int32_t windowId = event.GetWindowId(); 1974 if (windowId == 1 && (evtType == TYPE_VIEW_HOVER_ENTER_EVENT || evtType == TYPE_VIEW_ACCESSIBILITY_FOCUSED_EVENT)) { 1975 FindInnerWindowId(event, windowId); 1976 } 1977 1978 switch (evtType) { 1979 case TYPE_VIEW_HOVER_ENTER_EVENT: 1980 Singleton<AccessibilityWindowManager>::GetInstance().SetActiveWindow(windowId, false); 1981 Singleton<AccessibilityWindowManager>::GetInstance().SetAccessibilityFocusedWindow(windowId); 1982 break; 1983 case TYPE_VIEW_ACCESSIBILITY_FOCUSED_EVENT: 1984 Singleton<AccessibilityWindowManager>::GetInstance().SetAccessibilityFocusedWindow(windowId); 1985 break; 1986 default: 1987 break; 1988 } 1989} 1990 1991void AccessibleAbilityManagerService::UpdateAccessibilityManagerService() 1992{ 1993 HILOG_DEBUG("start."); 1994 1995 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData(); 1996 if (!accountData) { 1997 HILOG_ERROR("Account data is null"); 1998 return; 1999 } 2000 2001 accountData->UpdateAccountCapabilities(); 2002 UpdateInputFilter(); 2003 UpdateAccessibilityState(); 2004 UpdateShortKeyRegister(); 2005} 2006 2007void AccessibleAbilityManagerService::UpdateAccessibilityState() 2008{ 2009 HILOG_DEBUG("start."); 2010 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData(); 2011 if (!accountData) { 2012 HILOG_ERROR("Account data is null"); 2013 return; 2014 } 2015 uint32_t state = accountData->GetAccessibilityState(); 2016 if (!(state & STATE_ACCESSIBILITY_ENABLED)) { 2017 Singleton<AccessibilityWindowManager>::GetInstance().ClearAccessibilityFocused(); 2018 } 2019 2020 stateObservers_.OnStateObservers(state); 2021} 2022 2023void AccessibleAbilityManagerService::UpdateCaptionProperty() 2024{ 2025 return accessibilitySettings_->UpdateCaptionProperty(); 2026} 2027 2028void AccessibleAbilityManagerService::UpdateSettingsInAtoHosTask() 2029{ 2030 HILOG_DEBUG(); 2031 if (!handler_) { 2032 HILOG_ERROR("UpdateSettingsInAtoHosTask: handler is nullptr!"); 2033 return; 2034 } 2035 handler_->PostTask([=]() { 2036 UpdateSettingsInAtoHos(); 2037 }, "UPDATE_SETTINGS_IN_ATOHOS_TASK"); 2038} 2039 2040void AccessibleAbilityManagerService::UpdateAutoStartAbilities() 2041{ 2042 HILOG_DEBUG(); 2043 if (!handler_) { 2044 HILOG_ERROR("UpdateAutoStartAbilities: handler is nullptr."); 2045 return; 2046 } 2047 2048 handler_->PostTask([=]() { 2049 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData(); 2050 if (!accountData) { 2051 HILOG_ERROR("Account data is null"); 2052 return; 2053 } 2054 for (auto &abilityId : removedAutoStartAbilities_) { 2055 if (accountData->GetAbilityAutoStartState(abilityId)) { 2056 accountData->SetAbilityAutoStartState(abilityId, false); 2057 } 2058 } 2059 accountData->UpdateAutoStartEnabledAbilities(); 2060 accountData->UpdateAbilities(); 2061 }, "UPDATE_AUTO_START_ABILITIES"); 2062} 2063 2064void AccessibleAbilityManagerService::UpdateSettingsInAtoHos() 2065{ 2066 HILOG_DEBUG(); 2067 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData(); 2068 if (!accountData) { 2069 HILOG_ERROR("accountData is nullptr."); 2070 return; 2071 } 2072 2073 if (!accountData->GetConfig()->GetStartFromAtoHosState() || currentAccountId_ != DEFAULT_ACCOUNT_ID) { 2074 HILOG_INFO("Not first start from a to hos."); 2075 return; 2076 } 2077 accessibilitySettings_->UpdateSettingsInAtoHos(); 2078} 2079 2080void AccessibleAbilityManagerService::UpdateInputFilter() 2081{ 2082 HILOG_DEBUG("start."); 2083 2084 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData(); 2085 if (!accountData) { 2086 HILOG_ERROR("Account data is null"); 2087 return; 2088 } 2089 2090 uint32_t flag = accountData->GetInputFilterFlag(); 2091 HILOG_DEBUG("InputInterceptor flag is %{public}d", flag); 2092 2093 inputInterceptor_ = AccessibilityInputInterceptor::GetInstance(); 2094 if (!inputInterceptor_) { 2095 HILOG_ERROR("inputInterceptor_ is null."); 2096 return; 2097 } 2098 inputInterceptor_->SetAvailableFunctions(flag); 2099 Utils::RecordStartingA11yEvent(flag); 2100} 2101 2102void AccessibleAbilityManagerService::UpdateAllSetting() 2103{ 2104 accessibilitySettings_->UpdateAllSetting(); 2105} 2106 2107void AccessibleAbilityManagerService::UpdateShortKeyRegister() 2108{ 2109 HILOG_DEBUG(); 2110 2111 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData(); 2112 if (accountData == nullptr) { 2113 HILOG_ERROR("Account data is null!"); 2114 return; 2115 } 2116 2117 bool shortKeyState = accountData->GetConfig()->GetShortKeyState(); 2118 if (shortKeyState) { 2119 accessibilityShortKey_->Unregister(); 2120 accessibilityShortKey_->Register(); 2121 } else { 2122 accessibilityShortKey_->Unregister(); 2123 } 2124} 2125 2126RetError AccessibleAbilityManagerService::SetScreenMagnificationState(const bool state) 2127{ 2128 return accessibilitySettings_->SetScreenMagnificationState(state); 2129} 2130 2131RetError AccessibleAbilityManagerService::SetShortKeyState(const bool state) 2132{ 2133 return accessibilitySettings_->SetShortKeyState(state); 2134} 2135 2136RetError AccessibleAbilityManagerService::SetMouseKeyState(const bool state) 2137{ 2138 return accessibilitySettings_->SetMouseKeyState(state); 2139} 2140 2141RetError AccessibleAbilityManagerService::SetMouseAutoClick(const int32_t time) 2142{ 2143 return accessibilitySettings_->SetMouseAutoClick(time); 2144} 2145 2146RetError AccessibleAbilityManagerService::SetShortkeyTarget(const std::string &name) 2147{ 2148 return accessibilitySettings_->SetShortkeyTarget(name); 2149} 2150 2151RetError AccessibleAbilityManagerService::SetShortkeyMultiTarget(const std::vector<std::string> &name) 2152{ 2153 return accessibilitySettings_->SetShortkeyMultiTarget(name); 2154} 2155 2156RetError AccessibleAbilityManagerService::SetHighContrastTextState(const bool state) 2157{ 2158 return accessibilitySettings_->SetHighContrastTextState(state); 2159} 2160 2161RetError AccessibleAbilityManagerService::SetDaltonizationState(const bool state) 2162{ 2163 return accessibilitySettings_->SetDaltonizationState(state); 2164} 2165 2166RetError AccessibleAbilityManagerService::SetInvertColorState(const bool state) 2167{ 2168 return accessibilitySettings_->SetInvertColorState(state); 2169} 2170 2171RetError AccessibleAbilityManagerService::SetAnimationOffState(const bool state) 2172{ 2173 return accessibilitySettings_->SetAnimationOffState(state); 2174} 2175 2176RetError AccessibleAbilityManagerService::SetAudioMonoState(const bool state) 2177{ 2178 return accessibilitySettings_->SetAudioMonoState(state); 2179} 2180 2181RetError AccessibleAbilityManagerService::SetDaltonizationColorFilter(const uint32_t filter) 2182{ 2183 return accessibilitySettings_->SetDaltonizationColorFilter(filter); 2184} 2185 2186RetError AccessibleAbilityManagerService::SetContentTimeout(const uint32_t time) 2187{ 2188 return accessibilitySettings_->SetContentTimeout(time); 2189} 2190 2191RetError AccessibleAbilityManagerService::SetBrightnessDiscount(const float discount) 2192{ 2193 return accessibilitySettings_->SetBrightnessDiscount(discount); 2194} 2195 2196RetError AccessibleAbilityManagerService::SetAudioBalance(const float balance) 2197{ 2198 return accessibilitySettings_->SetAudioBalance(balance); 2199} 2200 2201RetError AccessibleAbilityManagerService::SetClickResponseTime(const uint32_t time) 2202{ 2203 return accessibilitySettings_->SetClickResponseTime(time); 2204} 2205 2206RetError AccessibleAbilityManagerService::SetIgnoreRepeatClickState(const bool state) 2207{ 2208 return accessibilitySettings_->SetIgnoreRepeatClickState(state); 2209} 2210 2211RetError AccessibleAbilityManagerService::SetIgnoreRepeatClickTime(const uint32_t time) 2212{ 2213 return accessibilitySettings_->SetIgnoreRepeatClickTime(time); 2214} 2215 2216RetError AccessibleAbilityManagerService::GetScreenMagnificationState(bool &state) 2217{ 2218 return accessibilitySettings_->GetScreenMagnificationState(state); 2219} 2220 2221RetError AccessibleAbilityManagerService::GetShortKeyState(bool &state) 2222{ 2223 return accessibilitySettings_->GetShortKeyState(state); 2224} 2225 2226RetError AccessibleAbilityManagerService::GetMouseKeyState(bool &state) 2227{ 2228 return accessibilitySettings_->GetMouseKeyState(state); 2229} 2230 2231RetError AccessibleAbilityManagerService::GetMouseAutoClick(int32_t &time) 2232{ 2233 return accessibilitySettings_->GetMouseAutoClick(time); 2234} 2235 2236RetError AccessibleAbilityManagerService::GetShortkeyTarget(std::string &name) 2237{ 2238 return accessibilitySettings_->GetShortkeyTarget(name); 2239} 2240 2241RetError AccessibleAbilityManagerService::GetShortkeyMultiTarget(std::vector<std::string> &name) 2242{ 2243 return accessibilitySettings_->GetShortkeyMultiTarget(name); 2244} 2245 2246RetError AccessibleAbilityManagerService::GetHighContrastTextState(bool &state) 2247{ 2248 return accessibilitySettings_->GetHighContrastTextState(state); 2249} 2250 2251RetError AccessibleAbilityManagerService::GetDaltonizationState(bool &state) 2252{ 2253 return accessibilitySettings_->GetDaltonizationState(state); 2254} 2255 2256RetError AccessibleAbilityManagerService::GetInvertColorState(bool &state) 2257{ 2258 return accessibilitySettings_->GetInvertColorState(state); 2259} 2260 2261RetError AccessibleAbilityManagerService::GetAnimationOffState(bool &state) 2262{ 2263 return accessibilitySettings_->GetAnimationOffState(state); 2264} 2265 2266RetError AccessibleAbilityManagerService::GetAudioMonoState(bool &state) 2267{ 2268 return accessibilitySettings_->GetAudioMonoState(state); 2269} 2270 2271RetError AccessibleAbilityManagerService::GetDaltonizationColorFilter(uint32_t &type) 2272{ 2273 return accessibilitySettings_->GetDaltonizationColorFilter(type); 2274} 2275 2276RetError AccessibleAbilityManagerService::GetContentTimeout(uint32_t &timer) 2277{ 2278 return accessibilitySettings_->GetContentTimeout(timer); 2279} 2280 2281RetError AccessibleAbilityManagerService::GetBrightnessDiscount(float &brightness) 2282{ 2283 return accessibilitySettings_->GetBrightnessDiscount(brightness); 2284} 2285 2286RetError AccessibleAbilityManagerService::GetAudioBalance(float &balance) 2287{ 2288 return accessibilitySettings_->GetAudioBalance(balance); 2289} 2290 2291RetError AccessibleAbilityManagerService::GetClickResponseTime(uint32_t &time) 2292{ 2293 return accessibilitySettings_->GetClickResponseTime(time); 2294} 2295 2296RetError AccessibleAbilityManagerService::GetIgnoreRepeatClickState(bool &state) 2297{ 2298 return accessibilitySettings_->GetIgnoreRepeatClickState(state); 2299} 2300 2301RetError AccessibleAbilityManagerService::GetIgnoreRepeatClickTime(uint32_t &time) 2302{ 2303 return accessibilitySettings_->GetIgnoreRepeatClickTime(time); 2304} 2305 2306void AccessibleAbilityManagerService::GetAllConfigs(AccessibilityConfigData &configData) 2307{ 2308 HILOG_DEBUG(); 2309 XCollieHelper timer(TIMER_GET_ALL_CONFIG, XCOLLIE_TIMEOUT); 2310 std::shared_ptr<ffrt::promise<void>> syncPromise = std::make_shared<ffrt::promise<void>>(); 2311 std::shared_ptr<AccessibilityConfigData> config = std::make_shared<AccessibilityConfigData>(); 2312 if (syncPromise == nullptr || config == nullptr) { 2313 HILOG_WARN("create syncPromise or config failed"); 2314 return; 2315 } 2316 ffrt::future syncFuture = syncPromise->get_future(); 2317 actionHandler_->PostTask([this, syncPromise, config]() { 2318 HILOG_DEBUG(); 2319 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData(); 2320 if (!accountData) { 2321 HILOG_ERROR("accountData is nullptr"); 2322 syncPromise->set_value(); 2323 return; 2324 } 2325 2326 config->highContrastText_ = accountData->GetConfig()->GetHighContrastTextState(); 2327 config->daltonizationState_ = accountData->GetConfig()->GetDaltonizationState(); 2328 config->invertColor_ = accountData->GetConfig()->GetInvertColorState(); 2329 config->animationOff_ = accountData->GetConfig()->GetAnimationOffState(); 2330 config->audioMono_ = accountData->GetConfig()->GetAudioMonoState(); 2331 config->mouseKey_ = accountData->GetConfig()->GetMouseKeyState(); 2332 config->captionState_ = accountData->GetConfig()->GetCaptionState(); 2333 config->screenMagnifier_ = accountData->GetConfig()->GetScreenMagnificationState(); 2334 config->shortkey_ = accountData->GetConfig()->GetShortKeyState(); 2335 config->mouseAutoClick_ = accountData->GetConfig()->GetMouseAutoClick(); 2336 config->daltonizationColorFilter_ = accountData->GetConfig()->GetDaltonizationColorFilter(); 2337 config->contentTimeout_ = accountData->GetConfig()->GetContentTimeout(); 2338 config->brightnessDiscount_ = accountData->GetConfig()->GetBrightnessDiscount(); 2339 config->audioBalance_ = accountData->GetConfig()->GetAudioBalance(); 2340 config->shortkeyTarget_ = accountData->GetConfig()->GetShortkeyTarget(); 2341 config->shortkeyMultiTarget_ = accountData->GetConfig()->GetShortkeyMultiTarget(); 2342 config->captionProperty_ = accountData->GetConfig()->GetCaptionProperty(); 2343 syncPromise->set_value(); 2344 }, "TASK_GET_ALL_CONFIGS"); 2345 2346 ffrt::future_status wait = syncFuture.wait_for(std::chrono::milliseconds(TIME_OUT_OPERATOR)); 2347 if (wait != ffrt::future_status::ready) { 2348 HILOG_ERROR("Failed to wait GetAllConfigs result"); 2349 return; 2350 } 2351 configData = *config; 2352 return syncFuture.get(); 2353} 2354 2355bool AccessibleAbilityManagerService::EnableShortKeyTargetAbility(const std::string &name) 2356{ 2357 HILOG_DEBUG(); 2358 HILOG_INFO("EnableShortKeyTargetAbility name = %{public}s", name.c_str()); 2359#ifdef OHOS_BUILD_ENABLE_HITRACE 2360 HITRACE_METER_NAME(HITRACE_TAG_ACCESSIBILITY_MANAGER, "EnableShortKeyTargetAbility"); 2361#endif // OHOS_BUILD_ENABLE_HITRACE 2362 2363 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData(); 2364 if (!accountData) { 2365 HILOG_ERROR("accountData is nullptr"); 2366 return false; 2367 } 2368 2369 std::string targetAbility; 2370 if (name != "") { 2371 targetAbility = name; 2372 } else { 2373 targetAbility = accountData->GetConfig()->GetShortkeyTarget(); 2374 HILOG_DEBUG("target ability is [%{public}s]", targetAbility.c_str()); 2375 if (targetAbility == "") { 2376 HILOG_ERROR("target ability is null"); 2377 return false; 2378 } 2379 } 2380 2381 auto it = AccessibilityConfigTable.find(targetAbility); 2382 if (it != AccessibilityConfigTable.end()) { 2383 return SetTargetAbility(it->second); 2384 } 2385 2386 uint32_t capabilities = CAPABILITY_GESTURE | CAPABILITY_KEY_EVENT_OBSERVER | CAPABILITY_RETRIEVE | 2387 CAPABILITY_TOUCH_GUIDE | CAPABILITY_ZOOM; 2388 RetError enableState = accountData->EnableAbility(targetAbility, capabilities); 2389 if (enableState == RET_ERR_CONNECTION_EXIST) { 2390 HILOG_DEBUG(); 2391 return InnerDisableAbility(targetAbility) == RET_OK; 2392 } 2393 return enableState == RET_OK; 2394} 2395 2396void AccessibleAbilityManagerService::OnShortKeyProcess() 2397{ 2398 HILOG_DEBUG(); 2399 2400 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData(); 2401 if (accountData == nullptr) { 2402 HILOG_ERROR("accountData is nullptr"); 2403 return; 2404 } 2405 2406 std::shared_ptr<AccessibilityShortkeyDialog> shortkeyDialog = std::make_shared<AccessibilityShortkeyDialog>(); 2407 2408 std::shared_ptr<AccessibilitySettingProvider> service = 2409 AccessibilitySettingProvider::GetInstance(POWER_MANAGER_SERVICE_ID); 2410 if (service == nullptr) { 2411 HILOG_ERROR("service is nullptr"); 2412 return; 2413 } 2414 bool oobeState = false; 2415 bool userSetupState = false; 2416 service->GetBoolValue(DEVICE_PROVISIONED, oobeState); 2417 if (accountData->GetConfig()->GetDbHandle()) { 2418 userSetupState = accountData->GetConfig()->GetDbHandle()->GetBoolValue(USER_SETUP_COMPLETED, false); 2419 } 2420 if (oobeState && userSetupState) { 2421 int32_t shortKeyTimeout = accountData->GetConfig()->GetShortKeyTimeout(); 2422 if (shortKeyTimeout == SHORT_KEY_TIMEOUT_BEFORE_USE) { 2423 HILOG_INFO("first use short cut key"); 2424 accountData->GetConfig()->SetShortKeyTimeout(SHORT_KEY_TIMEOUT_AFTER_USE); 2425 shortkeyDialog->ConnectDialog(ShortKeyDialogType::RECONFIRM); 2426 return; 2427 } 2428 } 2429 2430 std::vector<std::string> shortkeyMultiTarget = accountData->GetConfig()->GetShortkeyMultiTarget(); 2431 if (shortkeyMultiTarget.size() == 0) { 2432 EnableShortKeyTargetAbility(); 2433 } else if (shortkeyMultiTarget.size() == 1) { 2434 EnableShortKeyTargetAbility(shortkeyMultiTarget[0]); 2435 } else { 2436 // dialog 2437 if (shortkeyDialog->ConnectDialog(ShortKeyDialogType::FUNCTION_SELECT)) { 2438 HILOG_DEBUG("ready to build dialog"); 2439 } 2440 } 2441} 2442 2443bool AccessibleAbilityManagerService::DisableShortKeyTargetAbility() 2444{ 2445 HILOG_DEBUG(); 2446 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData(); 2447 if (!accountData) { 2448 HILOG_ERROR("accountData is nullptr"); 2449 return false; 2450 } 2451 2452 std::string targetAbility = accountData->GetConfig()->GetShortkeyTarget(); 2453 HILOG_DEBUG("target ability is [%{public}s]", targetAbility.c_str()); 2454 if (targetAbility == "") { 2455 HILOG_ERROR("target ability is null"); 2456 return false; 2457 } 2458 return InnerDisableAbility(targetAbility) == RET_OK; 2459} 2460 2461uint32_t AccessibleAbilityManagerService::RegisterConfigObserver( 2462 const sptr<IAccessibleAbilityManagerConfigObserver> &callback) 2463{ 2464 HILOG_DEBUG(); 2465 if (!callback || !actionHandler_) { 2466 HILOG_ERROR("Parameters check failed!"); 2467 return ERR_INVALID_VALUE; 2468 } 2469 XCollieHelper timer(TIMER_REGISTER_CONFIG_OBSERVER, XCOLLIE_TIMEOUT); 2470 std::shared_ptr<ffrt::promise<uint32_t>> syncPromisePtr = std::make_shared<ffrt::promise<uint32_t>>(); 2471 ffrt::future syncFuture = syncPromisePtr->get_future(); 2472 actionHandler_->PostTask([this, syncPromisePtr, callback]() { 2473 HILOG_DEBUG(); 2474 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData(); 2475 if (!accountData) { 2476 HILOG_ERROR("Account data is null"); 2477 syncPromisePtr->set_value(ERR_INVALID_VALUE); 2478 return; 2479 } 2480 if (!configCallbackDeathRecipient_) { 2481 configCallbackDeathRecipient_ = new(std::nothrow) ConfigCallbackDeathRecipient(); 2482 if (!configCallbackDeathRecipient_) { 2483 HILOG_ERROR("configCallbackDeathRecipient_ is null"); 2484 syncPromisePtr->set_value(ERR_INVALID_VALUE); 2485 return; 2486 } 2487 } 2488 if (!callback->AsObject()) { 2489 HILOG_ERROR("object is null"); 2490 syncPromisePtr->set_value(0); 2491 return; 2492 } 2493 callback->AsObject()->AddDeathRecipient(configCallbackDeathRecipient_); 2494 accountData->AddConfigCallback(callback); 2495 HILOG_DEBUG("the size of caption property callbacks is %{public}zu", 2496 accountData->GetConfigCallbacks().size()); 2497 syncPromisePtr->set_value(NO_ERROR); 2498 }, "TASK_REGISTER_CONFIG_OBSERVER"); 2499 2500 ffrt::future_status wait = syncFuture.wait_for(std::chrono::milliseconds(TIME_OUT_OPERATOR)); 2501 if (wait != ffrt::future_status::ready) { 2502 HILOG_ERROR("Failed to wait RegisterConfigObserver result"); 2503 return RET_ERR_TIME_OUT; 2504 } 2505 return syncFuture.get(); 2506} 2507 2508void AccessibleAbilityManagerService::ConfigCallbackDeathRecipient::OnRemoteDied( 2509 const wptr<IRemoteObject> &remote) 2510{ 2511 Singleton<AccessibleAbilityManagerService>::GetInstance().RemoveCallback(CONFIG_CALLBACK, this, remote); 2512} 2513 2514void AccessibleAbilityManagerService::BundleManagerDeathRecipient::OnRemoteDied( 2515 const wptr<IRemoteObject> &remote) 2516{ 2517 Singleton<AccessibleAbilityManagerService>::GetInstance().OnBundleManagerDied(remote); 2518} 2519 2520void AccessibleAbilityManagerService::UpdateConfigState() 2521{ 2522 return accessibilitySettings_->UpdateConfigState(); 2523} 2524 2525void AccessibleAbilityManagerService::UpdateAudioBalance() 2526{ 2527 return accessibilitySettings_->UpdateAudioBalance(); 2528} 2529 2530void AccessibleAbilityManagerService::UpdateBrightnessDiscount() 2531{ 2532 return accessibilitySettings_->UpdateBrightnessDiscount(); 2533} 2534 2535void AccessibleAbilityManagerService::UpdateContentTimeout() 2536{ 2537 return accessibilitySettings_->UpdateContentTimeout(); 2538} 2539 2540void AccessibleAbilityManagerService::UpdateDaltonizationColorFilter() 2541{ 2542 return accessibilitySettings_->UpdateDaltonizationColorFilter(); 2543} 2544 2545void AccessibleAbilityManagerService::UpdateMouseAutoClick() 2546{ 2547 return accessibilitySettings_->UpdateMouseAutoClick(); 2548} 2549 2550void AccessibleAbilityManagerService::UpdateShortkeyTarget() 2551{ 2552 return accessibilitySettings_->UpdateShortkeyTarget(); 2553} 2554 2555void AccessibleAbilityManagerService::UpdateShortkeyMultiTarget() 2556{ 2557 return accessibilitySettings_->UpdateShortkeyMultiTarget(); 2558} 2559 2560void AccessibleAbilityManagerService::UpdateClickResponseTime() 2561{ 2562 return accessibilitySettings_->UpdateClickResponseTime(); 2563} 2564 2565void AccessibleAbilityManagerService::UpdateIgnoreRepeatClickTime() 2566{ 2567 return accessibilitySettings_->UpdateIgnoreRepeatClickTime(); 2568} 2569 2570void AccessibleAbilityManagerService::RemoveCallback(CallBackID callback, 2571 const sptr<DeathRecipient> &recipient, const wptr<IRemoteObject> &remote) 2572{ 2573 HILOG_INFO("remove callback[%{public}d]", callback); 2574 if (!handler_) { 2575 HILOG_ERROR("handler is nullptr"); 2576 return; 2577 } 2578 handler_->PostTask([=]() { 2579 if (!remote.GetRefPtr()) { 2580 HILOG_ERROR("remote is null"); 2581 return; 2582 } 2583 remote->RemoveDeathRecipient(recipient); 2584 2585 if (callback == CONFIG_CALLBACK) { 2586 RemoveSavedConfigCallback(remote); 2587 } 2588 auto accountData = GetCurrentAccountData(); 2589 if (!accountData) { 2590 HILOG_ERROR("Current account data is null"); 2591 return; 2592 } 2593 switch (callback) { 2594 case STATE_CALLBACK: 2595 stateObservers_.RemoveStateObserver(remote); 2596 break; 2597 case CAPTION_PROPERTY_CALLBACK: 2598 accountData->RemoveCaptionPropertyCallback(remote); 2599 break; 2600 case ENABLE_ABILITY_LISTS_CALLBACK: 2601 accountData->RemoveEnableAbilityListsObserver(remote); 2602 break; 2603 case CONFIG_CALLBACK: 2604 accountData->RemoveConfigCallback(remote); 2605 break; 2606 default: 2607 break; 2608 } 2609 }, "RemoveCallback"); 2610} 2611 2612void AccessibleAbilityManagerService::RemoveSavedConfigCallback(const wptr<IRemoteObject>& callback) 2613{ 2614 HILOG_DEBUG("start."); 2615 for (auto itr = defaultConfigCallbacks_.begin(); itr != defaultConfigCallbacks_.end(); itr++) { 2616 if ((*itr)->AsObject() == callback) { 2617 defaultConfigCallbacks_.erase(itr); 2618 break; 2619 } 2620 } 2621} 2622 2623void AccessibleAbilityManagerService::OnBundleManagerDied(const wptr<IRemoteObject> &remote) 2624{ 2625 HILOG_INFO("OnBundleManagerDied "); 2626 if (!handler_) { 2627 HILOG_ERROR("handler is nullptr"); 2628 return; 2629 } 2630 2631 handler_->PostTask([=]() { 2632 if (!remote.GetRefPtr() || !bundleManager_) { 2633 HILOG_ERROR("remote is null"); 2634 return; 2635 } 2636 2637 bundleManager_->AsObject()->RemoveDeathRecipient(bundleManagerDeathRecipient_); 2638 bundleManager_ = nullptr; 2639 }, "OnBundleManagerDied"); 2640} 2641 2642void AccessibleAbilityManagerService::StateObservers::AddStateObserver( 2643 const sptr<IAccessibleAbilityManagerStateObserver>& stateObserver) 2644{ 2645 std::lock_guard<ffrt::mutex> lock(stateObserversMutex_); 2646 auto iter = std::find(observersList_.begin(), observersList_.end(), stateObserver); 2647 if (iter == observersList_.end()) { 2648 observersList_.push_back(stateObserver); 2649 HILOG_DEBUG("register state observer successfully"); 2650 return; 2651 } 2652 2653 HILOG_INFO("state observer is existed"); 2654} 2655 2656void AccessibleAbilityManagerService::StateObservers::OnStateObservers(uint32_t state) 2657{ 2658 std::lock_guard<ffrt::mutex> lock(stateObserversMutex_); 2659 for (auto& stateObserver : observersList_) { 2660 if (stateObserver) { 2661 stateObserver->OnStateChanged(state); 2662 } 2663 } 2664} 2665 2666void AccessibleAbilityManagerService::StateObservers::RemoveStateObserver(const wptr<IRemoteObject> &remote) 2667{ 2668 std::lock_guard<ffrt::mutex> lock(stateObserversMutex_); 2669 auto iter = std::find_if(observersList_.begin(), observersList_.end(), 2670 [remote](const sptr<IAccessibleAbilityManagerStateObserver>& stateObserver) { 2671 return stateObserver->AsObject() == remote; 2672 }); 2673 if (iter != observersList_.end()) { 2674 observersList_.erase(iter); 2675 } 2676} 2677 2678void AccessibleAbilityManagerService::StateObservers::Clear() 2679{ 2680 std::lock_guard<ffrt::mutex> lock(stateObserversMutex_); 2681 observersList_.clear(); 2682} 2683 2684RetError AccessibleAbilityManagerService::GetFocusedWindowId(int32_t &focusedWindowId) 2685{ 2686 HILOG_DEBUG(); 2687 return Singleton<AccessibilityWindowManager>::GetInstance().GetFocusedWindowId(focusedWindowId); 2688} 2689 2690void AccessibleAbilityManagerService::InsertWindowIdEventPair(int32_t windowId, const AccessibilityEventInfo &event) 2691{ 2692 HILOG_DEBUG("insert event, windowId: %{public}d", windowId); 2693 windowFocusEventMap_[windowId] = event; 2694} 2695 2696bool AccessibleAbilityManagerService::CheckWindowIdEventExist(int32_t windowId) 2697{ 2698 return windowFocusEventMap_.count(windowId); 2699} 2700 2701bool AccessibleAbilityManagerService::CheckWindowRegister(int32_t windowId) 2702{ 2703 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData(); 2704 if (!accountData) { 2705 HILOG_ERROR("accountData is nullptr."); 2706 return false; 2707 } 2708 return accountData->GetAccessibilityWindowConnection(windowId) != nullptr; 2709} 2710 2711void AccessibleAbilityManagerService::OnDeviceProvisioned() 2712{ 2713 HILOG_DEBUG(); 2714 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData(); 2715 if (!accountData) { 2716 HILOG_ERROR("accountData is nullptr"); 2717 return; 2718 } 2719 std::shared_ptr<AccessibilitySettingProvider> service = 2720 AccessibilitySettingProvider::GetInstance(POWER_MANAGER_SERVICE_ID); 2721 if (service == nullptr) { 2722 HILOG_ERROR("service is nullptr"); 2723 return; 2724 } 2725 service->UnregisterObserver(DEVICE_PROVISIONED); 2726 if (accountData->GetConfig()->GetDbHandle()) { 2727 accountData->GetConfig()->GetDbHandle()->UnregisterObserver(USER_SETUP_COMPLETED); 2728 } 2729 if (accountData->GetDefaultUserScreenReaderState()) { 2730 HILOG_INFO("Modify shortKeyTimeout and shortKeyOnLockScreenState"); 2731 accountData->GetConfig()->SetShortKeyTimeout(SHORT_KEY_TIMEOUT_AFTER_USE); 2732 accountData->GetConfig()->SetShortKeyOnLockScreenState(true); 2733 UpdateConfigState(); 2734 } 2735} 2736 2737void AccessibleAbilityManagerService::InitializeShortKeyState() 2738{ 2739 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData(); 2740 if (!accountData) { 2741 HILOG_ERROR("accountData is nullptr"); 2742 return; 2743 } 2744 2745 bool shortKeyFlag = false; 2746 if (accountData->GetAccountId() != DEFAULT_ACCOUNT_ID && accountData->GetConfig()->GetDbHandle() != nullptr) { 2747 if (accountData->GetConfig()->GetDbHandle()->GetIntValue(SHORTCUT_ENABLED, INVALID_SHORTCUT_STATE) == 2748 INVALID_SHORTCUT_STATE) { 2749 HILOG_INFO("Initialize the shortcut key state of PrivateSpace"); 2750 shortKeyFlag = true; 2751 } 2752 } else if (accountData->GetAccountId() == DEFAULT_ACCOUNT_ID) { 2753 HILOG_INFO("Initialize the shortcut key state of MainSpace"); 2754 shortKeyFlag = true; 2755 } 2756 2757 if (shortKeyFlag) { 2758 accountData->GetConfig()->SetShortKeyState(true); 2759 std::vector<std::string> tmpVec { SCREEN_READER_BUNDLE_ABILITY_NAME }; 2760 accountData->GetConfig()->SetShortkeyMultiTarget(tmpVec); 2761 UpdateConfigState(); 2762 Singleton<AccessibleAbilityManagerService>::GetInstance().UpdateShortKeyRegister(); 2763 } 2764} 2765 2766void AccessibleAbilityManagerService::RegisterProvisionCallback() 2767{ 2768 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData(); 2769 if (!accountData) { 2770 HILOG_ERROR("accountData is nullptr"); 2771 return; 2772 } 2773 2774 std::shared_ptr<AccessibilitySettingProvider> service = 2775 AccessibilitySettingProvider::GetInstance(POWER_MANAGER_SERVICE_ID); 2776 if (service == nullptr) { 2777 HILOG_ERROR("service is nullptr"); 2778 return; 2779 } 2780 AccessibilitySettingObserver::UpdateFunc func = [ = ](const std::string &state) { 2781 Singleton<AccessibleAbilityManagerService>::GetInstance().OnDeviceProvisioned(); 2782 }; 2783 service->RegisterObserver(DEVICE_PROVISIONED, func); 2784 if (accountData->GetConfig()->GetDbHandle() != nullptr) { 2785 accountData->GetConfig()->GetDbHandle()->RegisterObserver(USER_SETUP_COMPLETED, func); 2786 } 2787} 2788 2789void AccessibleAbilityManagerService::RegisterShortKeyEvent() 2790{ 2791 HILOG_DEBUG(); 2792 if (!handler_) { 2793 HILOG_ERROR("handler_ is nullptr"); 2794 return; 2795 } 2796 handler_->PostTask([=]() { 2797 HILOG_DEBUG(); 2798 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData(); 2799 if (!accountData) { 2800 HILOG_ERROR("accountData is nullptr"); 2801 return; 2802 } 2803 std::shared_ptr<AccessibilitySettingProvider> service = 2804 AccessibilitySettingProvider::GetInstance(POWER_MANAGER_SERVICE_ID); 2805 if (service == nullptr) { 2806 HILOG_ERROR("service is nullptr"); 2807 return; 2808 } 2809 bool oobeState = false; 2810 bool userSetupState = false; 2811 service->GetBoolValue(DEVICE_PROVISIONED, oobeState); 2812 if (accountData->GetConfig()->GetDbHandle() != nullptr) { 2813 userSetupState = accountData->GetConfig()->GetDbHandle()->GetBoolValue(USER_SETUP_COMPLETED, false); 2814 } 2815 if (accountData->GetAccountId() == DEFAULT_ACCOUNT_ID && (oobeState == false || userSetupState == false)) { 2816 InitializeShortKeyState(); 2817 RegisterProvisionCallback(); 2818 } else if (accountData->GetAccountId() != DEFAULT_ACCOUNT_ID) { 2819 InitializeShortKeyState(); 2820 } 2821 }, "REGISTER_SHORTKEY_OBSERVER"); 2822} 2823 2824void AccessibleAbilityManagerService::OffZoomGesture() 2825{ 2826 HILOG_INFO(); 2827#ifdef OHOS_BUILD_ENABLE_DISPLAY_MANAGER 2828 AccessibilityDisplayManager &displayMgr = Singleton<AccessibilityDisplayManager>::GetInstance(); 2829 uint64_t currentScreen = displayMgr.GetDefaultDisplayId(); 2830 float normalScale = 1.0f; 2831 float defaultAnchor = 0.5f; 2832 displayMgr.SetDisplayScale(currentScreen, normalScale, normalScale, defaultAnchor, defaultAnchor); 2833 return; 2834#else 2835 HILOG_INFO("not support zoom"); 2836 return; 2837#endif 2838} 2839 2840void AccessibleAbilityManagerService::OnScreenMagnificationStateChanged() 2841{ 2842 HILOG_DEBUG(); 2843 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData(); 2844 if (accountData == nullptr) { 2845 HILOG_ERROR("accountData is nullptr"); 2846 return; 2847 } 2848 2849 std::shared_ptr<AccessibilitySettingsConfig> config = accountData->GetConfig(); 2850 if (config == nullptr) { 2851 HILOG_ERROR("config is nullptr"); 2852 return; 2853 } 2854 2855 if (config->GetDbHandle() == nullptr) { 2856 HILOG_ERROR("datashareHelper is nullptr"); 2857 return; 2858 } 2859 2860 bool screenMagnificationEnabled = false; 2861 screenMagnificationEnabled = config->GetDbHandle()->GetBoolValue(SCREEN_MAGNIFICATION_KEY, false); 2862 config->SetScreenMagnificationState(screenMagnificationEnabled); 2863 Singleton<AccessibleAbilityManagerService>::GetInstance().UpdateInputFilter(); 2864 if (!screenMagnificationEnabled) { 2865 OffZoomGesture(); 2866 } 2867} 2868 2869void AccessibleAbilityManagerService::RegisterScreenMagnificationState() 2870{ 2871 HILOG_DEBUG(); 2872 if (handler_ == nullptr) { 2873 HILOG_ERROR("handler_ is nullptr"); 2874 return; 2875 } 2876 handler_->PostTask([=]() { 2877 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData(); 2878 if (accountData == nullptr) { 2879 HILOG_ERROR("accountData is nullptr"); 2880 return; 2881 } 2882 2883 AccessibilitySettingObserver::UpdateFunc func = [ = ](const std::string &state) { 2884 Singleton<AccessibleAbilityManagerService>::GetInstance().OnScreenMagnificationStateChanged(); 2885 }; 2886 if (accountData->GetConfig()->GetDbHandle()) { 2887 accountData->GetConfig()->GetDbHandle()->RegisterObserver(SCREEN_MAGNIFICATION_KEY, func); 2888 } 2889 }, "REGISTER_SCREEN_ZOOM_OBSERVER"); 2890} 2891 2892void AccessibleAbilityManagerService::OnScreenMagnificationTypeChanged() 2893{ 2894 HILOG_DEBUG(); 2895 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData(); 2896 if (accountData == nullptr) { 2897 HILOG_ERROR("accountData is nullptr"); 2898 return; 2899 } 2900 2901 std::shared_ptr<AccessibilitySettingsConfig> config = accountData->GetConfig(); 2902 if (config == nullptr) { 2903 HILOG_ERROR("config is nullptr"); 2904 return; 2905 } 2906 2907 if (config->GetDbHandle() == nullptr) { 2908 HILOG_ERROR("datashareHelper is nullptr"); 2909 return; 2910 } 2911 2912 uint32_t screenMagnificationType = 0; 2913 screenMagnificationType = 2914 static_cast<uint32_t>(config->GetDbHandle()->GetIntValue(SCREEN_MAGNIFICATION_TYPE, 0)); 2915 config->SetScreenMagnificationType(screenMagnificationType); 2916 Singleton<AccessibleAbilityManagerService>::GetInstance().UpdateInputFilter(); 2917} 2918 2919void AccessibleAbilityManagerService::RegisterScreenMagnificationType() 2920{ 2921 HILOG_DEBUG(); 2922 if (handler_ == nullptr) { 2923 HILOG_ERROR("handler_ is nullptr"); 2924 return; 2925 } 2926 handler_->PostTask([=]() { 2927 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData(); 2928 if (accountData == nullptr) { 2929 HILOG_ERROR("accountData is nullptr"); 2930 return; 2931 } 2932 2933 AccessibilitySettingObserver::UpdateFunc func = [ = ](const std::string &state) { 2934 Singleton<AccessibleAbilityManagerService>::GetInstance().OnScreenMagnificationTypeChanged(); 2935 }; 2936 if (accountData->GetConfig()->GetDbHandle()) { 2937 accountData->GetConfig()->GetDbHandle()->RegisterObserver(SCREEN_MAGNIFICATION_TYPE, func); 2938 } 2939 }, "REGISTER_SCREEN_ZOOM_TYPE_OBSERVER"); 2940} 2941 2942void AccessibleAbilityManagerService::PostDelayUnloadTask() 2943{ 2944 auto task = [=]() { 2945 sptr<ISystemAbilityManager> systemAbilityManager = 2946 SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager(); 2947 if (systemAbilityManager == nullptr) { 2948 HILOG_ERROR("failed to get system ability mgr"); 2949 return; 2950 } 2951 if (!IsNeedUnload()) { 2952 return; 2953 } 2954 int32_t ret = systemAbilityManager->UnloadSystemAbility(ACCESSIBILITY_MANAGER_SERVICE_ID); 2955 if (ret != ERR_OK) { 2956 HILOG_ERROR("unload system ability failed"); 2957 return; 2958 } 2959 }; 2960 handler_->RemoveTask(DELAY_UNLOAD_TASK); 2961 handler_->PostTask(task, DELAY_UNLOAD_TASK, UNLOAD_TASK_INTERNAL); 2962} 2963 2964bool AccessibleAbilityManagerService::IsNeedUnload() 2965{ 2966 HILOG_DEBUG(); 2967#ifndef ACCESSIBILITY_WATCH_FEATURE 2968 // always return true to avoid stablity problem 2969 return false; 2970#else // for watch 2971 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData(); 2972 if (!accountData) { 2973 HILOG_ERROR("accountData is nullptr"); 2974 return true; 2975 } 2976 2977 // do not unload when any extension is enabled 2978 std::vector<std::string> enableAbilityList = accountData->GetEnabledAbilities(); 2979 if (enableAbilityList.size() != 0) { 2980 return false; 2981 } 2982 return true; 2983#endif // ACCESSIBILITY_WATCH_FEATURE 2984} 2985 2986int32_t AccessibleAbilityManagerService::GetTreeIdBySplitElementId(const int64_t elementId) 2987{ 2988 if (elementId < 0) { 2989 HILOG_DEBUG("The elementId is -1"); 2990 return elementId; 2991 } 2992 int32_t treeId = (static_cast<uint64_t>(elementId) >> ELEMENT_MOVE_BIT); 2993 return treeId; 2994} 2995 2996void AccessibleAbilityManagerService::AddRequestId(int32_t windowId, int32_t treeId, int32_t requestId, 2997 sptr<IAccessibilityElementOperatorCallback> callback) 2998{ 2999 std::lock_guard<ffrt::mutex> lock(mutex_); 3000 HILOG_DEBUG("Add windowId: %{public}d treeId: %{public}d requestId: %{public}d", windowId, treeId, requestId); 3001 if (!windowRequestIdMap_.count(windowId)) { 3002 windowRequestIdMap_[windowId] = {}; 3003 } 3004 if (!windowRequestIdMap_[windowId].count(treeId)) { 3005 windowRequestIdMap_[windowId][treeId] = {}; 3006 } 3007 if (!windowRequestIdMap_[windowId][treeId].count(requestId)) { 3008 windowRequestIdMap_[windowId][treeId].insert(requestId); 3009 requestIdMap_[requestId] = callback; 3010 } 3011} 3012 3013void AccessibleAbilityManagerService::RemoveRequestId(int32_t requestId) 3014{ 3015 std::lock_guard<ffrt::mutex> lock(mutex_); 3016 HILOG_DEBUG("RemoveRequestId requestId: %{public}d", requestId); 3017 for (auto &window : windowRequestIdMap_) { 3018 for (auto &tree : window.second) { 3019 auto it = tree.second.find(requestId); 3020 if (it != tree.second.end()) { 3021 HILOG_DEBUG("tree.second.erase requestId:%{public}d", requestId); 3022 tree.second.erase(it); 3023 } 3024 auto ite = requestIdMap_.find(requestId); 3025 if (ite != requestIdMap_.end()) { 3026 HILOG_DEBUG("requestIdMap_.erase requestId:%{public}d", requestId); 3027 requestIdMap_.erase(ite); 3028 } 3029 } 3030 } 3031} 3032 3033void AccessibleAbilityManagerService::StopCallbackWait(int32_t windowId) 3034{ 3035 HILOG_INFO("StopCallbackWait start windowId: %{public}d", windowId); 3036 if (!windowRequestIdMap_.count(windowId)) { 3037 HILOG_DEBUG("windowId not exists"); 3038 return; 3039 } 3040 for (auto iter = windowRequestIdMap_[windowId].begin(); iter != windowRequestIdMap_[windowId].end(); ++iter) { 3041 HILOG_DEBUG("stop callback wait windowId: %{public}d, treeId: %{public}d", windowId, iter->first); 3042 StopCallbackWait(windowId, iter->first); 3043 } 3044} 3045 3046void AccessibleAbilityManagerService::StopCallbackWait(int32_t windowId, int32_t treeId) 3047{ 3048 std::lock_guard<ffrt::mutex> lock(mutex_); 3049 HILOG_INFO("StopCallbackWait start windowId: %{public}d treeId: %{public}d", windowId, treeId); 3050 if (!windowRequestIdMap_.count(windowId)) { 3051 return; 3052 } 3053 if (!windowRequestIdMap_[windowId].count(treeId)) { 3054 return; 3055 } 3056 auto requestIds = windowRequestIdMap_[windowId][treeId]; 3057 for (auto requestId = requestIds.begin(); requestId != requestIds.end();) { 3058 HILOG_DEBUG("stop callback wait windowId: %{public}d, requestId: %{public}d", windowId, *requestId); 3059 auto iter = requestIdMap_.find(*requestId); 3060 if (iter != requestIdMap_.end()) { 3061 HILOG_DEBUG("requestIdMap_ set callback and erase requestId:%{public}d", *requestId); 3062 sptr<IAccessibilityElementOperatorCallback> callback = requestIdMap_[*requestId]; 3063 if (callback != nullptr) { 3064 callback->SetExecuteActionResult(false, *requestId); 3065 } 3066 requestIdMap_.erase(iter); 3067 } 3068 requestId = requestIds.erase(requestId); 3069 } 3070} 3071 3072int64_t AccessibleAbilityManagerService::GetRootParentId(int32_t windowId, int32_t treeId) 3073{ 3074 HILOG_INFO("aa search treeParent from aams, windowId: %{public}d, treeId: %{public}d", windowId, treeId); 3075 int64_t elementId = 0; 3076 sptr<AccessibilityWindowConnection> connection = GetAccessibilityWindowConnection(windowId); 3077 if (!connection) { 3078 HILOG_WARN("The operator of windowId[%{public}d] has not been registered.", windowId); 3079 return RET_ERR_NO_CONNECTION; 3080 } 3081 connection->GetRootParentId(treeId, elementId); 3082 return elementId; 3083} 3084 3085RetError AccessibleAbilityManagerService::GetAllTreeId(int32_t windowId, std::vector<int32_t> &treeIds) 3086{ 3087 HILOG_DEBUG(); 3088 sptr<AccessibilityWindowConnection> connection = GetAccessibilityWindowConnection(windowId); 3089 if (!connection) { 3090 HILOG_WARN("The operator of windowId[%{public}d] has not been registered.", windowId); 3091 return RET_ERR_NO_CONNECTION; 3092 } 3093 connection->GetAllTreeId(treeIds); 3094 return RET_OK; 3095} 3096 3097int32_t AccessibleAbilityManagerService::GenerateRequestId() 3098{ 3099 int32_t requestId = requestId_.fetch_add(1, std::memory_order_relaxed); 3100 if (requestId == REQUEST_ID_MAX) { 3101 requestId_ = REQUEST_ID_MIN; 3102 requestId = requestId_.fetch_add(1, std::memory_order_relaxed); 3103 } 3104 return requestId; 3105} 3106 3107RetError AccessibleAbilityManagerService::CheckCallingUid() 3108{ 3109 int32_t accountId = Utils::GetUserIdByCallingUid(); 3110 if (accountId != currentAccountId_ && accountId != ROOT_UID) { 3111 HILOG_WARN("accountId is diff from currentAccountId_."); 3112 return RET_ERR_SAMGR; 3113 } 3114 return RET_OK; 3115} 3116 3117void AccessibleAbilityManagerService::OnDataClone() 3118{ 3119 std::shared_ptr<AccessibilitySettingProvider> service = 3120 AccessibilitySettingProvider::GetInstance(POWER_MANAGER_SERVICE_ID); 3121 if (service == nullptr) { 3122 HILOG_ERROR("service is nullptr"); 3123 return; 3124 } 3125 bool cloneState = false; 3126 service->GetBoolValue(ACCESSIBILITY_CLONE_FLAG, cloneState); 3127 if (cloneState == false) { 3128 return; 3129 } 3130 sptr<AccessibilityAccountData> accountData = GetCurrentAccountData(); 3131 if (accountData == nullptr) { 3132 HILOG_WARN("accountData is nullptr."); 3133 return; 3134 } 3135 if (accountData->GetConfig() != nullptr) { 3136 accountData->GetConfig()->OnDataClone(); 3137 UpdateAllSetting(); 3138 UpdateAutoStartAbilities(); 3139 UpdateInputFilter(); 3140 HILOG_INFO("accessibility reload config."); 3141 } else { 3142 HILOG_WARN("config_ is nullptr"); 3143 } 3144} 3145} // namespace Accessibility 3146} // namespace OHOS