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