1/* 2 * Copyright (c) 2022-2024 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#include "accessibility_ability_command.h" 16#include "accessibility_ability_utils.h" 17 18#include <csignal> 19#include <cstdlib> 20#include <fstream> 21#include <getopt.h> 22#include <regex> 23 24#include "ability_manager_client.h" 25#include "accessibility_config.h" 26#include "accessibility_system_ability_client.h" 27#include "bool_wrapper.h" 28#include "hilog_tag_wrapper.h" 29#include "iservice_registry.h" 30#include "mission_snapshot.h" 31#include "sa_mgr_client.h" 32#include "system_ability_definition.h" 33#include "test_observer.h" 34 35using namespace OHOS::AppExecFwk; 36 37namespace OHOS { 38namespace AAFwk { 39namespace { 40const std::string ENABLE_SHORT_OPTIONS = "a:b:c:"; 41const std::string DISABLE_SHORT_OPTIONS = "a:b:"; 42const std::string SET_SHORT_OPTIONS = "v:"; 43const std::string STRING_LIST_ABILITY_NG = "error: failed to list abilities"; 44const int32_t MOUSE_AUTO_CLICK_TIME_LOW_BOUND = 1000; 45const int32_t MOUSE_AUTO_CLICK_TIME_HIGH_BOUND = 5000; 46const int32_t CONTENT_TIME_OUT_TIME_LOW_BOUND = 0; 47const int32_t CONTENT_TIME_OUT_TIME_HIGH_BOUND = 5000; 48const int32_t AUDIO_BALANCE_LOW_BOUND = -100; 49const int32_t AUDIO_BALANCE_HIGH_BOUND = 100; 50const int32_t BRIGHTNESS_DISCOUNT_LOW_BOUND = 0; 51const int32_t BRIGHTNESS_DISCOUNT_HIGH_BOUND = 100; 52const int32_t DALTIONIZATION_TYPE_LOW_BOUND = 0; 53const int32_t DALTIONIZATION_TYPE_HIGH_BOUND = 3; 54const int32_t TYPE_NORMAL = 0; 55const int32_t TYPE_PROTANOMALY = 1; 56const int32_t TYPE_DEUTERANOMALY = 2; 57const int32_t TYPE_TRITANOMALY = 3; 58const int32_t ACCESSIBILITY_ENABLE_COMMAND_ARGUMENT_NUM = 3; 59const int32_t ACCESSIBILITY_DISABLE_COMMAND_ARGUMENT_NUM = 2; 60const int32_t ACCESSIBILITY_SET_COMMAND_ARGUMENT_NUM = 1; 61 62const std::string ACCESSIBILITY_TOOL_NAME = "accessibility"; 63const std::string ACCESSIBILITY_STRING_ENABLE_ABILITY_OK = "enable ability successfully."; 64const std::string ACCESSIBILITY_STRING_ENABLE_ABILITY_NG = "error: failed to enable ability.\n"; 65 66const std::string ACCESSIBILITY_SET_SCREEN_MAGNIFICATION_STATE_OK = "set screen magnification state successfully."; 67const std::string ACCESSIBILITY_SET_SCREEN_MAGNIFICATION_STATE_NG = "error: failed to set screen magnification state\n"; 68const std::string ACCESSIBILITY_SET_SHORT_KEY_STATE_OK = "set short key state successfully."; 69const std::string ACCESSIBILITY_SET_SHORT_KEY_STATE_NG = "error: failed to set short key state.\n"; 70const std::string ACCESSIBILITY_SET_MOUSE_KEY_STATE_OK = "set mouse key state successfully."; 71const std::string ACCESSIBILITY_SET_MOUSE_KEY_STATE_NG = "error: failed to set mouse key state.\n"; 72const std::string ACCESSIBILITY_SET_CAPTION_STATE_OK = "set caption state successfully."; 73const std::string ACCESSIBILITY_SET_CAPTION_STATE_NG = "error: failed to set caption state.\n"; 74const std::string ACCESSIBILITY_SET_HIGH_CONTRAST_TEXT_STATE_OK = "set high contrast text state successfully."; 75const std::string ACCESSIBILITY_SET_HIGH_CONTRAST_TEXT_STATE_NG = "error: failed to set high contrast text state.\n"; 76const std::string ACCESSIBILITY_SET_INVERT_COLOR_STATE_OK = "set invert color state successfully."; 77const std::string ACCESSIBILITY_SET_INVERT_COLOR_STATE_NG = "error: failed to set invert color state.\n"; 78const std::string ACCESSIBILITY_SET_ANIMATION_OFF_STATE_OK = "set animation off state successfully."; 79const std::string ACCESSIBILITY_SET_ANIMATION_OFF_STATE_NG = "error: failed to set animation off state.\n"; 80const std::string ACCESSIBILITY_SET_AUDIO_MONO_STATE_OK = "set audio mono state successfully."; 81const std::string ACCESSIBILITY_SET_AUDIO_MONO_STATE_NG = "error: failed to set audio mono state.\n"; 82const std::string ACCESSIBILITY_SET_AUTO_CLICK_TIME_OK = "set mouse auto click time successfully."; 83const std::string ACCESSIBILITY_SET_AUTO_CLICK_TIME_NG = "error: failed to set mouse auto click time.\n"; 84const std::string ACCESSIBILITY_SET_SHORT_KEY_TARGET_OK = "set short key target successfully."; 85const std::string ACCESSIBILITY_SET_SHORT_KEY_TARGET_NG = "error: failed to set short key target.\n"; 86const std::string ACCESSIBILITY_SET_AUDIO_BALANCE_OK = "set audio balance successfully."; 87const std::string ACCESSIBILITY_SET_AUDIO_BALANCE_NG = "error: failed to set audio balance successfully."; 88const std::string ACCESSIBILITY_SET_CONTENT_TIME_OK = "set content timeout successfully."; 89const std::string ACCESSIBILITY_SET_CONTENT_TIME_NG = "error: failed to set content timeout.\n"; 90const std::string ACCESSIBILITY_SET_BRIGHTNESS_DISCOUNT_OK = "set brightness discount successfully."; 91const std::string ACCESSIBILITY_SET_BRIGHTNESS_DISCOUNT_NG = "error: failed to set brightness discount.\n"; 92const std::string ACCESSIBILITY_SET_DALTONIZATIONZATION_COLOR_FILTER_OK = 93 "set daltonization color filter successfully."; 94const std::string ACCESSIBILITY_SET_DALTONIZATIONZATION_COLOR_FILTER_NG = 95 "error: failed to set daltonization color filter.\n"; 96 97const std::string ACCESSIBILITY_ABILITY_NOT_FOUND = " was not found!"; 98const std::string ACCESSIBILITY_HELP_MSG_NO_OPTION = "missing options."; 99 100const std::string ACCESSIBILITY_ABILITY_NO_BUNDLE_ARGUMENT = 101 "argument -b <bundle-name> or --bundle=<bundle-name> is required!"; 102const std::string ACCESSIBILITY_ABILITY_NO_ABILITY_ARGUMENT = 103 "argument -a <ability-name> or --ability=<ability-name> is required!"; 104const std::string ACCESSIBILITY_ABILITY_NO_CAPABILITIES_ARGUMENT = 105 "argument -c <capabilities-abbr>" 106 " or --capabilities=<capabilities-abbr> is required!"; 107 108const std::string ACCESSIBILITY_ABILITY_TOO_MANY_ARGUMENT = "there are too many arguments "; 109const std::string ACCESSIBILITY_ABILITY_DUPLICATE_ARGUMENT = "there are duplicate arguments."; 110 111const std::string ACCESSIBILITY_STRING_DISABLE_ABILITY_OK = "disable ability successfully."; 112const std::string ACCESSIBILITY_STRING_DISABLE_ABILITY_NG = "error: failed to disable ability."; 113 114const std::string ACCESSIBILITY_ABILITY_NO_ABILITY_ARGUMENT_VALUE = "option -a requires a value."; 115const std::string ACCESSIBILITY_ABILITY_NO_BUNDLE_ARGUMENT_VALUE = "option -b requires a value."; 116const std::string ACCESSIBILITY_ABILITY_NO_CAPABILITIES_ARGUMENT_VALUE = "option -c requires a value."; 117const std::string ACCESSIBILITY_ABILITY_NO_SET_ARGUMENT_VALUE = "option -v requires a value."; 118 119const std::string ACCESSIBILITY_ABILITY_SET_VALUE_INVALID = "value is invalid."; 120 121const std::string ACCESSIBILITY_HELP_MSG = 122 "usage: accessibility <command>\n" 123 "these are common accessibility commands list:\n" 124 " help list available commands\n" 125 " enable enable ability with options\n" 126 " disable disable ability with options\n" 127 " list list the installed abilities info\n" 128 " setShortKeyState set the state of the short key configuration item\n" 129 " setMouseKeyState set the state of the mouse key configuration item\n" 130 " setCaptionState set the state of the caption configuration item\n" 131 " setMouseAutoClick set the time of the mouse auto click configuration item\n" 132 " setShortKeyTarget set the name of the short key target configuration item\n" 133 " setHighContrastTextState set the state of the high contrast text configuration item\n" 134 " setInvertColorState set the state of the invert color configuration item\n" 135 " setDaltonizationColorFilter set the type of the daltonization color filter configuration item\n" 136 " setContentTimeout set the time of the toast content duration configuration item\n" 137 " setAnimationOffState set the state of the animation off configuration item\n" 138 " setBrightnessDiscount set the discount of the screen brightness configuration item\n" 139 " setAudioMonoState set the state of the audio mono configuration item\n" 140 " setAudioBalance set the value of the audio balance configuration item\n"; 141 142const std::string ACCESSIBILITY_HELP_MSG_ENABLE_ABILITY = 143 "usage: accessibility enable [-a <ability-name>] [-b <bundle-name>] [-c <capabilities-abbr>]\n" 144 "enable the auxiliary application with bundle-name and ability-name and capabilities-abbr\n"; 145 146const std::string ACCESSIBILITY_HELP_MSG_DISABLE_ABILITY = 147 "usage: accessibility disable [-a <ability-name>] [-b <bundle-name>]\n" 148 "disable the auxiliary application with bundle-name and ability-name\n"; 149 150const std::string ACCESSIBILITY_HELP_MSG_LIST_ABILITIES = 151 "the auxiliary capabilities supported by the accessibility subsystem are as follows:\n" 152 "r:retrieve enable the retrieval capability of auxiliary application\n" 153 "t:touch_guide enable the touch guide capability of auxiliary application\n" 154 "g:gesture enable the gesture injection capability of auxiliary application\n" 155 "k:key_event_observer enable the key event interception capability of auxiliary application\n" 156 "z:zoom enable the gesture zoom capability of auxiliary application\n"; 157 158const std::string ACCESSIBILITY_HELP_MSG_SET_SCREEN_MAGNIFICATION_STATE = 159 "usage: accessibility setScreenMagnificationState [-v <0 | 1> ]\n" 160 "set the state of the screen magnification configuration item\n"; 161 162const std::string ACCESSIBILITY_HELP_MSG_SET_SHORT_KEY_STATE = 163 "usage: accessibility setShortKeyState [-v <0 | 1> ]\n" 164 "set the state of the short key configuration item\n"; 165 166const std::string ACCESSIBILITY_HELP_MSG_SET_MOUSE_KEY_STATE = 167 "usage: accessibility setMouseKeyState [-v <0 | 1> ]\n" 168 "set the state of the mouse key configuration item\n"; 169 170const std::string ACCESSIBILITY_HELP_MSG_SET_CAPTION_STATE = 171 "usage: accessibility setCaptionState [-v <0 | 1> ]\n" 172 "set the state of the caption configuration item\n"; 173 174const std::string ACCESSIBILITY_HELP_MSG_HIGH_CONTRAST_TEXT_STATE = 175 "usage: accessibility setHighContrastTextState [-v <0 | 1> ]\n" 176 "set the state of the high contrast text configuration item\n"; 177 178const std::string ACCESSIBILITY_HELP_MSG_SET_INVERT_COLOR_STATE = 179 "usage: accessibility setInvertColorState [-v <0 | 1>]\n" 180 "set the state of the invert color configuration item\n"; 181 182const std::string ACCESSIBILITY_HELP_MSG_SET_DALTONIZATION_COLOR_FILTER = 183 "usage: accessibility setDaltonizationColorFilter [-v <0 | 1 | 2 | 3>]\n" 184 "normal = 0, protanomaly = 1, deuteranomaly = 2, tritanomaly = 3\n" 185 "set the type of the daltonization color filter configuration item\n"; 186 187const std::string ACCESSIBILITY_HELP_MSG_ANIMATION_OFF_STATE = 188 "usage: accessibility setAnimationOffState [-v <0 | 1>]\n" 189 "set the state of the animation off configuration item\n"; 190 191const std::string ACCESSIBILITY_HELP_MSG_SET_AUDIO_MONO_STATE = 192 "usage: accessibility setAudioMonoState [-v <0 | 1>]\n" 193 "set the state of the audio mono configuration item\n"; 194 195const std::string ACCESSIBILITY_HELP_MSG_SET_AUTO_CLICK_TIME = 196 "usage: accessibility setMouseAutoClick [-v <time-value>]\n" 197 "the range of time-value is 1000 to 5000 and the default unit is ms\n" 198 "set the time of the mouse auto click configuration item\n"; 199 200const std::string ACCESSIBILITY_HELP_MSG_SET_SHORT_KEY_TARGET = 201 "usage: accessibility setShortKeyTarget -a <ability-name> -b <bundle-name>\n" 202 "set the name of the short key target configuration item\n"; 203 204const std::string ACCESSIBILITY_HELP_MSG_SET_CONTENT_TIME_OUT = 205 "usage: accessibility setContentTimeout [-v <time-value>]\n" 206 "the range of time-value is 0 to 5000 and the default unit is ms\n" 207 "set the time of the toast content duration configuration item\n"; 208 209const std::string ACCESSIBILITY_HELP_MSG_SET_BRIGHTNESS_DISCOUNT = 210 "usage: accessibility setBrightnessDiscount [-v <discount-value>]\n" 211 "the percentage of discount-value is 0 to 100\n" 212 "set the discount of the screen brightness configuration item\n"; 213 214const std::string ACCESSIBILITY_HELP_MSG_SET_AUDIO_BALANCE = 215 "usage: accessibility setAudioBalance [-v <balance-value>]\n" 216 "the percentage of balance-value is -100 to 100\n" 217 "the negative values represent the left channel and positive values represent the right channel\n" 218 "set the value of the audio balance configuration item\n"; 219 220constexpr struct option ENABLE_LONG_OPTIONS[] = { 221 {"ability", required_argument, nullptr, 'a'}, 222 {"bundle", required_argument, nullptr, 'b'}, 223 {"capabilities", required_argument, nullptr, 'c'}, 224 {nullptr, 0, nullptr, 0}, 225}; 226 227constexpr struct option DISABLE_LONG_OPTIONS[] = { 228 {"ability", required_argument, nullptr, 'a'}, 229 {"bundle", required_argument, nullptr, 'b'}, 230 {nullptr, 0, nullptr, 0}, 231}; 232 233constexpr struct option SET_LONG_OPTIONS[] = { 234 {"value", required_argument, nullptr, 'v'}, 235 {nullptr, 0, nullptr, 0}, 236}; 237} // namespace 238 239AccessibilityAbilityShellCommand::AccessibilityAbilityShellCommand(int argc, char* argv[]) 240 : ShellCommand(argc, argv, ACCESSIBILITY_TOOL_NAME) 241{ 242 for (int i = 0; i < argc_; i++) { 243 TAG_LOGI(AAFwkTag::AA_TOOL, "argv_[%{public}d]: %{public}s", i, argv_[i]); 244 } 245 if (abilityClientPtr_ == nullptr) { 246 abilityClientPtr_ = Accessibility::AccessibilitySystemAbilityClient::GetInstance(); 247 if (abilityClientPtr_ == nullptr) { 248 TAG_LOGE(AAFwkTag::AA_TOOL, "Get ability client failed"); 249 } 250 } 251 int32_t addPermissionResult = AccessibilityUtils::AddPermission(); 252 if (addPermissionResult != 0) { 253 TAG_LOGE(AAFwkTag::AA_TOOL, "Add permission failed"); 254 } 255} 256 257ErrCode AccessibilityAbilityShellCommand::init() 258{ 259 messageMap_ = { 260 { 261 Accessibility::RET_ERR_FAILED, 262 "reason: system exception.", 263 }, 264 { 265 Accessibility::RET_ERR_INVALID_PARAM, 266 "reason: invalid param.", 267 }, 268 { 269 Accessibility::RET_ERR_NULLPTR, 270 "reason: nullptr exception.", 271 }, 272 { 273 Accessibility::RET_ERR_IPC_FAILED, 274 "reason: ipc failed.", 275 }, 276 { 277 Accessibility::RET_ERR_SAMGR, 278 "reason: samgr error.", 279 }, 280 { 281 Accessibility::RET_ERR_NO_PERMISSION, 282 "reason: no permissions.", 283 }, 284 { 285 Accessibility::RET_ERR_TIME_OUT, 286 "reason: execution timeout.", 287 }, 288 { 289 Accessibility::RET_ERR_CONNECTION_EXIST, 290 "reason: the ability is already enabled.", 291 }, 292 { 293 Accessibility::RET_ERR_NO_CAPABILITY, 294 "reason: capabilities is wrong.", 295 }, 296 { 297 Accessibility::RET_ERR_NOT_INSTALLED, 298 "reason: the auxiliary application is not installed.", 299 }, 300 { 301 Accessibility::RET_ERR_NOT_ENABLED, 302 "reason: the auxiliary application is not enabled.", 303 } 304 }; 305 return OHOS::ERR_OK; 306} 307 308ErrCode AccessibilityAbilityShellCommand::CreateMessageMap() 309{ 310 return OHOS::ERR_OK; 311} 312 313ErrCode AccessibilityAbilityShellCommand::CreateCommandMap() 314{ 315 commandMap_ = { 316 }; 317 318 return OHOS::ERR_OK; 319} 320 321ErrCode AccessibilityAbilityShellCommand::RunAsHelpCommand() 322{ 323 resultReceiver_.append(ACCESSIBILITY_HELP_MSG); 324 325 return OHOS::ERR_OK; 326} 327 328void AccessibilityAbilityShellCommand::CheckEnableCommandOption(const int option, 329 AccessibilityCommandArgument& argument) 330{ 331 switch (option) { 332 case 'a': { 333 argument.abilityName = optarg; 334 argument.abilityArgumentNum++; 335 break; 336 } 337 case 'b': { 338 argument.bundleName = optarg; 339 argument.bundleArgumentNum++; 340 break; 341 } 342 case 'c': { 343 argument.capabilityNames = optarg; 344 argument.capabilityNamesArgumentNum++; 345 break; 346 } 347 default: { 348 argument.unknownArgumentNum++; 349 argument.unknownArguments.push_back(argv_[optind - 1]); 350 break; 351 } 352 } 353} 354 355ErrCode AccessibilityAbilityShellCommand::MakeEnableCommandArgumentFromCmd(AccessibilityCommandArgument& argument) 356{ 357 int option = -1; 358 int counter = 0; 359 argument.command = "enable"; 360 while (true) { 361 counter++; 362 363 option = getopt_long(argc_, argv_, ENABLE_SHORT_OPTIONS.c_str(), ENABLE_LONG_OPTIONS, nullptr); 364 365 TAG_LOGI( 366 AAFwkTag::AA_TOOL, "option: %{public}d, optind: %{public}d, optopt: %{public}d", option, optind, optopt); 367 368 if (optind < 0 || optind > argc_) { 369 return OHOS::ERR_INVALID_VALUE; 370 } 371 372 if (option == -1) { 373 if (counter == 1 && strcmp(argv_[optind], cmd_.c_str()) == 0) { 374 resultReceiver_.append(argument.command + ": " + ACCESSIBILITY_HELP_MSG_NO_OPTION); 375 return OHOS::ERR_INVALID_VALUE; 376 } 377 break; 378 } 379 380 if (option == '?') { 381 switch (optopt) { 382 case 'a': { 383 resultReceiver_.append(argument.command + ": " + ACCESSIBILITY_ABILITY_NO_ABILITY_ARGUMENT_VALUE); 384 return OHOS::ERR_INVALID_VALUE; 385 } 386 case 'b': { 387 resultReceiver_.append(argument.command + ": " + ACCESSIBILITY_ABILITY_NO_BUNDLE_ARGUMENT_VALUE); 388 return OHOS::ERR_INVALID_VALUE; 389 } 390 case 'c': { 391 resultReceiver_.append(argument.command + ": " + 392 ACCESSIBILITY_ABILITY_NO_CAPABILITIES_ARGUMENT_VALUE); 393 return OHOS::ERR_INVALID_VALUE; 394 } 395 default: { 396 break; 397 } 398 } 399 } 400 CheckEnableCommandOption(option, argument); 401 } 402 return CheckEnableCommandArgument(argument, resultReceiver_); 403} 404 405ErrCode AccessibilityAbilityShellCommand::MakeDisableCommandArgumentFromCmd(AccessibilityCommandArgument& argument) 406{ 407 argument.command = "disable"; 408 ErrCode result = MakeCommandArgumentFromCmd(argument); 409 if (result == OHOS::ERR_OK) { 410 return CheckDisableCommandArgument(argument, resultReceiver_); 411 } 412 return result; 413} 414 415ErrCode AccessibilityAbilityShellCommand::RunAsEnableAbility() 416{ 417 AccessibilityCommandArgument argument; 418 ErrCode result = MakeEnableCommandArgumentFromCmd(argument); 419 if (result == OHOS::ERR_OK) { 420 auto& config = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 421 (void)config.InitializeContext(); 422 std::string name = argument.bundleName + "/" + argument.abilityName; 423 std::string capabilityNames = argument.capabilityNames; 424 uint32_t capabilities = AccessibilityUtils::GetCapabilityValue(capabilityNames); 425 Accessibility::RetError ret = config.EnableAbility(name, capabilities); 426 if (ret == Accessibility::RET_OK) { 427 resultReceiver_ = ACCESSIBILITY_STRING_ENABLE_ABILITY_OK + "\n"; 428 } else { 429 resultReceiver_ = ACCESSIBILITY_STRING_ENABLE_ABILITY_NG; 430 resultReceiver_.append(GetMessageFromCode(ret)); 431 } 432 } else { 433 resultReceiver_.append("\n"); 434 resultReceiver_.append(ACCESSIBILITY_HELP_MSG_ENABLE_ABILITY); 435 result = OHOS::ERR_INVALID_VALUE; 436 } 437 438 return result; 439} 440 441ErrCode AccessibilityAbilityShellCommand::RunAsDisableAbility() 442{ 443 AccessibilityCommandArgument argument; 444 ErrCode result = MakeDisableCommandArgumentFromCmd(argument); 445 if (result == OHOS::ERR_OK) { 446 auto& config = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 447 (void)config.InitializeContext(); 448 std::string name = argument.bundleName + "/" + argument.abilityName; 449 Accessibility::RetError ret = config.DisableAbility(name); 450 if (ret == Accessibility::RET_OK) { 451 resultReceiver_ = ACCESSIBILITY_STRING_DISABLE_ABILITY_OK + "\n"; 452 } else { 453 resultReceiver_ = ACCESSIBILITY_STRING_DISABLE_ABILITY_NG; 454 resultReceiver_.append(GetMessageFromCode(ret)); 455 } 456 } else { 457 resultReceiver_.append("\n"); 458 resultReceiver_.append(ACCESSIBILITY_HELP_MSG_DISABLE_ABILITY); 459 result = OHOS::ERR_INVALID_VALUE; 460 } 461 462 return result; 463} 464 465ErrCode AccessibilityAbilityShellCommand::RunAsGetEnabledAbilities() 466{ 467 ErrCode result = OHOS::ERR_OK; 468 std::vector<std::string> enabledAbilities = GetEnabledAbilities(); 469 if (!enabledAbilities.empty()) { 470 for (const auto& ability : enabledAbilities) { 471 resultReceiver_.append(ability + "\n"); 472 } 473 } else { 474 result = OHOS::ERR_INVALID_VALUE; 475 } 476 return result; 477} 478 479ErrCode AccessibilityAbilityShellCommand::RunAsGetInstalledAbilities() 480{ 481 ErrCode result = OHOS::ERR_OK; 482 std::vector<Accessibility::AccessibilityAbilityInfo> installedAbilities = GetInstalledAbilities(); 483 if (!installedAbilities.empty()) { 484 resultReceiver_.append(AccessibilityUtils::FormatAbilityInfos(installedAbilities)); 485 resultReceiver_.append(ACCESSIBILITY_HELP_MSG_LIST_ABILITIES); 486 } else { 487 result = OHOS::ERR_INVALID_VALUE; 488 } 489 return result; 490} 491 492const std::vector<std::string> AccessibilityAbilityShellCommand::GetEnabledAbilities() 493{ 494 std::vector<std::string> enabledAbilities; 495 if (abilityClientPtr_ != nullptr && 496 (abilityClientPtr_->GetEnabledAbilities(enabledAbilities) != Accessibility::RET_OK)) { 497 TAG_LOGE(AAFwkTag::AA_TOOL, "GetEnabledAbilities failed"); 498 } 499 return enabledAbilities; 500} 501 502const std::vector<Accessibility::AccessibilityAbilityInfo> AccessibilityAbilityShellCommand::GetInstalledAbilities() 503{ 504 std::vector<Accessibility::AccessibilityAbilityInfo> installedAbilities; 505 const uint32_t allTypes = Accessibility::AccessibilityAbilityTypes::ACCESSIBILITY_ABILITY_TYPE_ALL; 506 const Accessibility::AbilityStateType stateType = Accessibility::AbilityStateType::ABILITY_STATE_INSTALLED; 507 if (abilityClientPtr_ != nullptr && 508 (abilityClientPtr_->GetAbilityList(allTypes, stateType, installedAbilities) != Accessibility::RET_OK)) { 509 TAG_LOGE(AAFwkTag::AA_TOOL, "GetInstalledAbilities failed"); 510 } 511 return installedAbilities; 512} 513 514bool AccessibilityAbilityShellCommand::CheckBundleArgument( 515 const AccessibilityCommandArgument& argument, 516 std::string& resultMessage) 517{ 518 if (argument.bundleArgumentNum == 0) { 519 resultMessage.append(ACCESSIBILITY_ABILITY_NO_BUNDLE_ARGUMENT); 520 return false; 521 } 522 if (argument.bundleArgumentNum > 1) { 523 resultMessage.append(ACCESSIBILITY_ABILITY_DUPLICATE_ARGUMENT); 524 return false; 525 } 526 if (argument.bundleName.empty() || argument.bundleName[0] == '-') { 527 resultMessage.append(ACCESSIBILITY_ABILITY_NO_BUNDLE_ARGUMENT_VALUE); 528 return false; 529 } 530 return true; 531} 532 533bool AccessibilityAbilityShellCommand::CheckAbilityArgument( 534 const AccessibilityCommandArgument& argument, 535 std::string& resultMessage) 536{ 537 if (argument.abilityArgumentNum == 0) { 538 resultMessage.append(ACCESSIBILITY_ABILITY_NO_ABILITY_ARGUMENT); 539 return false; 540 } 541 if (argument.abilityArgumentNum > 1) { 542 resultMessage.append(ACCESSIBILITY_ABILITY_DUPLICATE_ARGUMENT); 543 return false; 544 } 545 if (argument.abilityName.empty() || argument.abilityName[0] == '-') { 546 resultMessage.append(ACCESSIBILITY_ABILITY_NO_ABILITY_ARGUMENT_VALUE); 547 return false; 548 } 549 return true; 550} 551 552bool AccessibilityAbilityShellCommand::CheckCapabilitiesArgument( 553 const AccessibilityCommandArgument& argument, 554 std::vector<Accessibility::AccessibilityAbilityInfo>& installedAbilities, 555 std::string& resultMessage) 556{ 557 if (argument.capabilityNamesArgumentNum == 0) { 558 resultMessage.append(ACCESSIBILITY_ABILITY_NO_CAPABILITIES_ARGUMENT); 559 return false; 560 } 561 if (argument.capabilityNamesArgumentNum > 1) { 562 resultMessage.append(ACCESSIBILITY_ABILITY_DUPLICATE_ARGUMENT); 563 return false; 564 } 565 if (argument.capabilityNames.empty() || argument.capabilityNames[0] == '-') { 566 resultMessage.append(ACCESSIBILITY_ABILITY_NO_CAPABILITIES_ARGUMENT_VALUE); 567 return false; 568 } 569 return true; 570} 571 572bool AccessibilityAbilityShellCommand::CheckParamValidity( 573 const AccessibilityCommandArgument& argument, 574 std::vector<Accessibility::AccessibilityAbilityInfo>& installedAbilities, 575 std::string& resultMessage) 576{ 577 const std::string& abilityName = argument.abilityName; 578 const std::string& bundleName = argument.bundleName; 579 const std::string& capabilityNames = argument.capabilityNames; 580 bool isExisted = false; 581 for (auto& ability : installedAbilities) { 582 if (ability.GetName() == abilityName && ability.GetPackageName() == bundleName) { 583 isExisted = true; 584 const std::string staticCapabilityNames = AccessibilityUtils::GetStaticCapabilityNames(ability); 585 std::string invalidCapabilityNames = AccessibilityUtils::GetInvalidCapabilityNames(capabilityNames, 586 staticCapabilityNames); 587 if (!invalidCapabilityNames.empty()) { 588 resultMessage.append("the capabilities " + invalidCapabilityNames + ACCESSIBILITY_ABILITY_NOT_FOUND); 589 return false; 590 } 591 } 592 } 593 if (!isExisted) { 594 resultMessage.append("the auxiliary application " + 595 bundleName + "/" + abilityName + ACCESSIBILITY_ABILITY_NOT_FOUND); 596 return false; 597 } 598 return true; 599} 600 601ErrCode AccessibilityAbilityShellCommand::CheckEnableCommandArgument(const AccessibilityCommandArgument& argument, 602 std::string& resultMessage) 603{ 604 ErrCode result = OHOS::ERR_OK; 605 resultMessage.append(argument.command + ": "); 606 int32_t totalArgumentNum = argument.bundleArgumentNum + argument.abilityArgumentNum + 607 argument.capabilityNamesArgumentNum + argument.unknownArgumentNum; 608 if (totalArgumentNum > ACCESSIBILITY_ENABLE_COMMAND_ARGUMENT_NUM) { 609 resultReceiver_.append(ACCESSIBILITY_ABILITY_TOO_MANY_ARGUMENT); 610 if (argument.bundleArgumentNum > 1 || argument.abilityArgumentNum > 1 || 611 argument.capabilityNamesArgumentNum > 1) { 612 resultMessage.append("and exist duplicated arguments"); 613 } 614 if (argument.unknownArgumentNum > 0) { 615 resultMessage.append("and exist unknown arguments."); 616 resultMessage.append(AccessibilityUtils::GetUnknownArgumentsMsg(argument.unknownArguments)); 617 } 618 return OHOS::ERR_INVALID_VALUE; 619 } 620 if (argument.unknownArgumentNum > 0) { 621 resultMessage.append("unknown arguments."); 622 resultMessage.append(AccessibilityUtils::GetUnknownArgumentsMsg(argument.unknownArguments)); 623 return OHOS::ERR_INVALID_VALUE; 624 } 625 std::vector<Accessibility::AccessibilityAbilityInfo> installedAbilities = GetInstalledAbilities(); 626 if (!CheckAbilityArgument(argument, resultMessage)) { 627 TAG_LOGE(AAFwkTag::AA_TOOL, "invalid abilityName: %{public}s", argument.abilityName.c_str()); 628 return OHOS::ERR_INVALID_VALUE; 629 } 630 if (!CheckBundleArgument(argument, resultMessage)) { 631 TAG_LOGE(AAFwkTag::AA_TOOL, "invalid bundleName: %{public}s", argument.bundleName.c_str()); 632 return OHOS::ERR_INVALID_VALUE; 633 } 634 if (!CheckCapabilitiesArgument(argument, installedAbilities, resultMessage)) { 635 TAG_LOGE(AAFwkTag::AA_TOOL, "invalid capabilityNames: %{public}s", argument.capabilityNames.c_str()); 636 return OHOS::ERR_INVALID_VALUE; 637 } 638 if (!CheckParamValidity(argument, installedAbilities, resultMessage)) { 639 TAG_LOGE(AAFwkTag::AA_TOOL, "%{public}s/%{public}s not installed", 640 argument.bundleName.c_str(), argument.abilityName.c_str()); 641 return OHOS::ERR_INVALID_VALUE; 642 } 643 std::vector<std::string> enabledAbilities = GetEnabledAbilities(); 644 std::string currentAbility = argument.bundleName + "/" + argument.abilityName; 645 for (const auto& ability : enabledAbilities) { 646 if (ability == currentAbility) { 647 resultMessage.append("the auxiliary application has been enabled."); 648 return OHOS::ERR_INVALID_VALUE; 649 } 650 } 651 return result; 652} 653 654ErrCode AccessibilityAbilityShellCommand::CheckDisableCommandArgument(const AccessibilityCommandArgument& argument, 655 std::string& resultMessage) 656{ 657 ErrCode result = CheckCommandArgument(argument, resultMessage); 658 if (result == OHOS::ERR_OK) { 659 std::vector<std::string> enabledAbilities = GetEnabledAbilities(); 660 std::string currentAbility = argument.bundleName + "/" + argument.abilityName; 661 bool isEnabled = false; 662 for (const auto& ability : enabledAbilities) { 663 if (ability == currentAbility) { 664 isEnabled = true; 665 break; 666 } 667 } 668 if (!isEnabled) { 669 resultMessage.append("the auxiliary application was not enabled and could not be disabled."); 670 return OHOS::ERR_INVALID_VALUE; 671 } 672 } 673 return result; 674} 675 676ErrCode AccessibilityAbilityShellCommand::CheckCommandArgument(const AccessibilityCommandArgument& argument, 677 std::string& resultMessage) 678{ 679 resultMessage.append(argument.command + ": "); 680 int32_t totalArgumentNum = argument.bundleArgumentNum + argument.abilityArgumentNum + 681 argument.capabilityNamesArgumentNum + argument.unknownArgumentNum; 682 if (totalArgumentNum > ACCESSIBILITY_DISABLE_COMMAND_ARGUMENT_NUM) { 683 resultReceiver_.append(ACCESSIBILITY_ABILITY_TOO_MANY_ARGUMENT); 684 if (argument.bundleArgumentNum > 1 || argument.abilityArgumentNum > 1) { 685 resultMessage.append("and duplicated arguments exist."); 686 } 687 if (argument.unknownArgumentNum > 0) { 688 resultMessage.append("and unknown arguments exist."); 689 resultMessage.append(AccessibilityUtils::GetUnknownArgumentsMsg(argument.unknownArguments)); 690 } 691 return OHOS::ERR_INVALID_VALUE; 692 } 693 if (argument.unknownArgumentNum > 0) { 694 resultMessage.append("unknown arguments exist."); 695 resultMessage.append(AccessibilityUtils::GetUnknownArgumentsMsg(argument.unknownArguments)); 696 return OHOS::ERR_INVALID_VALUE; 697 } 698 std::vector<Accessibility::AccessibilityAbilityInfo> installedAbilities = GetInstalledAbilities(); 699 if (!CheckAbilityArgument(argument, resultMessage)) { 700 TAG_LOGE(AAFwkTag::AA_TOOL, "invalid abilityName: %{public}s", argument.abilityName.c_str()); 701 return OHOS::ERR_INVALID_VALUE; 702 } 703 if (!CheckBundleArgument(argument, resultMessage)) { 704 TAG_LOGE(AAFwkTag::AA_TOOL, "invalid bundleName: %{public}s", argument.bundleName.c_str()); 705 return OHOS::ERR_INVALID_VALUE; 706 } 707 if (!CheckParamValidity(argument, installedAbilities, resultMessage)) { 708 TAG_LOGE(AAFwkTag::AA_TOOL, "%{public}s/%{public}s not installed", 709 argument.bundleName.c_str(), argument.abilityName.c_str()); 710 return OHOS::ERR_INVALID_VALUE; 711 } 712 return OHOS::ERR_OK; 713} 714 715ErrCode AccessibilityAbilityShellCommand::CheckSetCommandArgument(const AccessibilityCommandArgument& argument, 716 std::string& resultMessage) 717{ 718 resultMessage.append(argument.command + ": "); 719 int32_t totalArgumentNum = argument.setArgumentNum + argument.unknownArgumentNum; 720 if (totalArgumentNum > ACCESSIBILITY_SET_COMMAND_ARGUMENT_NUM) { 721 resultReceiver_.append(ACCESSIBILITY_ABILITY_TOO_MANY_ARGUMENT); 722 if (argument.setArgumentNum > 1) { 723 resultMessage.append("and exist duplicated arguments."); 724 } 725 if (argument.unknownArgumentNum > 0) { 726 resultMessage.append("and exist unknown arguments "); 727 resultMessage.append(AccessibilityUtils::GetUnknownArgumentsMsg(argument.unknownArguments)); 728 } 729 return OHOS::ERR_INVALID_VALUE; 730 } 731 if (argument.unknownArgumentNum > 0) { 732 resultMessage.append("unknown arguments "); 733 resultMessage.append(AccessibilityUtils::GetUnknownArgumentsMsg(argument.unknownArguments)); 734 return OHOS::ERR_INVALID_VALUE; 735 } 736 if (argument.setArgumentNum == 0) { 737 resultMessage.append(ACCESSIBILITY_HELP_MSG_NO_OPTION); 738 return OHOS::ERR_INVALID_VALUE; 739 } 740 return OHOS::ERR_OK; 741} 742 743ErrCode AccessibilityAbilityShellCommand::RunAsSetScreenMagnificationState() 744{ 745 AccessibilityCommandArgument argument; 746 argument.command = "setScreenMagnificationState"; 747 ErrCode result = MakeSetCommandArgumentFromCmd(argument); 748 if (result == OHOS::ERR_OK && !AccessibilityUtils::IsValidStateString(argument.value)) { 749 resultReceiver_.append(ACCESSIBILITY_ABILITY_SET_VALUE_INVALID); 750 result = OHOS::ERR_INVALID_VALUE; 751 } 752 if (result == OHOS::ERR_OK) { 753 auto& config = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 754 (void)config.InitializeContext(); 755 bool state = std::atoi(argument.value.c_str()) == 1; 756 Accessibility::RetError ret = config.SetScreenMagnificationState(state); 757 if (ret == Accessibility::RET_OK) { 758 resultReceiver_ = ACCESSIBILITY_SET_SCREEN_MAGNIFICATION_STATE_OK + "\n"; 759 } else { 760 resultReceiver_ = ACCESSIBILITY_SET_SCREEN_MAGNIFICATION_STATE_NG; 761 resultReceiver_.append(GetMessageFromCode(ret)); 762 } 763 } else { 764 resultReceiver_.append("\n"); 765 resultReceiver_.append(ACCESSIBILITY_HELP_MSG_SET_SCREEN_MAGNIFICATION_STATE); 766 result = OHOS::ERR_INVALID_VALUE; 767 } 768 769 return result; 770} 771 772ErrCode AccessibilityAbilityShellCommand::RunAsSetShortKeyState() 773{ 774 AccessibilityCommandArgument argument; 775 argument.command = "setShortKeyState"; 776 ErrCode result = MakeSetCommandArgumentFromCmd(argument); 777 if (result == OHOS::ERR_OK && !AccessibilityUtils::IsValidStateString(argument.value)) { 778 resultReceiver_.append(ACCESSIBILITY_ABILITY_SET_VALUE_INVALID); 779 result = OHOS::ERR_INVALID_VALUE; 780 } 781 if (result == OHOS::ERR_OK) { 782 auto& config = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 783 (void)config.InitializeContext(); 784 bool state = std::atoi(argument.value.c_str()) == 1; 785 Accessibility::RetError ret = config.SetShortKeyState(state); 786 if (ret == Accessibility::RET_OK) { 787 resultReceiver_ = ACCESSIBILITY_SET_SHORT_KEY_STATE_OK + "\n"; 788 } else { 789 resultReceiver_ = ACCESSIBILITY_SET_SHORT_KEY_STATE_NG; 790 resultReceiver_.append(GetMessageFromCode(ret)); 791 } 792 } else { 793 resultReceiver_.append("\n"); 794 resultReceiver_.append(ACCESSIBILITY_HELP_MSG_SET_SHORT_KEY_STATE); 795 result = OHOS::ERR_INVALID_VALUE; 796 } 797 798 return result; 799} 800 801ErrCode AccessibilityAbilityShellCommand::RunAsSetMouseKeyState() 802{ 803 AccessibilityCommandArgument argument; 804 argument.command = "setMouseKeyState"; 805 ErrCode result = MakeSetCommandArgumentFromCmd(argument); 806 if (result == OHOS::ERR_OK && !AccessibilityUtils::IsValidStateString(argument.value)) { 807 resultReceiver_.append(ACCESSIBILITY_ABILITY_SET_VALUE_INVALID); 808 result = OHOS::ERR_INVALID_VALUE; 809 } 810 if (result == OHOS::ERR_OK) { 811 auto& config = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 812 (void)config.InitializeContext(); 813 bool state = std::atoi(argument.value.c_str()) == 1; 814 Accessibility::RetError ret = config.SetMouseKeyState(state); 815 if (ret == Accessibility::RET_OK) { 816 resultReceiver_ = ACCESSIBILITY_SET_MOUSE_KEY_STATE_OK + "\n"; 817 } else { 818 resultReceiver_ = ACCESSIBILITY_SET_MOUSE_KEY_STATE_NG; 819 resultReceiver_.append(GetMessageFromCode(ret)); 820 } 821 } else { 822 resultReceiver_.append("\n"); 823 resultReceiver_.append(ACCESSIBILITY_HELP_MSG_SET_MOUSE_KEY_STATE); 824 result = OHOS::ERR_INVALID_VALUE; 825 } 826 827 return result; 828} 829 830ErrCode AccessibilityAbilityShellCommand::RunAsSetCaptionState() 831{ 832 AccessibilityCommandArgument argument; 833 argument.command = "setCaptionState"; 834 ErrCode result = MakeSetCommandArgumentFromCmd(argument); 835 if (result == OHOS::ERR_OK && !AccessibilityUtils::IsValidStateString(argument.value)) { 836 resultReceiver_.append(ACCESSIBILITY_ABILITY_SET_VALUE_INVALID); 837 result = OHOS::ERR_INVALID_VALUE; 838 } 839 if (result == OHOS::ERR_OK) { 840 auto& config = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 841 (void)config.InitializeContext(); 842 bool state = std::atoi(argument.value.c_str()) == 1; 843 Accessibility::RetError ret = config.SetCaptionsState(state); 844 if (ret == Accessibility::RET_OK) { 845 resultReceiver_ = ACCESSIBILITY_SET_CAPTION_STATE_OK + "\n"; 846 } else { 847 resultReceiver_ = ACCESSIBILITY_SET_CAPTION_STATE_NG; 848 resultReceiver_.append(GetMessageFromCode(ret)); 849 } 850 } else { 851 resultReceiver_.append("\n"); 852 resultReceiver_.append(ACCESSIBILITY_HELP_MSG_SET_CAPTION_STATE); 853 result = OHOS::ERR_INVALID_VALUE; 854 } 855 856 return result; 857} 858 859ErrCode AccessibilityAbilityShellCommand::RunAsSetMouseAutoClick() 860{ 861 AccessibilityCommandArgument argument; 862 argument.command = "setMouseAutoClick"; 863 ErrCode result = MakeSetCommandArgumentFromCmd(argument); 864 if (result == OHOS::ERR_OK && !AccessibilityUtils::IsValidIntString(argument.value, 865 MOUSE_AUTO_CLICK_TIME_LOW_BOUND, MOUSE_AUTO_CLICK_TIME_HIGH_BOUND)) { 866 resultReceiver_.append(ACCESSIBILITY_ABILITY_SET_VALUE_INVALID); 867 result = OHOS::ERR_INVALID_VALUE; 868 } 869 if (result == OHOS::ERR_OK) { 870 auto& config = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 871 (void)config.InitializeContext(); 872 float time = 1.0 * std::atoi(argument.value.c_str()) / 100; 873 Accessibility::RetError ret = config.SetMouseAutoClick(time); 874 if (ret == Accessibility::RET_OK) { 875 resultReceiver_ = ACCESSIBILITY_SET_AUTO_CLICK_TIME_OK + "\n"; 876 } else { 877 resultReceiver_ = ACCESSIBILITY_SET_AUTO_CLICK_TIME_NG; 878 resultReceiver_.append(GetMessageFromCode(ret)); 879 } 880 } else { 881 resultReceiver_.append("\n"); 882 resultReceiver_.append(ACCESSIBILITY_HELP_MSG_SET_AUTO_CLICK_TIME); 883 result = OHOS::ERR_INVALID_VALUE; 884 } 885 886 return result; 887} 888 889ErrCode AccessibilityAbilityShellCommand::RunAsSetShortKeyTarget() 890{ 891 AccessibilityCommandArgument argument; 892 ErrCode result = MakeSetShortKeyTargetCommandArgumentFromCmd(argument); 893 if (result == OHOS::ERR_OK) { 894 auto& config = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 895 (void)config.InitializeContext(); 896 std::string name = argument.bundleName + "/" + argument.abilityName; 897 Accessibility::RetError ret = config.SetShortkeyTarget(name); 898 if (ret == Accessibility::RET_OK) { 899 resultReceiver_ = ACCESSIBILITY_SET_SHORT_KEY_TARGET_OK + "\n"; 900 } else { 901 resultReceiver_ = ACCESSIBILITY_SET_SHORT_KEY_TARGET_NG; 902 resultReceiver_.append(GetMessageFromCode(ret)); 903 } 904 } else { 905 resultReceiver_.append("\n"); 906 resultReceiver_.append(ACCESSIBILITY_HELP_MSG_SET_SHORT_KEY_TARGET); 907 result = OHOS::ERR_INVALID_VALUE; 908 } 909 910 return result; 911} 912 913ErrCode AccessibilityAbilityShellCommand::RunAsSetHighContrastTextState() 914{ 915 AccessibilityCommandArgument argument; 916 argument.command = "setHighContrastTextState"; 917 ErrCode result = MakeSetCommandArgumentFromCmd(argument); 918 if (result == OHOS::ERR_OK && !AccessibilityUtils::IsValidStateString(argument.value)) { 919 resultReceiver_.append(ACCESSIBILITY_ABILITY_SET_VALUE_INVALID); 920 result = OHOS::ERR_INVALID_VALUE; 921 } 922 if (result == OHOS::ERR_OK) { 923 auto& config = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 924 (void)config.InitializeContext(); 925 bool state = std::atoi(argument.value.c_str()) == 1; 926 Accessibility::RetError ret = config.SetHighContrastTextState(state); 927 if (ret == Accessibility::RET_OK) { 928 resultReceiver_ = ACCESSIBILITY_SET_HIGH_CONTRAST_TEXT_STATE_OK + "\n"; 929 } else { 930 resultReceiver_ = ACCESSIBILITY_SET_HIGH_CONTRAST_TEXT_STATE_NG; 931 resultReceiver_.append(GetMessageFromCode(ret)); 932 } 933 } else { 934 resultReceiver_.append("\n"); 935 resultReceiver_.append(ACCESSIBILITY_HELP_MSG_HIGH_CONTRAST_TEXT_STATE); 936 result = OHOS::ERR_INVALID_VALUE; 937 } 938 939 return result; 940} 941 942ErrCode AccessibilityAbilityShellCommand::RunAsSetInvertColorState() 943{ 944 AccessibilityCommandArgument argument; 945 argument.command = "setInvertColorState"; 946 ErrCode result = MakeSetCommandArgumentFromCmd(argument); 947 if (result == OHOS::ERR_OK && !AccessibilityUtils::IsValidStateString(argument.value)) { 948 resultReceiver_.append(ACCESSIBILITY_ABILITY_SET_VALUE_INVALID); 949 result = OHOS::ERR_INVALID_VALUE; 950 } 951 if (result == OHOS::ERR_OK) { 952 auto& config = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 953 (void)config.InitializeContext(); 954 bool state = std::atoi(argument.value.c_str()) == 1; 955 Accessibility::RetError ret = config.SetInvertColorState(state); 956 if (ret == Accessibility::RET_OK) { 957 resultReceiver_ = ACCESSIBILITY_SET_INVERT_COLOR_STATE_OK + "\n"; 958 } else { 959 resultReceiver_ = ACCESSIBILITY_SET_INVERT_COLOR_STATE_NG; 960 resultReceiver_.append(GetMessageFromCode(ret)); 961 } 962 } else { 963 resultReceiver_.append("\n"); 964 resultReceiver_.append(ACCESSIBILITY_HELP_MSG_SET_INVERT_COLOR_STATE); 965 result = OHOS::ERR_INVALID_VALUE; 966 } 967 968 return result; 969} 970 971ErrCode AccessibilityAbilityShellCommand::RunAsSetDaltonizationColorFilter() 972{ 973 AccessibilityCommandArgument argument; 974 argument.command = "setDaltonizationColorFilter"; 975 ErrCode result = MakeSetCommandArgumentFromCmd(argument); 976 if (result == OHOS::ERR_OK && !AccessibilityUtils::IsValidIntString(argument.value, 977 DALTIONIZATION_TYPE_LOW_BOUND, DALTIONIZATION_TYPE_HIGH_BOUND)) { 978 resultReceiver_.append(ACCESSIBILITY_ABILITY_SET_VALUE_INVALID); 979 return OHOS::ERR_INVALID_VALUE; 980 } 981 if (result == OHOS::ERR_OK) { 982 auto& config = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 983 (void)config.InitializeContext(); 984 int32_t value = std::atoi(argument.value.c_str()); 985 AccessibilityConfig::DALTONIZATION_TYPE type = AccessibilityConfig::DALTONIZATION_TYPE::Normal; 986 switch (value) { 987 case TYPE_NORMAL: { 988 type = AccessibilityConfig::DALTONIZATION_TYPE::Normal; 989 break; 990 } 991 case TYPE_PROTANOMALY: { 992 type = AccessibilityConfig::DALTONIZATION_TYPE::Protanomaly; 993 break; 994 } 995 case TYPE_DEUTERANOMALY: { 996 type = AccessibilityConfig::DALTONIZATION_TYPE::Deuteranomaly; 997 break; 998 } 999 case TYPE_TRITANOMALY: { 1000 type = AccessibilityConfig::DALTONIZATION_TYPE::Tritanomaly; 1001 break; 1002 } 1003 default: { 1004 break; 1005 } 1006 } 1007 Accessibility::RetError ret = config.SetDaltonizationColorFilter(type); 1008 if (ret == Accessibility::RET_OK) { 1009 resultReceiver_ = ACCESSIBILITY_SET_DALTONIZATIONZATION_COLOR_FILTER_OK + "\n"; 1010 } else { 1011 resultReceiver_ = ACCESSIBILITY_SET_DALTONIZATIONZATION_COLOR_FILTER_NG; 1012 resultReceiver_.append(GetMessageFromCode(ret)); 1013 } 1014 } else { 1015 resultReceiver_.append("\n"); 1016 resultReceiver_.append(ACCESSIBILITY_HELP_MSG_SET_DALTONIZATION_COLOR_FILTER); 1017 result = OHOS::ERR_INVALID_VALUE; 1018 } 1019 1020 return result; 1021} 1022 1023ErrCode AccessibilityAbilityShellCommand::RunAsSetContentTimeout() 1024{ 1025 AccessibilityCommandArgument argument; 1026 argument.command = "setContentTimeout"; 1027 ErrCode result = MakeSetCommandArgumentFromCmd(argument); 1028 if (result == OHOS::ERR_OK && !AccessibilityUtils::IsValidIntString(argument.value, 1029 CONTENT_TIME_OUT_TIME_LOW_BOUND, CONTENT_TIME_OUT_TIME_HIGH_BOUND)) { 1030 resultReceiver_.append(ACCESSIBILITY_ABILITY_SET_VALUE_INVALID); 1031 result = OHOS::ERR_INVALID_VALUE; 1032 } 1033 if (result == OHOS::ERR_OK) { 1034 auto& config = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 1035 (void)config.InitializeContext(); 1036 int32_t time = std::atoi(argument.value.c_str()); 1037 Accessibility::RetError ret = config.SetContentTimeout(time); 1038 if (ret == Accessibility::RET_OK) { 1039 resultReceiver_ = ACCESSIBILITY_SET_CONTENT_TIME_OK + "\n"; 1040 } else { 1041 resultReceiver_ = ACCESSIBILITY_SET_CONTENT_TIME_NG; 1042 resultReceiver_.append(GetMessageFromCode(ret)); 1043 } 1044 } else { 1045 resultReceiver_.append("\n"); 1046 resultReceiver_.append(ACCESSIBILITY_HELP_MSG_SET_CONTENT_TIME_OUT); 1047 result = OHOS::ERR_INVALID_VALUE; 1048 } 1049 1050 return result; 1051} 1052 1053ErrCode AccessibilityAbilityShellCommand::RunAsSetAnimationOffState() 1054{ 1055 AccessibilityCommandArgument argument; 1056 argument.command = "setAnimationOffState"; 1057 ErrCode result = MakeSetCommandArgumentFromCmd(argument); 1058 if (result == OHOS::ERR_OK && !AccessibilityUtils::IsValidStateString(argument.value)) { 1059 resultReceiver_.append(ACCESSIBILITY_ABILITY_SET_VALUE_INVALID); 1060 result = OHOS::ERR_INVALID_VALUE; 1061 } 1062 if (result == OHOS::ERR_OK) { 1063 auto& config = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 1064 (void)config.InitializeContext(); 1065 bool state = std::atoi(argument.value.c_str()) == 1; 1066 Accessibility::RetError ret = config.SetAnimationOffState(state); 1067 if (ret == Accessibility::RET_OK) { 1068 resultReceiver_ = ACCESSIBILITY_SET_ANIMATION_OFF_STATE_OK + "\n"; 1069 } else { 1070 resultReceiver_ = ACCESSIBILITY_SET_ANIMATION_OFF_STATE_NG; 1071 resultReceiver_.append(GetMessageFromCode(ret)); 1072 } 1073 } else { 1074 resultReceiver_.append("\n"); 1075 resultReceiver_.append(ACCESSIBILITY_HELP_MSG_ANIMATION_OFF_STATE); 1076 result = OHOS::ERR_INVALID_VALUE; 1077 } 1078 1079 return result; 1080} 1081 1082ErrCode AccessibilityAbilityShellCommand::RunAsSetBrightnessDiscount() 1083{ 1084 AccessibilityCommandArgument argument; 1085 argument.command = "setSetBrightnessDiscount"; 1086 ErrCode result = MakeSetCommandArgumentFromCmd(argument); 1087 if (result == OHOS::ERR_OK && !AccessibilityUtils::IsValidIntString(argument.value, 1088 BRIGHTNESS_DISCOUNT_LOW_BOUND, BRIGHTNESS_DISCOUNT_HIGH_BOUND)) { 1089 resultReceiver_.append(ACCESSIBILITY_ABILITY_SET_VALUE_INVALID); 1090 result = OHOS::ERR_INVALID_VALUE; 1091 } 1092 if (result == OHOS::ERR_OK) { 1093 auto& config = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 1094 (void)config.InitializeContext(); 1095 float discount = 1.0 * std::atoi(argument.value.c_str()) / 100; 1096 Accessibility::RetError ret = config.SetBrightnessDiscount(discount); 1097 if (ret == Accessibility::RET_OK) { 1098 resultReceiver_ = ACCESSIBILITY_SET_BRIGHTNESS_DISCOUNT_OK + "\n"; 1099 } else { 1100 resultReceiver_ = ACCESSIBILITY_SET_BRIGHTNESS_DISCOUNT_NG; 1101 resultReceiver_.append(GetMessageFromCode(ret)); 1102 } 1103 } else { 1104 resultReceiver_.append("\n"); 1105 resultReceiver_.append(ACCESSIBILITY_HELP_MSG_SET_BRIGHTNESS_DISCOUNT); 1106 result = OHOS::ERR_INVALID_VALUE; 1107 } 1108 1109 return result; 1110} 1111 1112ErrCode AccessibilityAbilityShellCommand::RunAsSetAudioMonoState() 1113{ 1114 AccessibilityCommandArgument argument; 1115 argument.command = "setAudioMonoState"; 1116 ErrCode result = MakeSetCommandArgumentFromCmd(argument); 1117 if (result == OHOS::ERR_OK && !AccessibilityUtils::IsValidStateString(argument.value)) { 1118 resultReceiver_.append(ACCESSIBILITY_ABILITY_SET_VALUE_INVALID); 1119 result = OHOS::ERR_INVALID_VALUE; 1120 } 1121 if (result == OHOS::ERR_OK) { 1122 auto& config = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 1123 (void)config.InitializeContext(); 1124 bool state = std::atoi(argument.value.c_str()) == 1; 1125 Accessibility::RetError ret = config.SetAudioMonoState(state); 1126 if (ret == Accessibility::RET_OK) { 1127 resultReceiver_ = ACCESSIBILITY_SET_AUDIO_MONO_STATE_OK + "\n"; 1128 } else { 1129 resultReceiver_ = ACCESSIBILITY_SET_AUDIO_MONO_STATE_NG; 1130 resultReceiver_.append(GetMessageFromCode(ret)); 1131 } 1132 } else { 1133 resultReceiver_.append("\n"); 1134 resultReceiver_.append(ACCESSIBILITY_HELP_MSG_SET_AUDIO_MONO_STATE); 1135 result = OHOS::ERR_INVALID_VALUE; 1136 } 1137 1138 return result; 1139} 1140 1141ErrCode AccessibilityAbilityShellCommand::RunAsSetAudioBalance() 1142{ 1143 AccessibilityCommandArgument argument; 1144 argument.command = "setAudioBalance"; 1145 ErrCode result = MakeSetCommandArgumentFromCmd(argument); 1146 if (result == OHOS::ERR_OK && !AccessibilityUtils::IsValidIntString(argument.value, 1147 AUDIO_BALANCE_LOW_BOUND, AUDIO_BALANCE_HIGH_BOUND)) { 1148 resultReceiver_.append(ACCESSIBILITY_ABILITY_SET_VALUE_INVALID); 1149 result = OHOS::ERR_INVALID_VALUE; 1150 } 1151 if (result == OHOS::ERR_OK) { 1152 auto& config = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 1153 (void)config.InitializeContext(); 1154 float balance = 1.0 * std::atoi(argument.value.c_str()) / 100; 1155 Accessibility::RetError ret = config.SetAudioBalance(balance); 1156 if (ret == Accessibility::RET_OK) { 1157 resultReceiver_ = ACCESSIBILITY_SET_AUDIO_BALANCE_OK + "\n"; 1158 } else { 1159 resultReceiver_ = ACCESSIBILITY_SET_AUDIO_BALANCE_NG; 1160 resultReceiver_.append(GetMessageFromCode(ret)); 1161 } 1162 } else { 1163 resultReceiver_.append("\n"); 1164 resultReceiver_.append(ACCESSIBILITY_HELP_MSG_SET_AUDIO_BALANCE); 1165 result = OHOS::ERR_INVALID_VALUE; 1166 } 1167 return result; 1168} 1169 1170ErrCode AccessibilityAbilityShellCommand::MakeSetShortKeyTargetCommandArgumentFromCmd( 1171 AccessibilityCommandArgument& argument) 1172{ 1173 argument.command = "setShortkeyTarget"; 1174 ErrCode result = MakeCommandArgumentFromCmd(argument); 1175 if (result == OHOS::ERR_OK) { 1176 return CheckCommandArgument(argument, resultReceiver_); 1177 } 1178 return result; 1179} 1180 1181void AccessibilityAbilityShellCommand::SetArgument(int option, AccessibilityCommandArgument& argument) 1182{ 1183 switch (option) { 1184 case 'a': { 1185 argument.abilityName = optarg; 1186 argument.abilityArgumentNum++; 1187 break; 1188 } 1189 case 'b': { 1190 argument.bundleName = optarg; 1191 argument.bundleArgumentNum++; 1192 break; 1193 } 1194 default: { 1195 argument.unknownArgumentNum++; 1196 argument.unknownArguments.push_back(argv_[optind - 1]); 1197 break; 1198 } 1199 } 1200} 1201 1202ErrCode AccessibilityAbilityShellCommand::MakeCommandArgumentFromCmd(AccessibilityCommandArgument& argument) 1203{ 1204 int option = -1; 1205 int counter = 0; 1206 while (true) { 1207 counter++; 1208 option = getopt_long(argc_, argv_, DISABLE_SHORT_OPTIONS.c_str(), DISABLE_LONG_OPTIONS, nullptr); 1209 1210 TAG_LOGI( 1211 AAFwkTag::AA_TOOL, "optopt: %{public}d, option: %{public}d, optind: %{public}d", optopt, option, optind); 1212 1213 if (optind < 0 || optind > argc_) { 1214 return OHOS::ERR_INVALID_VALUE; 1215 } 1216 1217 if (option == -1) { 1218 if (counter == 1 && strcmp(argv_[optind], cmd_.c_str()) == 0) { 1219 resultReceiver_.append(argument.command + ": " + ACCESSIBILITY_HELP_MSG_NO_OPTION); 1220 return OHOS::ERR_INVALID_VALUE; 1221 } 1222 break; 1223 } 1224 1225 if (option == '?') { 1226 option = optopt; 1227 switch (option) { 1228 case 'a': { 1229 resultReceiver_.append(argument.command + ": " + ACCESSIBILITY_ABILITY_NO_ABILITY_ARGUMENT_VALUE); 1230 return OHOS::ERR_INVALID_VALUE; 1231 } 1232 case 'b': { 1233 resultReceiver_.append(argument.command + ": " + ACCESSIBILITY_ABILITY_NO_BUNDLE_ARGUMENT_VALUE); 1234 return OHOS::ERR_INVALID_VALUE; 1235 } 1236 default: { 1237 break; 1238 } 1239 } 1240 } 1241 1242 SetArgument(option, argument); 1243 } 1244 return OHOS::ERR_OK; 1245} 1246 1247ErrCode AccessibilityAbilityShellCommand::MakeSetCommandArgumentFromCmd(AccessibilityCommandArgument& argument) 1248{ 1249 int option = -1; 1250 int counter = 0; 1251 1252 while (true) { 1253 counter++; 1254 1255 option = getopt_long(argc_, argv_, SET_SHORT_OPTIONS.c_str(), SET_LONG_OPTIONS, nullptr); 1256 1257 TAG_LOGI( 1258 AAFwkTag::AA_TOOL, "optind: %{public}d, optopt: %{public}d, option: %{public}d", optind, optopt, option); 1259 1260 if (optind < 0 || optind > argc_) { 1261 return OHOS::ERR_INVALID_VALUE; 1262 } 1263 1264 if (option == -1) { 1265 if (counter == 1 && strcmp(argv_[optind], cmd_.c_str()) == 0) { 1266 resultReceiver_.append(argument.command + ": " + ACCESSIBILITY_HELP_MSG_NO_OPTION); 1267 return OHOS::ERR_INVALID_VALUE; 1268 } 1269 break; 1270 } 1271 1272 if (option == '?') { 1273 option = optopt; 1274 switch (option) { 1275 case 'v': { 1276 resultReceiver_.append(argument.command + ": " + ACCESSIBILITY_ABILITY_NO_SET_ARGUMENT_VALUE); 1277 return OHOS::ERR_INVALID_VALUE; 1278 } 1279 default: { 1280 break; 1281 } 1282 } 1283 } 1284 1285 switch (option) { 1286 case 'v': { 1287 argument.value = optarg; 1288 argument.setArgumentNum++; 1289 break; 1290 } 1291 default: { 1292 argument.unknownArgumentNum++; 1293 argument.unknownArguments.push_back(argv_[optind - 1]); 1294 break; 1295 } 1296 } 1297 } 1298 return CheckSetCommandArgument(argument, resultReceiver_); 1299} 1300 1301} // namespace AAFwk 1302} // namespace OHOS