1 /*
2 * Copyright (c) 2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15 #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_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 HILOG_INFO("argv_[%{public}d]: %{public}s", i, argv_[i]);
244 }
245 if (abilityClientPtr_ == nullptr) {
246 abilityClientPtr_ = Accessibility::AccessibilitySystemAbilityClient::GetInstance();
247 if (abilityClientPtr_ == nullptr) {
248 HILOG_ERROR("Get accessibility system ability client failed.");
249 }
250 }
251 int32_t addPermissionResult = AccessibilityUtils::AddPermission();
252 if (addPermissionResult != 0) {
253 HILOG_ERROR("Add permission for accessibility tool 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
MakeEnableCommandArgumentFromCmd(AccessibilityCommandArgument & argument)328 ErrCode AccessibilityAbilityShellCommand::MakeEnableCommandArgumentFromCmd(AccessibilityCommandArgument& argument)
329 {
330 int option = -1;
331 int counter = 0;
332 argument.command = "enable";
333 while (true) {
334 counter++;
335
336 option = getopt_long(argc_, argv_, ENABLE_SHORT_OPTIONS.c_str(), ENABLE_LONG_OPTIONS, nullptr);
337
338 HILOG_INFO("option: %{public}d, optind: %{public}d, optopt: %{public}d", option, optind, optopt);
339
340 if (optind < 0 || optind > argc_) {
341 return OHOS::ERR_INVALID_VALUE;
342 }
343
344 if (option == -1) {
345 if (counter == 1 && strcmp(argv_[optind], cmd_.c_str()) == 0) {
346 resultReceiver_.append(argument.command + ": " + ACCESSIBILITY_HELP_MSG_NO_OPTION);
347 return OHOS::ERR_INVALID_VALUE;
348 }
349 break;
350 }
351
352 if (option == '?') {
353 switch (optopt) {
354 case 'a': {
355 resultReceiver_.append(argument.command + ": " + ACCESSIBILITY_ABILITY_NO_ABILITY_ARGUMENT_VALUE);
356 return OHOS::ERR_INVALID_VALUE;
357 }
358 case 'b': {
359 resultReceiver_.append(argument.command + ": " + ACCESSIBILITY_ABILITY_NO_BUNDLE_ARGUMENT_VALUE);
360 return OHOS::ERR_INVALID_VALUE;
361 }
362 case 'c': {
363 resultReceiver_.append(argument.command + ": " +
364 ACCESSIBILITY_ABILITY_NO_CAPABILITIES_ARGUMENT_VALUE);
365 return OHOS::ERR_INVALID_VALUE;
366 }
367 default: {
368 break;
369 }
370 }
371 }
372
373 switch (option) {
374 case 'a': {
375 argument.abilityName = optarg;
376 argument.abilityArgumentNum++;
377 break;
378 }
379 case 'b': {
380 argument.bundleName = optarg;
381 argument.bundleArgumentNum++;
382 break;
383 }
384 case 'c': {
385 argument.capabilityNames = optarg;
386 argument.capabilityNamesArgumentNum++;
387 break;
388 }
389 default: {
390 argument.unknownArgumentNum++;
391 argument.unknownArguments.push_back(argv_[optind - 1]);
392 break;
393 }
394 }
395 }
396 return CheckEnableCommandArgument(argument, resultReceiver_);
397 }
398
MakeDisableCommandArgumentFromCmd(AccessibilityCommandArgument & argument)399 ErrCode AccessibilityAbilityShellCommand::MakeDisableCommandArgumentFromCmd(AccessibilityCommandArgument& argument)
400 {
401 argument.command = "disable";
402 ErrCode result = MakeCommandArgumentFromCmd(argument);
403 if (result == OHOS::ERR_OK) {
404 return CheckDisableCommandArgument(argument, resultReceiver_);
405 }
406 return result;
407 }
408
RunAsEnableAbility()409 ErrCode AccessibilityAbilityShellCommand::RunAsEnableAbility()
410 {
411 AccessibilityCommandArgument argument;
412 ErrCode result = MakeEnableCommandArgumentFromCmd(argument);
413 if (result == OHOS::ERR_OK) {
414 auto& config = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance();
415 (void)config.InitializeContext();
416 std::string name = argument.bundleName + "/" + argument.abilityName;
417 std::string capabilityNames = argument.capabilityNames;
418 uint32_t capabilities = AccessibilityUtils::GetCapabilityValue(capabilityNames);
419 Accessibility::RetError ret = config.EnableAbility(name, capabilities);
420 if (ret == Accessibility::RET_OK) {
421 resultReceiver_ = ACCESSIBILITY_STRING_ENABLE_ABILITY_OK + "\n";
422 } else {
423 resultReceiver_ = ACCESSIBILITY_STRING_ENABLE_ABILITY_NG;
424 resultReceiver_.append(GetMessageFromCode(ret));
425 }
426 } else {
427 resultReceiver_.append("\n");
428 resultReceiver_.append(ACCESSIBILITY_HELP_MSG_ENABLE_ABILITY);
429 result = OHOS::ERR_INVALID_VALUE;
430 }
431
432 return result;
433 }
434
RunAsDisableAbility()435 ErrCode AccessibilityAbilityShellCommand::RunAsDisableAbility()
436 {
437 AccessibilityCommandArgument argument;
438 ErrCode result = MakeDisableCommandArgumentFromCmd(argument);
439 if (result == OHOS::ERR_OK) {
440 auto& config = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance();
441 (void)config.InitializeContext();
442 std::string name = argument.bundleName + "/" + argument.abilityName;
443 Accessibility::RetError ret = config.DisableAbility(name);
444 if (ret == Accessibility::RET_OK) {
445 resultReceiver_ = ACCESSIBILITY_STRING_DISABLE_ABILITY_OK + "\n";
446 } else {
447 resultReceiver_ = ACCESSIBILITY_STRING_DISABLE_ABILITY_NG;
448 resultReceiver_.append(GetMessageFromCode(ret));
449 }
450 } else {
451 resultReceiver_.append("\n");
452 resultReceiver_.append(ACCESSIBILITY_HELP_MSG_DISABLE_ABILITY);
453 result = OHOS::ERR_INVALID_VALUE;
454 }
455
456 return result;
457 }
458
RunAsGetEnabledAbilities()459 ErrCode AccessibilityAbilityShellCommand::RunAsGetEnabledAbilities()
460 {
461 ErrCode result = OHOS::ERR_OK;
462 std::vector<std::string> enabledAbilities = GetEnabledAbilities();
463 if (!enabledAbilities.empty()) {
464 for (const auto& ability : enabledAbilities) {
465 resultReceiver_.append(ability + "\n");
466 }
467 } else {
468 result = OHOS::ERR_INVALID_VALUE;
469 }
470 return result;
471 }
472
RunAsGetInstalledAbilities()473 ErrCode AccessibilityAbilityShellCommand::RunAsGetInstalledAbilities()
474 {
475 ErrCode result = OHOS::ERR_OK;
476 std::vector<Accessibility::AccessibilityAbilityInfo> installedAbilities = GetInstalledAbilities();
477 if (!installedAbilities.empty()) {
478 resultReceiver_.append(AccessibilityUtils::FormatAbilityInfos(installedAbilities));
479 resultReceiver_.append(ACCESSIBILITY_HELP_MSG_LIST_ABILITIES);
480 } else {
481 result = OHOS::ERR_INVALID_VALUE;
482 }
483 return result;
484 }
485
GetEnabledAbilities()486 const std::vector<std::string> AccessibilityAbilityShellCommand::GetEnabledAbilities()
487 {
488 std::vector<std::string> enabledAbilities;
489 if (abilityClientPtr_ != nullptr &&
490 (abilityClientPtr_->GetEnabledAbilities(enabledAbilities) != Accessibility::RET_OK)) {
491 HILOG_ERROR("Failed to GetEnabledAbilities");
492 }
493 return enabledAbilities;
494 }
495
GetInstalledAbilities()496 const std::vector<Accessibility::AccessibilityAbilityInfo> AccessibilityAbilityShellCommand::GetInstalledAbilities()
497 {
498 std::vector<Accessibility::AccessibilityAbilityInfo> installedAbilities;
499 const uint32_t allTypes = Accessibility::AccessibilityAbilityTypes::ACCESSIBILITY_ABILITY_TYPE_ALL;
500 const Accessibility::AbilityStateType stateType = Accessibility::AbilityStateType::ABILITY_STATE_INSTALLED;
501 if (abilityClientPtr_ != nullptr &&
502 (abilityClientPtr_->GetAbilityList(allTypes, stateType, installedAbilities) != Accessibility::RET_OK)) {
503 HILOG_ERROR("Failed to GetInstalledAbilities");
504 }
505 return installedAbilities;
506 }
507
CheckBundleArgument(const AccessibilityCommandArgument & argument,std::string & resultMessage)508 bool AccessibilityAbilityShellCommand::CheckBundleArgument(
509 const AccessibilityCommandArgument& argument,
510 std::string& resultMessage)
511 {
512 if (argument.bundleArgumentNum == 0) {
513 resultMessage.append(ACCESSIBILITY_ABILITY_NO_BUNDLE_ARGUMENT);
514 return false;
515 }
516 if (argument.bundleArgumentNum > 1) {
517 resultMessage.append(ACCESSIBILITY_ABILITY_DUPLICATE_ARGUMENT);
518 return false;
519 }
520 if (argument.bundleName.empty() || argument.bundleName[0] == '-') {
521 resultMessage.append(ACCESSIBILITY_ABILITY_NO_BUNDLE_ARGUMENT_VALUE);
522 return false;
523 }
524 return true;
525 }
526
CheckAbilityArgument(const AccessibilityCommandArgument & argument,std::string & resultMessage)527 bool AccessibilityAbilityShellCommand::CheckAbilityArgument(
528 const AccessibilityCommandArgument& argument,
529 std::string& resultMessage)
530 {
531 if (argument.abilityArgumentNum == 0) {
532 resultMessage.append(ACCESSIBILITY_ABILITY_NO_ABILITY_ARGUMENT);
533 return false;
534 }
535 if (argument.abilityArgumentNum > 1) {
536 resultMessage.append(ACCESSIBILITY_ABILITY_DUPLICATE_ARGUMENT);
537 return false;
538 }
539 if (argument.abilityName.empty() || argument.abilityName[0] == '-') {
540 resultMessage.append(ACCESSIBILITY_ABILITY_NO_ABILITY_ARGUMENT_VALUE);
541 return false;
542 }
543 return true;
544 }
545
CheckCapabilitiesArgument(const AccessibilityCommandArgument & argument,std::vector<Accessibility::AccessibilityAbilityInfo> & installedAbilities,std::string & resultMessage)546 bool AccessibilityAbilityShellCommand::CheckCapabilitiesArgument(
547 const AccessibilityCommandArgument& argument,
548 std::vector<Accessibility::AccessibilityAbilityInfo>& installedAbilities,
549 std::string& resultMessage)
550 {
551 if (argument.capabilityNamesArgumentNum == 0) {
552 resultMessage.append(ACCESSIBILITY_ABILITY_NO_CAPABILITIES_ARGUMENT);
553 return false;
554 }
555 if (argument.capabilityNamesArgumentNum > 1) {
556 resultMessage.append(ACCESSIBILITY_ABILITY_DUPLICATE_ARGUMENT);
557 return false;
558 }
559 if (argument.capabilityNames.empty() || argument.capabilityNames[0] == '-') {
560 resultMessage.append(ACCESSIBILITY_ABILITY_NO_CAPABILITIES_ARGUMENT_VALUE);
561 return false;
562 }
563 return true;
564 }
565
CheckParamValidity(const AccessibilityCommandArgument & argument,std::vector<Accessibility::AccessibilityAbilityInfo> & installedAbilities,std::string & resultMessage)566 bool AccessibilityAbilityShellCommand::CheckParamValidity(
567 const AccessibilityCommandArgument& argument,
568 std::vector<Accessibility::AccessibilityAbilityInfo>& installedAbilities,
569 std::string& resultMessage)
570 {
571 const std::string& abilityName = argument.abilityName;
572 const std::string& bundleName = argument.bundleName;
573 const std::string& capabilityNames = argument.capabilityNames;
574 bool isExisted = false;
575 for (auto& ability : installedAbilities) {
576 if (ability.GetName() == abilityName && ability.GetPackageName() == bundleName) {
577 isExisted = true;
578 const std::string staticCapabilityNames = AccessibilityUtils::GetStaticCapabilityNames(ability);
579 std::string invalidCapabilityNames = AccessibilityUtils::GetInvalidCapabilityNames(capabilityNames,
580 staticCapabilityNames);
581 if (!invalidCapabilityNames.empty()) {
582 resultMessage.append("the capabilities " + invalidCapabilityNames + ACCESSIBILITY_ABILITY_NOT_FOUND);
583 return false;
584 }
585 }
586 }
587 if (!isExisted) {
588 resultMessage.append("the auxiliary application " +
589 bundleName + "/" + abilityName + ACCESSIBILITY_ABILITY_NOT_FOUND);
590 return false;
591 }
592 return true;
593 }
594
CheckEnableCommandArgument(const AccessibilityCommandArgument & argument,std::string & resultMessage)595 ErrCode AccessibilityAbilityShellCommand::CheckEnableCommandArgument(const AccessibilityCommandArgument& argument,
596 std::string& resultMessage)
597 {
598 ErrCode result = OHOS::ERR_OK;
599 resultMessage.append(argument.command + ": ");
600 int32_t totalArgumentNum = argument.bundleArgumentNum + argument.abilityArgumentNum +
601 argument.capabilityNamesArgumentNum + argument.unknownArgumentNum;
602 if (totalArgumentNum > ACCESSIBILITY_ENABLE_COMMAND_ARGUMENT_NUM) {
603 resultReceiver_.append(ACCESSIBILITY_ABILITY_TOO_MANY_ARGUMENT);
604 if (argument.bundleArgumentNum > 1 || argument.abilityArgumentNum > 1 ||
605 argument.capabilityNamesArgumentNum > 1) {
606 resultMessage.append("and exist duplicated arguments");
607 }
608 if (argument.unknownArgumentNum > 0) {
609 resultMessage.append("and exist unknown arguments.");
610 resultMessage.append(AccessibilityUtils::GetUnknownArgumentsMsg(argument.unknownArguments));
611 }
612 return OHOS::ERR_INVALID_VALUE;
613 }
614 if (argument.unknownArgumentNum > 0) {
615 resultMessage.append("unknown arguments.");
616 resultMessage.append(AccessibilityUtils::GetUnknownArgumentsMsg(argument.unknownArguments));
617 return OHOS::ERR_INVALID_VALUE;
618 }
619 std::vector<Accessibility::AccessibilityAbilityInfo> installedAbilities = GetInstalledAbilities();
620 if (!CheckAbilityArgument(argument, resultMessage)) {
621 HILOG_ERROR("abilityName = %{public}s is invalid.", argument.abilityName.c_str());
622 return OHOS::ERR_INVALID_VALUE;
623 }
624 if (!CheckBundleArgument(argument, resultMessage)) {
625 HILOG_ERROR("bundleName = %{public}s is invalid.", argument.bundleName.c_str());
626 return OHOS::ERR_INVALID_VALUE;
627 }
628 if (!CheckCapabilitiesArgument(argument, installedAbilities, resultMessage)) {
629 HILOG_ERROR("capabilityNames = %{public}s is invalid", argument.capabilityNames.c_str());
630 return OHOS::ERR_INVALID_VALUE;
631 }
632 if (!CheckParamValidity(argument, installedAbilities, resultMessage)) {
633 HILOG_ERROR("%{public}s/%{public}s is not installed",
634 argument.bundleName.c_str(), argument.abilityName.c_str());
635 return OHOS::ERR_INVALID_VALUE;
636 }
637 std::vector<std::string> enabledAbilities = GetEnabledAbilities();
638 std::string currentAbility = argument.bundleName + "/" + argument.abilityName;
639 for (const auto& ability : enabledAbilities) {
640 if (ability == currentAbility) {
641 resultMessage.append("the auxiliary application has been enabled.");
642 return OHOS::ERR_INVALID_VALUE;
643 }
644 }
645 return result;
646 }
647
CheckDisableCommandArgument(const AccessibilityCommandArgument & argument,std::string & resultMessage)648 ErrCode AccessibilityAbilityShellCommand::CheckDisableCommandArgument(const AccessibilityCommandArgument& argument,
649 std::string& resultMessage)
650 {
651 ErrCode result = CheckCommandArgument(argument, resultMessage);
652 if (result == OHOS::ERR_OK) {
653 std::vector<std::string> enabledAbilities = GetEnabledAbilities();
654 std::string currentAbility = argument.bundleName + "/" + argument.abilityName;
655 bool isEnabled = false;
656 for (const auto& ability : enabledAbilities) {
657 if (ability == currentAbility) {
658 isEnabled = true;
659 break;
660 }
661 }
662 if (!isEnabled) {
663 resultMessage.append("the auxiliary application was not enabled and could not be disabled.");
664 return OHOS::ERR_INVALID_VALUE;
665 }
666 }
667 return result;
668 }
669
CheckCommandArgument(const AccessibilityCommandArgument & argument,std::string & resultMessage)670 ErrCode AccessibilityAbilityShellCommand::CheckCommandArgument(const AccessibilityCommandArgument& argument,
671 std::string& resultMessage)
672 {
673 resultMessage.append(argument.command + ": ");
674 int32_t totalArgumentNum = argument.bundleArgumentNum + argument.abilityArgumentNum +
675 argument.capabilityNamesArgumentNum + argument.unknownArgumentNum;
676 if (totalArgumentNum > ACCESSIBILITY_DISABLE_COMMAND_ARGUMENT_NUM) {
677 resultReceiver_.append(ACCESSIBILITY_ABILITY_TOO_MANY_ARGUMENT);
678 if (argument.bundleArgumentNum > 1 || argument.abilityArgumentNum > 1) {
679 resultMessage.append("and duplicated arguments exist.");
680 }
681 if (argument.unknownArgumentNum > 0) {
682 resultMessage.append("and unknown arguments exist.");
683 resultMessage.append(AccessibilityUtils::GetUnknownArgumentsMsg(argument.unknownArguments));
684 }
685 return OHOS::ERR_INVALID_VALUE;
686 }
687 if (argument.unknownArgumentNum > 0) {
688 resultMessage.append("unknown arguments exist.");
689 resultMessage.append(AccessibilityUtils::GetUnknownArgumentsMsg(argument.unknownArguments));
690 return OHOS::ERR_INVALID_VALUE;
691 }
692 std::vector<Accessibility::AccessibilityAbilityInfo> installedAbilities = GetInstalledAbilities();
693 if (!CheckAbilityArgument(argument, resultMessage)) {
694 HILOG_ERROR("abilityName = %{public}s is invalid", argument.abilityName.c_str());
695 return OHOS::ERR_INVALID_VALUE;
696 }
697 if (!CheckBundleArgument(argument, resultMessage)) {
698 HILOG_ERROR("bundleName = %{public}s is invalid", argument.bundleName.c_str());
699 return OHOS::ERR_INVALID_VALUE;
700 }
701 if (!CheckParamValidity(argument, installedAbilities, resultMessage)) {
702 HILOG_ERROR("%{public}s/%{public}s is not installed",
703 argument.bundleName.c_str(), argument.abilityName.c_str());
704 return OHOS::ERR_INVALID_VALUE;
705 }
706 return OHOS::ERR_OK;
707 }
708
CheckSetCommandArgument(const AccessibilityCommandArgument & argument,std::string & resultMessage)709 ErrCode AccessibilityAbilityShellCommand::CheckSetCommandArgument(const AccessibilityCommandArgument& argument,
710 std::string& resultMessage)
711 {
712 resultMessage.append(argument.command + ": ");
713 int32_t totalArgumentNum = argument.setArgumentNum + argument.unknownArgumentNum;
714 if (totalArgumentNum > ACCESSIBILITY_SET_COMMAND_ARGUMENT_NUM) {
715 resultReceiver_.append(ACCESSIBILITY_ABILITY_TOO_MANY_ARGUMENT);
716 if (argument.setArgumentNum > 1) {
717 resultMessage.append("and exist duplicated arguments.");
718 }
719 if (argument.unknownArgumentNum > 0) {
720 resultMessage.append("and exist unknown arguments ");
721 resultMessage.append(AccessibilityUtils::GetUnknownArgumentsMsg(argument.unknownArguments));
722 }
723 return OHOS::ERR_INVALID_VALUE;
724 }
725 if (argument.unknownArgumentNum > 0) {
726 resultMessage.append("unknown arguments ");
727 resultMessage.append(AccessibilityUtils::GetUnknownArgumentsMsg(argument.unknownArguments));
728 return OHOS::ERR_INVALID_VALUE;
729 }
730 if (argument.setArgumentNum == 0) {
731 resultMessage.append(ACCESSIBILITY_HELP_MSG_NO_OPTION);
732 return OHOS::ERR_INVALID_VALUE;
733 }
734 return OHOS::ERR_OK;
735 }
736
RunAsSetScreenMagnificationState()737 ErrCode AccessibilityAbilityShellCommand::RunAsSetScreenMagnificationState()
738 {
739 AccessibilityCommandArgument argument;
740 argument.command = "setScreenMagnificationState";
741 ErrCode result = MakeSetCommandArgumentFromCmd(argument);
742 if (result == OHOS::ERR_OK && !AccessibilityUtils::IsValidStateString(argument.value)) {
743 resultReceiver_.append(ACCESSIBILITY_ABILITY_SET_VALUE_INVALID);
744 result = OHOS::ERR_INVALID_VALUE;
745 }
746 if (result == OHOS::ERR_OK) {
747 auto& config = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance();
748 (void)config.InitializeContext();
749 bool state = std::atoi(argument.value.c_str()) == 1;
750 Accessibility::RetError ret = config.SetScreenMagnificationState(state);
751 if (ret == Accessibility::RET_OK) {
752 resultReceiver_ = ACCESSIBILITY_SET_SCREEN_MAGNIFICATION_STATE_OK + "\n";
753 } else {
754 resultReceiver_ = ACCESSIBILITY_SET_SCREEN_MAGNIFICATION_STATE_NG;
755 resultReceiver_.append(GetMessageFromCode(ret));
756 }
757 } else {
758 resultReceiver_.append("\n");
759 resultReceiver_.append(ACCESSIBILITY_HELP_MSG_SET_SCREEN_MAGNIFICATION_STATE);
760 result = OHOS::ERR_INVALID_VALUE;
761 }
762
763 return result;
764 }
765
RunAsSetShortKeyState()766 ErrCode AccessibilityAbilityShellCommand::RunAsSetShortKeyState()
767 {
768 AccessibilityCommandArgument argument;
769 argument.command = "setShortKeyState";
770 ErrCode result = MakeSetCommandArgumentFromCmd(argument);
771 if (result == OHOS::ERR_OK && !AccessibilityUtils::IsValidStateString(argument.value)) {
772 resultReceiver_.append(ACCESSIBILITY_ABILITY_SET_VALUE_INVALID);
773 result = OHOS::ERR_INVALID_VALUE;
774 }
775 if (result == OHOS::ERR_OK) {
776 auto& config = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance();
777 (void)config.InitializeContext();
778 bool state = std::atoi(argument.value.c_str()) == 1;
779 Accessibility::RetError ret = config.SetShortKeyState(state);
780 if (ret == Accessibility::RET_OK) {
781 resultReceiver_ = ACCESSIBILITY_SET_SHORT_KEY_STATE_OK + "\n";
782 } else {
783 resultReceiver_ = ACCESSIBILITY_SET_SHORT_KEY_STATE_NG;
784 resultReceiver_.append(GetMessageFromCode(ret));
785 }
786 } else {
787 resultReceiver_.append("\n");
788 resultReceiver_.append(ACCESSIBILITY_HELP_MSG_SET_SHORT_KEY_STATE);
789 result = OHOS::ERR_INVALID_VALUE;
790 }
791
792 return result;
793 }
794
RunAsSetMouseKeyState()795 ErrCode AccessibilityAbilityShellCommand::RunAsSetMouseKeyState()
796 {
797 AccessibilityCommandArgument argument;
798 argument.command = "setMouseKeyState";
799 ErrCode result = MakeSetCommandArgumentFromCmd(argument);
800 if (result == OHOS::ERR_OK && !AccessibilityUtils::IsValidStateString(argument.value)) {
801 resultReceiver_.append(ACCESSIBILITY_ABILITY_SET_VALUE_INVALID);
802 result = OHOS::ERR_INVALID_VALUE;
803 }
804 if (result == OHOS::ERR_OK) {
805 auto& config = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance();
806 (void)config.InitializeContext();
807 bool state = std::atoi(argument.value.c_str()) == 1;
808 Accessibility::RetError ret = config.SetMouseKeyState(state);
809 if (ret == Accessibility::RET_OK) {
810 resultReceiver_ = ACCESSIBILITY_SET_MOUSE_KEY_STATE_OK + "\n";
811 } else {
812 resultReceiver_ = ACCESSIBILITY_SET_MOUSE_KEY_STATE_NG;
813 resultReceiver_.append(GetMessageFromCode(ret));
814 }
815 } else {
816 resultReceiver_.append("\n");
817 resultReceiver_.append(ACCESSIBILITY_HELP_MSG_SET_MOUSE_KEY_STATE);
818 result = OHOS::ERR_INVALID_VALUE;
819 }
820
821 return result;
822 }
823
RunAsSetCaptionState()824 ErrCode AccessibilityAbilityShellCommand::RunAsSetCaptionState()
825 {
826 AccessibilityCommandArgument argument;
827 argument.command = "setCaptionState";
828 ErrCode result = MakeSetCommandArgumentFromCmd(argument);
829 if (result == OHOS::ERR_OK && !AccessibilityUtils::IsValidStateString(argument.value)) {
830 resultReceiver_.append(ACCESSIBILITY_ABILITY_SET_VALUE_INVALID);
831 result = OHOS::ERR_INVALID_VALUE;
832 }
833 if (result == OHOS::ERR_OK) {
834 auto& config = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance();
835 (void)config.InitializeContext();
836 bool state = std::atoi(argument.value.c_str()) == 1;
837 Accessibility::RetError ret = config.SetCaptionsState(state);
838 if (ret == Accessibility::RET_OK) {
839 resultReceiver_ = ACCESSIBILITY_SET_CAPTION_STATE_OK + "\n";
840 } else {
841 resultReceiver_ = ACCESSIBILITY_SET_CAPTION_STATE_NG;
842 resultReceiver_.append(GetMessageFromCode(ret));
843 }
844 } else {
845 resultReceiver_.append("\n");
846 resultReceiver_.append(ACCESSIBILITY_HELP_MSG_SET_CAPTION_STATE);
847 result = OHOS::ERR_INVALID_VALUE;
848 }
849
850 return result;
851 }
852
RunAsSetMouseAutoClick()853 ErrCode AccessibilityAbilityShellCommand::RunAsSetMouseAutoClick()
854 {
855 AccessibilityCommandArgument argument;
856 argument.command = "setMouseAutoClick";
857 ErrCode result = MakeSetCommandArgumentFromCmd(argument);
858 if (result == OHOS::ERR_OK && !AccessibilityUtils::IsValidIntString(argument.value,
859 MOUSE_AUTO_CLICK_TIME_LOW_BOUND, MOUSE_AUTO_CLICK_TIME_HIGH_BOUND)) {
860 resultReceiver_.append(ACCESSIBILITY_ABILITY_SET_VALUE_INVALID);
861 result = OHOS::ERR_INVALID_VALUE;
862 }
863 if (result == OHOS::ERR_OK) {
864 auto& config = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance();
865 (void)config.InitializeContext();
866 float time = 1.0 * std::atoi(argument.value.c_str()) / 100;
867 Accessibility::RetError ret = config.SetMouseAutoClick(time);
868 if (ret == Accessibility::RET_OK) {
869 resultReceiver_ = ACCESSIBILITY_SET_AUTO_CLICK_TIME_OK + "\n";
870 } else {
871 resultReceiver_ = ACCESSIBILITY_SET_AUTO_CLICK_TIME_NG;
872 resultReceiver_.append(GetMessageFromCode(ret));
873 }
874 } else {
875 resultReceiver_.append("\n");
876 resultReceiver_.append(ACCESSIBILITY_HELP_MSG_SET_AUTO_CLICK_TIME);
877 result = OHOS::ERR_INVALID_VALUE;
878 }
879
880 return result;
881 }
882
RunAsSetShortKeyTarget()883 ErrCode AccessibilityAbilityShellCommand::RunAsSetShortKeyTarget()
884 {
885 AccessibilityCommandArgument argument;
886 ErrCode result = MakeSetShortKeyTargetCommandArgumentFromCmd(argument);
887 if (result == OHOS::ERR_OK) {
888 auto& config = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance();
889 (void)config.InitializeContext();
890 std::string name = argument.bundleName + "/" + argument.abilityName;
891 Accessibility::RetError ret = config.SetShortkeyTarget(name);
892 if (ret == Accessibility::RET_OK) {
893 resultReceiver_ = ACCESSIBILITY_SET_SHORT_KEY_TARGET_OK + "\n";
894 } else {
895 resultReceiver_ = ACCESSIBILITY_SET_SHORT_KEY_TARGET_NG;
896 resultReceiver_.append(GetMessageFromCode(ret));
897 }
898 } else {
899 resultReceiver_.append("\n");
900 resultReceiver_.append(ACCESSIBILITY_HELP_MSG_SET_SHORT_KEY_TARGET);
901 result = OHOS::ERR_INVALID_VALUE;
902 }
903
904 return result;
905 }
906
RunAsSetHighContrastTextState()907 ErrCode AccessibilityAbilityShellCommand::RunAsSetHighContrastTextState()
908 {
909 AccessibilityCommandArgument argument;
910 argument.command = "setHighContrastTextState";
911 ErrCode result = MakeSetCommandArgumentFromCmd(argument);
912 if (result == OHOS::ERR_OK && !AccessibilityUtils::IsValidStateString(argument.value)) {
913 resultReceiver_.append(ACCESSIBILITY_ABILITY_SET_VALUE_INVALID);
914 result = OHOS::ERR_INVALID_VALUE;
915 }
916 if (result == OHOS::ERR_OK) {
917 auto& config = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance();
918 (void)config.InitializeContext();
919 bool state = std::atoi(argument.value.c_str()) == 1;
920 Accessibility::RetError ret = config.SetHighContrastTextState(state);
921 if (ret == Accessibility::RET_OK) {
922 resultReceiver_ = ACCESSIBILITY_SET_HIGH_CONTRAST_TEXT_STATE_OK + "\n";
923 } else {
924 resultReceiver_ = ACCESSIBILITY_SET_HIGH_CONTRAST_TEXT_STATE_NG;
925 resultReceiver_.append(GetMessageFromCode(ret));
926 }
927 } else {
928 resultReceiver_.append("\n");
929 resultReceiver_.append(ACCESSIBILITY_HELP_MSG_HIGH_CONTRAST_TEXT_STATE);
930 result = OHOS::ERR_INVALID_VALUE;
931 }
932
933 return result;
934 }
935
RunAsSetInvertColorState()936 ErrCode AccessibilityAbilityShellCommand::RunAsSetInvertColorState()
937 {
938 AccessibilityCommandArgument argument;
939 argument.command = "setInvertColorState";
940 ErrCode result = MakeSetCommandArgumentFromCmd(argument);
941 if (result == OHOS::ERR_OK && !AccessibilityUtils::IsValidStateString(argument.value)) {
942 resultReceiver_.append(ACCESSIBILITY_ABILITY_SET_VALUE_INVALID);
943 result = OHOS::ERR_INVALID_VALUE;
944 }
945 if (result == OHOS::ERR_OK) {
946 auto& config = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance();
947 (void)config.InitializeContext();
948 bool state = std::atoi(argument.value.c_str()) == 1;
949 Accessibility::RetError ret = config.SetInvertColorState(state);
950 if (ret == Accessibility::RET_OK) {
951 resultReceiver_ = ACCESSIBILITY_SET_INVERT_COLOR_STATE_OK + "\n";
952 } else {
953 resultReceiver_ = ACCESSIBILITY_SET_INVERT_COLOR_STATE_NG;
954 resultReceiver_.append(GetMessageFromCode(ret));
955 }
956 } else {
957 resultReceiver_.append("\n");
958 resultReceiver_.append(ACCESSIBILITY_HELP_MSG_SET_INVERT_COLOR_STATE);
959 result = OHOS::ERR_INVALID_VALUE;
960 }
961
962 return result;
963 }
964
RunAsSetDaltonizationColorFilter()965 ErrCode AccessibilityAbilityShellCommand::RunAsSetDaltonizationColorFilter()
966 {
967 AccessibilityCommandArgument argument;
968 argument.command = "setDaltonizationColorFilter";
969 ErrCode result = MakeSetCommandArgumentFromCmd(argument);
970 if (result == OHOS::ERR_OK && !AccessibilityUtils::IsValidIntString(argument.value,
971 DALTIONIZATION_TYPE_LOW_BOUND, DALTIONIZATION_TYPE_HIGH_BOUND)) {
972 resultReceiver_.append(ACCESSIBILITY_ABILITY_SET_VALUE_INVALID);
973 return OHOS::ERR_INVALID_VALUE;
974 }
975 if (result == OHOS::ERR_OK) {
976 auto& config = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance();
977 (void)config.InitializeContext();
978 int32_t value = std::atoi(argument.value.c_str());
979 AccessibilityConfig::DALTONIZATION_TYPE type = AccessibilityConfig::DALTONIZATION_TYPE::Normal;
980 switch (value) {
981 case TYPE_NORMAL: {
982 type = AccessibilityConfig::DALTONIZATION_TYPE::Normal;
983 break;
984 }
985 case TYPE_PROTANOMALY: {
986 type = AccessibilityConfig::DALTONIZATION_TYPE::Protanomaly;
987 break;
988 }
989 case TYPE_DEUTERANOMALY: {
990 type = AccessibilityConfig::DALTONIZATION_TYPE::Deuteranomaly;
991 break;
992 }
993 case TYPE_TRITANOMALY: {
994 type = AccessibilityConfig::DALTONIZATION_TYPE::Tritanomaly;
995 break;
996 }
997 default: {
998 break;
999 }
1000 }
1001 Accessibility::RetError ret = config.SetDaltonizationColorFilter(type);
1002 if (ret == Accessibility::RET_OK) {
1003 resultReceiver_ = ACCESSIBILITY_SET_DALTONIZATIONZATION_COLOR_FILTER_OK + "\n";
1004 } else {
1005 resultReceiver_ = ACCESSIBILITY_SET_DALTONIZATIONZATION_COLOR_FILTER_NG;
1006 resultReceiver_.append(GetMessageFromCode(ret));
1007 }
1008 } else {
1009 resultReceiver_.append("\n");
1010 resultReceiver_.append(ACCESSIBILITY_HELP_MSG_SET_DALTONIZATION_COLOR_FILTER);
1011 result = OHOS::ERR_INVALID_VALUE;
1012 }
1013
1014 return result;
1015 }
1016
RunAsSetContentTimeout()1017 ErrCode AccessibilityAbilityShellCommand::RunAsSetContentTimeout()
1018 {
1019 AccessibilityCommandArgument argument;
1020 argument.command = "setContentTimeout";
1021 ErrCode result = MakeSetCommandArgumentFromCmd(argument);
1022 if (result == OHOS::ERR_OK && !AccessibilityUtils::IsValidIntString(argument.value,
1023 CONTENT_TIME_OUT_TIME_LOW_BOUND, CONTENT_TIME_OUT_TIME_HIGH_BOUND)) {
1024 resultReceiver_.append(ACCESSIBILITY_ABILITY_SET_VALUE_INVALID);
1025 result = OHOS::ERR_INVALID_VALUE;
1026 }
1027 if (result == OHOS::ERR_OK) {
1028 auto& config = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance();
1029 (void)config.InitializeContext();
1030 int32_t time = std::atoi(argument.value.c_str());
1031 Accessibility::RetError ret = config.SetContentTimeout(time);
1032 if (ret == Accessibility::RET_OK) {
1033 resultReceiver_ = ACCESSIBILITY_SET_CONTENT_TIME_OK + "\n";
1034 } else {
1035 resultReceiver_ = ACCESSIBILITY_SET_CONTENT_TIME_NG;
1036 resultReceiver_.append(GetMessageFromCode(ret));
1037 }
1038 } else {
1039 resultReceiver_.append("\n");
1040 resultReceiver_.append(ACCESSIBILITY_HELP_MSG_SET_CONTENT_TIME_OUT);
1041 result = OHOS::ERR_INVALID_VALUE;
1042 }
1043
1044 return result;
1045 }
1046
RunAsSetAnimationOffState()1047 ErrCode AccessibilityAbilityShellCommand::RunAsSetAnimationOffState()
1048 {
1049 AccessibilityCommandArgument argument;
1050 argument.command = "setAnimationOffState";
1051 ErrCode result = MakeSetCommandArgumentFromCmd(argument);
1052 if (result == OHOS::ERR_OK && !AccessibilityUtils::IsValidStateString(argument.value)) {
1053 resultReceiver_.append(ACCESSIBILITY_ABILITY_SET_VALUE_INVALID);
1054 result = OHOS::ERR_INVALID_VALUE;
1055 }
1056 if (result == OHOS::ERR_OK) {
1057 auto& config = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance();
1058 (void)config.InitializeContext();
1059 bool state = std::atoi(argument.value.c_str()) == 1;
1060 Accessibility::RetError ret = config.SetAnimationOffState(state);
1061 if (ret == Accessibility::RET_OK) {
1062 resultReceiver_ = ACCESSIBILITY_SET_ANIMATION_OFF_STATE_OK + "\n";
1063 } else {
1064 resultReceiver_ = ACCESSIBILITY_SET_ANIMATION_OFF_STATE_NG;
1065 resultReceiver_.append(GetMessageFromCode(ret));
1066 }
1067 } else {
1068 resultReceiver_.append("\n");
1069 resultReceiver_.append(ACCESSIBILITY_HELP_MSG_ANIMATION_OFF_STATE);
1070 result = OHOS::ERR_INVALID_VALUE;
1071 }
1072
1073 return result;
1074 }
1075
RunAsSetBrightnessDiscount()1076 ErrCode AccessibilityAbilityShellCommand::RunAsSetBrightnessDiscount()
1077 {
1078 AccessibilityCommandArgument argument;
1079 argument.command = "setSetBrightnessDiscount";
1080 ErrCode result = MakeSetCommandArgumentFromCmd(argument);
1081 if (result == OHOS::ERR_OK && !AccessibilityUtils::IsValidIntString(argument.value,
1082 BRIGHTNESS_DISCOUNT_LOW_BOUND, BRIGHTNESS_DISCOUNT_HIGH_BOUND)) {
1083 resultReceiver_.append(ACCESSIBILITY_ABILITY_SET_VALUE_INVALID);
1084 result = OHOS::ERR_INVALID_VALUE;
1085 }
1086 if (result == OHOS::ERR_OK) {
1087 auto& config = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance();
1088 (void)config.InitializeContext();
1089 float discount = 1.0 * std::atoi(argument.value.c_str()) / 100;
1090 Accessibility::RetError ret = config.SetBrightnessDiscount(discount);
1091 if (ret == Accessibility::RET_OK) {
1092 resultReceiver_ = ACCESSIBILITY_SET_BRIGHTNESS_DISCOUNT_OK + "\n";
1093 } else {
1094 resultReceiver_ = ACCESSIBILITY_SET_BRIGHTNESS_DISCOUNT_NG;
1095 resultReceiver_.append(GetMessageFromCode(ret));
1096 }
1097 } else {
1098 resultReceiver_.append("\n");
1099 resultReceiver_.append(ACCESSIBILITY_HELP_MSG_SET_BRIGHTNESS_DISCOUNT);
1100 result = OHOS::ERR_INVALID_VALUE;
1101 }
1102
1103 return result;
1104 }
1105
RunAsSetAudioMonoState()1106 ErrCode AccessibilityAbilityShellCommand::RunAsSetAudioMonoState()
1107 {
1108 AccessibilityCommandArgument argument;
1109 argument.command = "setAudioMonoState";
1110 ErrCode result = MakeSetCommandArgumentFromCmd(argument);
1111 if (result == OHOS::ERR_OK && !AccessibilityUtils::IsValidStateString(argument.value)) {
1112 resultReceiver_.append(ACCESSIBILITY_ABILITY_SET_VALUE_INVALID);
1113 result = OHOS::ERR_INVALID_VALUE;
1114 }
1115 if (result == OHOS::ERR_OK) {
1116 auto& config = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance();
1117 (void)config.InitializeContext();
1118 bool state = std::atoi(argument.value.c_str()) == 1;
1119 Accessibility::RetError ret = config.SetAudioMonoState(state);
1120 if (ret == Accessibility::RET_OK) {
1121 resultReceiver_ = ACCESSIBILITY_SET_AUDIO_MONO_STATE_OK + "\n";
1122 } else {
1123 resultReceiver_ = ACCESSIBILITY_SET_AUDIO_MONO_STATE_NG;
1124 resultReceiver_.append(GetMessageFromCode(ret));
1125 }
1126 } else {
1127 resultReceiver_.append("\n");
1128 resultReceiver_.append(ACCESSIBILITY_HELP_MSG_SET_AUDIO_MONO_STATE);
1129 result = OHOS::ERR_INVALID_VALUE;
1130 }
1131
1132 return result;
1133 }
1134
RunAsSetAudioBalance()1135 ErrCode AccessibilityAbilityShellCommand::RunAsSetAudioBalance()
1136 {
1137 AccessibilityCommandArgument argument;
1138 argument.command = "setAudioBalance";
1139 ErrCode result = MakeSetCommandArgumentFromCmd(argument);
1140 if (result == OHOS::ERR_OK && !AccessibilityUtils::IsValidIntString(argument.value,
1141 AUDIO_BALANCE_LOW_BOUND, AUDIO_BALANCE_HIGH_BOUND)) {
1142 resultReceiver_.append(ACCESSIBILITY_ABILITY_SET_VALUE_INVALID);
1143 result = OHOS::ERR_INVALID_VALUE;
1144 }
1145 if (result == OHOS::ERR_OK) {
1146 auto& config = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance();
1147 (void)config.InitializeContext();
1148 float balance = 1.0 * std::atoi(argument.value.c_str()) / 100;
1149 Accessibility::RetError ret = config.SetAudioBalance(balance);
1150 if (ret == Accessibility::RET_OK) {
1151 resultReceiver_ = ACCESSIBILITY_SET_AUDIO_BALANCE_OK + "\n";
1152 } else {
1153 resultReceiver_ = ACCESSIBILITY_SET_AUDIO_BALANCE_NG;
1154 resultReceiver_.append(GetMessageFromCode(ret));
1155 }
1156 } else {
1157 resultReceiver_.append("\n");
1158 resultReceiver_.append(ACCESSIBILITY_HELP_MSG_SET_AUDIO_BALANCE);
1159 result = OHOS::ERR_INVALID_VALUE;
1160 }
1161 return result;
1162 }
1163
MakeSetShortKeyTargetCommandArgumentFromCmd(AccessibilityCommandArgument & argument)1164 ErrCode AccessibilityAbilityShellCommand::MakeSetShortKeyTargetCommandArgumentFromCmd(
1165 AccessibilityCommandArgument& argument)
1166 {
1167 argument.command = "setShortkeyTarget";
1168 ErrCode result = MakeCommandArgumentFromCmd(argument);
1169 if (result == OHOS::ERR_OK) {
1170 return CheckCommandArgument(argument, resultReceiver_);
1171 }
1172 return result;
1173 }
1174
MakeCommandArgumentFromCmd(AccessibilityCommandArgument & argument)1175 ErrCode AccessibilityAbilityShellCommand::MakeCommandArgumentFromCmd(AccessibilityCommandArgument& argument)
1176 {
1177 int option = -1;
1178 int counter = 0;
1179 while (true) {
1180 counter++;
1181 option = getopt_long(argc_, argv_, DISABLE_SHORT_OPTIONS.c_str(), DISABLE_LONG_OPTIONS, nullptr);
1182
1183 HILOG_INFO("optopt: %{public}d, option: %{public}d, optind: %{public}d", optopt, option, optind);
1184
1185 if (optind < 0 || optind > argc_) {
1186 return OHOS::ERR_INVALID_VALUE;
1187 }
1188
1189 if (option == -1) {
1190 if (counter == 1 && strcmp(argv_[optind], cmd_.c_str()) == 0) {
1191 resultReceiver_.append(argument.command + ": " + ACCESSIBILITY_HELP_MSG_NO_OPTION);
1192 return OHOS::ERR_INVALID_VALUE;
1193 }
1194 break;
1195 }
1196
1197 if (option == '?') {
1198 option = optopt;
1199 switch (option) {
1200 case 'a': {
1201 resultReceiver_.append(argument.command + ": " + ACCESSIBILITY_ABILITY_NO_ABILITY_ARGUMENT_VALUE);
1202 return OHOS::ERR_INVALID_VALUE;
1203 }
1204 case 'b': {
1205 resultReceiver_.append(argument.command + ": " + ACCESSIBILITY_ABILITY_NO_BUNDLE_ARGUMENT_VALUE);
1206 return OHOS::ERR_INVALID_VALUE;
1207 }
1208 default: {
1209 break;
1210 }
1211 }
1212 }
1213
1214 switch (option) {
1215 case 'a': {
1216 argument.abilityName = optarg;
1217 argument.abilityArgumentNum++;
1218 break;
1219 }
1220 case 'b': {
1221 argument.bundleName = optarg;
1222 argument.bundleArgumentNum++;
1223 break;
1224 }
1225 default: {
1226 argument.unknownArgumentNum++;
1227 argument.unknownArguments.push_back(argv_[optind - 1]);
1228 break;
1229 }
1230 }
1231 }
1232 return OHOS::ERR_OK;
1233 }
1234
MakeSetCommandArgumentFromCmd(AccessibilityCommandArgument & argument)1235 ErrCode AccessibilityAbilityShellCommand::MakeSetCommandArgumentFromCmd(AccessibilityCommandArgument& argument)
1236 {
1237 int option = -1;
1238 int counter = 0;
1239
1240 while (true) {
1241 counter++;
1242
1243 option = getopt_long(argc_, argv_, SET_SHORT_OPTIONS.c_str(), SET_LONG_OPTIONS, nullptr);
1244
1245 HILOG_INFO("optind: %{public}d, optopt: %{public}d, option: %{public}d", optind, optopt, option);
1246
1247 if (optind < 0 || optind > argc_) {
1248 return OHOS::ERR_INVALID_VALUE;
1249 }
1250
1251 if (option == -1) {
1252 if (counter == 1 && strcmp(argv_[optind], cmd_.c_str()) == 0) {
1253 resultReceiver_.append(argument.command + ": " + ACCESSIBILITY_HELP_MSG_NO_OPTION);
1254 return OHOS::ERR_INVALID_VALUE;
1255 }
1256 break;
1257 }
1258
1259 if (option == '?') {
1260 option = optopt;
1261 switch (option) {
1262 case 'v': {
1263 resultReceiver_.append(argument.command + ": " + ACCESSIBILITY_ABILITY_NO_SET_ARGUMENT_VALUE);
1264 return OHOS::ERR_INVALID_VALUE;
1265 }
1266 default: {
1267 break;
1268 }
1269 }
1270 }
1271
1272 switch (option) {
1273 case 'v': {
1274 argument.value = optarg;
1275 argument.setArgumentNum++;
1276 break;
1277 }
1278 default: {
1279 argument.unknownArgumentNum++;
1280 argument.unknownArguments.push_back(argv_[optind - 1]);
1281 break;
1282 }
1283 }
1284 }
1285 return CheckSetCommandArgument(argument, resultReceiver_);
1286 }
1287
1288 } // namespace AAFwk
1289 } // namespace OHOS
1290