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
35 using namespace OHOS::AppExecFwk;
36
37 namespace OHOS {
38 namespace AAFwk {
39 namespace {
40 const std::string ENABLE_SHORT_OPTIONS = "a:b:c:";
41 const std::string DISABLE_SHORT_OPTIONS = "a:b:";
42 const std::string SET_SHORT_OPTIONS = "v:";
43 const std::string STRING_LIST_ABILITY_NG = "error: failed to list abilities";
44 const int32_t MOUSE_AUTO_CLICK_TIME_LOW_BOUND = 1000;
45 const int32_t MOUSE_AUTO_CLICK_TIME_HIGH_BOUND = 5000;
46 const int32_t CONTENT_TIME_OUT_TIME_LOW_BOUND = 0;
47 const int32_t CONTENT_TIME_OUT_TIME_HIGH_BOUND = 5000;
48 const int32_t AUDIO_BALANCE_LOW_BOUND = -100;
49 const int32_t AUDIO_BALANCE_HIGH_BOUND = 100;
50 const int32_t BRIGHTNESS_DISCOUNT_LOW_BOUND = 0;
51 const int32_t BRIGHTNESS_DISCOUNT_HIGH_BOUND = 100;
52 const int32_t DALTIONIZATION_TYPE_LOW_BOUND = 0;
53 const int32_t DALTIONIZATION_TYPE_HIGH_BOUND = 3;
54 const int32_t TYPE_NORMAL = 0;
55 const int32_t TYPE_PROTANOMALY = 1;
56 const int32_t TYPE_DEUTERANOMALY = 2;
57 const int32_t TYPE_TRITANOMALY = 3;
58 const int32_t ACCESSIBILITY_ENABLE_COMMAND_ARGUMENT_NUM = 3;
59 const int32_t ACCESSIBILITY_DISABLE_COMMAND_ARGUMENT_NUM = 2;
60 const int32_t ACCESSIBILITY_SET_COMMAND_ARGUMENT_NUM = 1;
61
62 const std::string ACCESSIBILITY_TOOL_NAME = "accessibility";
63 const std::string ACCESSIBILITY_STRING_ENABLE_ABILITY_OK = "enable ability successfully.";
64 const std::string ACCESSIBILITY_STRING_ENABLE_ABILITY_NG = "error: failed to enable ability.\n";
65
66 const std::string ACCESSIBILITY_SET_SCREEN_MAGNIFICATION_STATE_OK = "set screen magnification state successfully.";
67 const std::string ACCESSIBILITY_SET_SCREEN_MAGNIFICATION_STATE_NG = "error: failed to set screen magnification state\n";
68 const std::string ACCESSIBILITY_SET_SHORT_KEY_STATE_OK = "set short key state successfully.";
69 const std::string ACCESSIBILITY_SET_SHORT_KEY_STATE_NG = "error: failed to set short key state.\n";
70 const std::string ACCESSIBILITY_SET_MOUSE_KEY_STATE_OK = "set mouse key state successfully.";
71 const std::string ACCESSIBILITY_SET_MOUSE_KEY_STATE_NG = "error: failed to set mouse key state.\n";
72 const std::string ACCESSIBILITY_SET_CAPTION_STATE_OK = "set caption state successfully.";
73 const std::string ACCESSIBILITY_SET_CAPTION_STATE_NG = "error: failed to set caption state.\n";
74 const std::string ACCESSIBILITY_SET_HIGH_CONTRAST_TEXT_STATE_OK = "set high contrast text state successfully.";
75 const std::string ACCESSIBILITY_SET_HIGH_CONTRAST_TEXT_STATE_NG = "error: failed to set high contrast text state.\n";
76 const std::string ACCESSIBILITY_SET_INVERT_COLOR_STATE_OK = "set invert color state successfully.";
77 const std::string ACCESSIBILITY_SET_INVERT_COLOR_STATE_NG = "error: failed to set invert color state.\n";
78 const std::string ACCESSIBILITY_SET_ANIMATION_OFF_STATE_OK = "set animation off state successfully.";
79 const std::string ACCESSIBILITY_SET_ANIMATION_OFF_STATE_NG = "error: failed to set animation off state.\n";
80 const std::string ACCESSIBILITY_SET_AUDIO_MONO_STATE_OK = "set audio mono state successfully.";
81 const std::string ACCESSIBILITY_SET_AUDIO_MONO_STATE_NG = "error: failed to set audio mono state.\n";
82 const std::string ACCESSIBILITY_SET_AUTO_CLICK_TIME_OK = "set mouse auto click time successfully.";
83 const std::string ACCESSIBILITY_SET_AUTO_CLICK_TIME_NG = "error: failed to set mouse auto click time.\n";
84 const std::string ACCESSIBILITY_SET_SHORT_KEY_TARGET_OK = "set short key target successfully.";
85 const std::string ACCESSIBILITY_SET_SHORT_KEY_TARGET_NG = "error: failed to set short key target.\n";
86 const std::string ACCESSIBILITY_SET_AUDIO_BALANCE_OK = "set audio balance successfully.";
87 const std::string ACCESSIBILITY_SET_AUDIO_BALANCE_NG = "error: failed to set audio balance successfully.";
88 const std::string ACCESSIBILITY_SET_CONTENT_TIME_OK = "set content timeout successfully.";
89 const std::string ACCESSIBILITY_SET_CONTENT_TIME_NG = "error: failed to set content timeout.\n";
90 const std::string ACCESSIBILITY_SET_BRIGHTNESS_DISCOUNT_OK = "set brightness discount successfully.";
91 const std::string ACCESSIBILITY_SET_BRIGHTNESS_DISCOUNT_NG = "error: failed to set brightness discount.\n";
92 const std::string ACCESSIBILITY_SET_DALTONIZATIONZATION_COLOR_FILTER_OK =
93 "set daltonization color filter successfully.";
94 const std::string ACCESSIBILITY_SET_DALTONIZATIONZATION_COLOR_FILTER_NG =
95 "error: failed to set daltonization color filter.\n";
96
97 const std::string ACCESSIBILITY_ABILITY_NOT_FOUND = " was not found!";
98 const std::string ACCESSIBILITY_HELP_MSG_NO_OPTION = "missing options.";
99
100 const std::string ACCESSIBILITY_ABILITY_NO_BUNDLE_ARGUMENT =
101 "argument -b <bundle-name> or --bundle=<bundle-name> is required!";
102 const std::string ACCESSIBILITY_ABILITY_NO_ABILITY_ARGUMENT =
103 "argument -a <ability-name> or --ability=<ability-name> is required!";
104 const std::string ACCESSIBILITY_ABILITY_NO_CAPABILITIES_ARGUMENT =
105 "argument -c <capabilities-abbr>"
106 " or --capabilities=<capabilities-abbr> is required!";
107
108 const std::string ACCESSIBILITY_ABILITY_TOO_MANY_ARGUMENT = "there are too many arguments ";
109 const std::string ACCESSIBILITY_ABILITY_DUPLICATE_ARGUMENT = "there are duplicate arguments.";
110
111 const std::string ACCESSIBILITY_STRING_DISABLE_ABILITY_OK = "disable ability successfully.";
112 const std::string ACCESSIBILITY_STRING_DISABLE_ABILITY_NG = "error: failed to disable ability.";
113
114 const std::string ACCESSIBILITY_ABILITY_NO_ABILITY_ARGUMENT_VALUE = "option -a requires a value.";
115 const std::string ACCESSIBILITY_ABILITY_NO_BUNDLE_ARGUMENT_VALUE = "option -b requires a value.";
116 const std::string ACCESSIBILITY_ABILITY_NO_CAPABILITIES_ARGUMENT_VALUE = "option -c requires a value.";
117 const std::string ACCESSIBILITY_ABILITY_NO_SET_ARGUMENT_VALUE = "option -v requires a value.";
118
119 const std::string ACCESSIBILITY_ABILITY_SET_VALUE_INVALID = "value is invalid.";
120
121 const 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
142 const 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
146 const 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
150 const 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
158 const 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
162 const 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
166 const 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
170 const 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
174 const 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
178 const 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
182 const 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
187 const 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
191 const 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
195 const 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
200 const 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
204 const 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
209 const 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
214 const 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
220 constexpr 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
227 constexpr struct option DISABLE_LONG_OPTIONS[] = {
228 {"ability", required_argument, nullptr, 'a'},
229 {"bundle", required_argument, nullptr, 'b'},
230 {nullptr, 0, nullptr, 0},
231 };
232
233 constexpr struct option SET_LONG_OPTIONS[] = {
234 {"value", required_argument, nullptr, 'v'},
235 {nullptr, 0, nullptr, 0},
236 };
237 } // namespace
238
AccessibilityAbilityShellCommand(int argc,char * argv[])239 AccessibilityAbilityShellCommand::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
init()257 ErrCode 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
CreateMessageMap()308 ErrCode AccessibilityAbilityShellCommand::CreateMessageMap()
309 {
310 return OHOS::ERR_OK;
311 }
312
CreateCommandMap()313 ErrCode AccessibilityAbilityShellCommand::CreateCommandMap()
314 {
315 commandMap_ = {
316 };
317
318 return OHOS::ERR_OK;
319 }
320
RunAsHelpCommand()321 ErrCode AccessibilityAbilityShellCommand::RunAsHelpCommand()
322 {
323 resultReceiver_.append(ACCESSIBILITY_HELP_MSG);
324
325 return OHOS::ERR_OK;
326 }
327
CheckEnableCommandOption(const int option,AccessibilityCommandArgument & argument)328 void 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
MakeEnableCommandArgumentFromCmd(AccessibilityCommandArgument & argument)355 ErrCode 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
MakeDisableCommandArgumentFromCmd(AccessibilityCommandArgument & argument)405 ErrCode 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
RunAsEnableAbility()415 ErrCode 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
RunAsDisableAbility()441 ErrCode 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
RunAsGetEnabledAbilities()465 ErrCode 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
RunAsGetInstalledAbilities()479 ErrCode 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
GetEnabledAbilities()492 const 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
GetInstalledAbilities()502 const 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
CheckBundleArgument(const AccessibilityCommandArgument & argument,std::string & resultMessage)514 bool 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
CheckAbilityArgument(const AccessibilityCommandArgument & argument,std::string & resultMessage)533 bool 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
CheckCapabilitiesArgument(const AccessibilityCommandArgument & argument,std::vector<Accessibility::AccessibilityAbilityInfo> & installedAbilities,std::string & resultMessage)552 bool 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
CheckParamValidity(const AccessibilityCommandArgument & argument,std::vector<Accessibility::AccessibilityAbilityInfo> & installedAbilities,std::string & resultMessage)572 bool 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
CheckEnableCommandArgument(const AccessibilityCommandArgument & argument,std::string & resultMessage)601 ErrCode 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
CheckDisableCommandArgument(const AccessibilityCommandArgument & argument,std::string & resultMessage)654 ErrCode 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
CheckCommandArgument(const AccessibilityCommandArgument & argument,std::string & resultMessage)676 ErrCode 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
CheckSetCommandArgument(const AccessibilityCommandArgument & argument,std::string & resultMessage)715 ErrCode 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
RunAsSetScreenMagnificationState()743 ErrCode 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
RunAsSetShortKeyState()772 ErrCode 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
RunAsSetMouseKeyState()801 ErrCode 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
RunAsSetCaptionState()830 ErrCode 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
RunAsSetMouseAutoClick()859 ErrCode 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
RunAsSetShortKeyTarget()889 ErrCode 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
RunAsSetHighContrastTextState()913 ErrCode 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
RunAsSetInvertColorState()942 ErrCode 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
RunAsSetDaltonizationColorFilter()971 ErrCode 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
RunAsSetContentTimeout()1023 ErrCode 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
RunAsSetAnimationOffState()1053 ErrCode 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
RunAsSetBrightnessDiscount()1082 ErrCode 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
RunAsSetAudioMonoState()1112 ErrCode 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
RunAsSetAudioBalance()1141 ErrCode 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
MakeSetShortKeyTargetCommandArgumentFromCmd(AccessibilityCommandArgument & argument)1170 ErrCode 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
SetArgument(int option,AccessibilityCommandArgument & argument)1181 void 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
MakeCommandArgumentFromCmd(AccessibilityCommandArgument & argument)1202 ErrCode 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
MakeSetCommandArgumentFromCmd(AccessibilityCommandArgument & argument)1247 ErrCode 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