/*
* Copyright (c) 2022 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "accessibility_ability_command.h"
#include "accessibility_ability_utils.h"
#include <csignal>
#include <cstdlib>
#include <fstream>
#include <getopt.h>
#include <regex>
#include "ability_manager_client.h"
#include "accessibility_config.h"
#include "accessibility_system_ability_client.h"
#include "bool_wrapper.h"
#include "hilog_wrapper.h"
#include "iservice_registry.h"
#include "mission_snapshot.h"
#include "sa_mgr_client.h"
#include "system_ability_definition.h"
#include "test_observer.h"
using namespace OHOS::AppExecFwk;
namespace OHOS {
namespace AAFwk {
namespace {
const std::string ENABLE_SHORT_OPTIONS = "a:b:c:";
const std::string DISABLE_SHORT_OPTIONS = "a:b:";
const std::string SET_SHORT_OPTIONS = "v:";
const std::string STRING_LIST_ABILITY_NG = "error: failed to list abilities";
const int32_t MOUSE_AUTO_CLICK_TIME_LOW_BOUND = 1000;
const int32_t MOUSE_AUTO_CLICK_TIME_HIGH_BOUND = 5000;
const int32_t CONTENT_TIME_OUT_TIME_LOW_BOUND = 0;
const int32_t CONTENT_TIME_OUT_TIME_HIGH_BOUND = 5000;
const int32_t AUDIO_BALANCE_LOW_BOUND = -100;
const int32_t AUDIO_BALANCE_HIGH_BOUND = 100;
const int32_t BRIGHTNESS_DISCOUNT_LOW_BOUND = 0;
const int32_t BRIGHTNESS_DISCOUNT_HIGH_BOUND = 100;
const int32_t DALTIONIZATION_TYPE_LOW_BOUND = 0;
const int32_t DALTIONIZATION_TYPE_HIGH_BOUND = 3;
const int32_t TYPE_NORMAL = 0;
const int32_t TYPE_PROTANOMALY = 1;
const int32_t TYPE_DEUTERANOMALY = 2;
const int32_t TYPE_TRITANOMALY = 3;
const int32_t ACCESSIBILITY_ENABLE_COMMAND_ARGUMENT_NUM = 3;
const int32_t ACCESSIBILITY_DISABLE_COMMAND_ARGUMENT_NUM = 2;
const int32_t ACCESSIBILITY_SET_COMMAND_ARGUMENT_NUM = 1;
const std::string ACCESSIBILITY_TOOL_NAME = "accessibility";
const std::string ACCESSIBILITY_STRING_ENABLE_ABILITY_OK = "enable ability successfully.";
const std::string ACCESSIBILITY_STRING_ENABLE_ABILITY_NG = "error: failed to enable ability.\n";
const std::string ACCESSIBILITY_SET_SCREEN_MAGNIFICATION_STATE_OK = "set screen magnification state successfully.";
const std::string ACCESSIBILITY_SET_SCREEN_MAGNIFICATION_STATE_NG = "error: failed to set screen magnification state\n";
const std::string ACCESSIBILITY_SET_SHORT_KEY_STATE_OK = "set short key state successfully.";
const std::string ACCESSIBILITY_SET_SHORT_KEY_STATE_NG = "error: failed to set short key state.\n";
const std::string ACCESSIBILITY_SET_MOUSE_KEY_STATE_OK = "set mouse key state successfully.";
const std::string ACCESSIBILITY_SET_MOUSE_KEY_STATE_NG = "error: failed to set mouse key state.\n";
const std::string ACCESSIBILITY_SET_CAPTION_STATE_OK = "set caption state successfully.";
const std::string ACCESSIBILITY_SET_CAPTION_STATE_NG = "error: failed to set caption state.\n";
const std::string ACCESSIBILITY_SET_HIGH_CONTRAST_TEXT_STATE_OK = "set high contrast text state successfully.";
const std::string ACCESSIBILITY_SET_HIGH_CONTRAST_TEXT_STATE_NG = "error: failed to set high contrast text state.\n";
const std::string ACCESSIBILITY_SET_INVERT_COLOR_STATE_OK = "set invert color state successfully.";
const std::string ACCESSIBILITY_SET_INVERT_COLOR_STATE_NG = "error: failed to set invert color state.\n";
const std::string ACCESSIBILITY_SET_ANIMATION_OFF_STATE_OK = "set animation off state successfully.";
const std::string ACCESSIBILITY_SET_ANIMATION_OFF_STATE_NG = "error: failed to set animation off state.\n";
const std::string ACCESSIBILITY_SET_AUDIO_MONO_STATE_OK = "set audio mono state successfully.";
const std::string ACCESSIBILITY_SET_AUDIO_MONO_STATE_NG = "error: failed to set audio mono state.\n";
const std::string ACCESSIBILITY_SET_AUTO_CLICK_TIME_OK = "set mouse auto click time successfully.";
const std::string ACCESSIBILITY_SET_AUTO_CLICK_TIME_NG = "error: failed to set mouse auto click time.\n";
const std::string ACCESSIBILITY_SET_SHORT_KEY_TARGET_OK = "set short key target successfully.";
const std::string ACCESSIBILITY_SET_SHORT_KEY_TARGET_NG = "error: failed to set short key target.\n";
const std::string ACCESSIBILITY_SET_AUDIO_BALANCE_OK = "set audio balance successfully.";
const std::string ACCESSIBILITY_SET_AUDIO_BALANCE_NG = "error: failed to set audio balance successfully.";
const std::string ACCESSIBILITY_SET_CONTENT_TIME_OK = "set content timeout successfully.";
const std::string ACCESSIBILITY_SET_CONTENT_TIME_NG = "error: failed to set content timeout.\n";
const std::string ACCESSIBILITY_SET_BRIGHTNESS_DISCOUNT_OK = "set brightness discount successfully.";
const std::string ACCESSIBILITY_SET_BRIGHTNESS_DISCOUNT_NG = "error: failed to set brightness discount.\n";
const std::string ACCESSIBILITY_SET_DALTONIZATIONZATION_COLOR_FILTER_OK =
"set daltonization color filter successfully.";
const std::string ACCESSIBILITY_SET_DALTONIZATIONZATION_COLOR_FILTER_NG =
"error: failed to set daltonization color filter.\n";
const std::string ACCESSIBILITY_ABILITY_NOT_FOUND = " was not found!";
const std::string ACCESSIBILITY_HELP_MSG_NO_OPTION = "missing options.";
const std::string ACCESSIBILITY_ABILITY_NO_BUNDLE_ARGUMENT =
"argument -b <bundle-name> or --bundle=<bundle-name> is required!";
const std::string ACCESSIBILITY_ABILITY_NO_ABILITY_ARGUMENT =
"argument -a <ability-name> or --ability=<ability-name> is required!";
const std::string ACCESSIBILITY_ABILITY_NO_CAPABILITIES_ARGUMENT =
"argument -c <capabilities-abbr>"
" or --capabilities=<capabilities-abbr> is required!";
const std::string ACCESSIBILITY_ABILITY_TOO_MANY_ARGUMENT = "there are too many arguments ";
const std::string ACCESSIBILITY_ABILITY_DUPLICATE_ARGUMENT = "there are duplicate arguments.";
const std::string ACCESSIBILITY_STRING_DISABLE_ABILITY_OK = "disable ability successfully.";
const std::string ACCESSIBILITY_STRING_DISABLE_ABILITY_NG = "error: failed to disable ability.";
const std::string ACCESSIBILITY_ABILITY_NO_ABILITY_ARGUMENT_VALUE = "option -a requires a value.";
const std::string ACCESSIBILITY_ABILITY_NO_BUNDLE_ARGUMENT_VALUE = "option -b requires a value.";
const std::string ACCESSIBILITY_ABILITY_NO_CAPABILITIES_ARGUMENT_VALUE = "option -c requires a value.";
const std::string ACCESSIBILITY_ABILITY_NO_SET_ARGUMENT_VALUE = "option -v requires a value.";
const std::string ACCESSIBILITY_ABILITY_SET_VALUE_INVALID = "value is invalid.";
const std::string ACCESSIBILITY_HELP_MSG =
"usage: accessibility <command>\n"
"these are common accessibility commands list:\n"
" help list available commands\n"
" enable enable ability with options\n"
" disable disable ability with options\n"
" list list the installed abilities info\n"
" setShortKeyState set the state of the short key configuration item\n"
" setMouseKeyState set the state of the mouse key configuration item\n"
" setCaptionState set the state of the caption configuration item\n"
" setMouseAutoClick set the time of the mouse auto click configuration item\n"
" setShortKeyTarget set the name of the short key target configuration item\n"
" setHighContrastTextState set the state of the high contrast text configuration item\n"
" setInvertColorState set the state of the invert color configuration item\n"
" setDaltonizationColorFilter set the type of the daltonization color filter configuration item\n"
" setContentTimeout set the time of the toast content duration configuration item\n"
" setAnimationOffState set the state of the animation off configuration item\n"
" setBrightnessDiscount set the discount of the screen brightness configuration item\n"
" setAudioMonoState set the state of the audio mono configuration item\n"
" setAudioBalance set the value of the audio balance configuration item\n";
const std::string ACCESSIBILITY_HELP_MSG_ENABLE_ABILITY =
"usage: accessibility enable [-a <ability-name>] [-b <bundle-name>] [-c <capabilities-abbr>]\n"
"enable the auxiliary application with bundle-name and ability-name and capabilities-abbr\n";
const std::string ACCESSIBILITY_HELP_MSG_DISABLE_ABILITY =
"usage: accessibility disable [-a <ability-name>] [-b <bundle-name>]\n"
"disable the auxiliary application with bundle-name and ability-name\n";
const std::string ACCESSIBILITY_HELP_MSG_LIST_ABILITIES =
"the auxiliary capabilities supported by the accessibility subsystem are as follows:\n"
"r:retrieve enable the retrieval capability of auxiliary application\n"
"t:touch_guide enable the touch guide capability of auxiliary application\n"
"g:gesture enable the gesture injection capability of auxiliary application\n"
"k:key_event_observer enable the key event interception capability of auxiliary application\n"
"z:zoom enable the gesture zoom capability of auxiliary application\n";
const std::string ACCESSIBILITY_HELP_MSG_SET_SCREEN_MAGNIFICATION_STATE =
"usage: accessibility setScreenMagnificationState [-v <0 | 1> ]\n"
"set the state of the screen magnification configuration item\n";
const std::string ACCESSIBILITY_HELP_MSG_SET_SHORT_KEY_STATE =
"usage: accessibility setShortKeyState [-v <0 | 1> ]\n"
"set the state of the short key configuration item\n";
const std::string ACCESSIBILITY_HELP_MSG_SET_MOUSE_KEY_STATE =
"usage: accessibility setMouseKeyState [-v <0 | 1> ]\n"
"set the state of the mouse key configuration item\n";
const std::string ACCESSIBILITY_HELP_MSG_SET_CAPTION_STATE =
"usage: accessibility setCaptionState [-v <0 | 1> ]\n"
"set the state of the caption configuration item\n";
const std::string ACCESSIBILITY_HELP_MSG_HIGH_CONTRAST_TEXT_STATE =
"usage: accessibility setHighContrastTextState [-v <0 | 1> ]\n"
"set the state of the high contrast text configuration item\n";
const std::string ACCESSIBILITY_HELP_MSG_SET_INVERT_COLOR_STATE =
"usage: accessibility setInvertColorState [-v <0 | 1>]\n"
"set the state of the invert color configuration item\n";
const std::string ACCESSIBILITY_HELP_MSG_SET_DALTONIZATION_COLOR_FILTER =
"usage: accessibility setDaltonizationColorFilter [-v <0 | 1 | 2 | 3>]\n"
"normal = 0, protanomaly = 1, deuteranomaly = 2, tritanomaly = 3\n"
"set the type of the daltonization color filter configuration item\n";
const std::string ACCESSIBILITY_HELP_MSG_ANIMATION_OFF_STATE =
"usage: accessibility setAnimationOffState [-v <0 | 1>]\n"
"set the state of the animation off configuration item\n";
const std::string ACCESSIBILITY_HELP_MSG_SET_AUDIO_MONO_STATE =
"usage: accessibility setAudioMonoState [-v <0 | 1>]\n"
"set the state of the audio mono configuration item\n";
const std::string ACCESSIBILITY_HELP_MSG_SET_AUTO_CLICK_TIME =
"usage: accessibility setMouseAutoClick [-v <time-value>]\n"
"the range of time-value is 1000 to 5000 and the default unit is ms\n"
"set the time of the mouse auto click configuration item\n";
const std::string ACCESSIBILITY_HELP_MSG_SET_SHORT_KEY_TARGET =
"usage: accessibility setShortKeyTarget -a <ability-name> -b <bundle-name>\n"
"set the name of the short key target configuration item\n";
const std::string ACCESSIBILITY_HELP_MSG_SET_CONTENT_TIME_OUT =
"usage: accessibility setContentTimeout [-v <time-value>]\n"
"the range of time-value is 0 to 5000 and the default unit is ms\n"
"set the time of the toast content duration configuration item\n";
const std::string ACCESSIBILITY_HELP_MSG_SET_BRIGHTNESS_DISCOUNT =
"usage: accessibility setBrightnessDiscount [-v <discount-value>]\n"
"the percentage of discount-value is 0 to 100\n"
"set the discount of the screen brightness configuration item\n";
const std::string ACCESSIBILITY_HELP_MSG_SET_AUDIO_BALANCE =
"usage: accessibility setAudioBalance [-v <balance-value>]\n"
"the percentage of balance-value is -100 to 100\n"
"the negative values represent the left channel and positive values represent the right channel\n"
"set the value of the audio balance configuration item\n";
constexpr struct option ENABLE_LONG_OPTIONS[] = {
{"ability", required_argument, nullptr, 'a'},
{"bundle", required_argument, nullptr, 'b'},
{"capabilities", required_argument, nullptr, 'c'},
{nullptr, 0, nullptr, 0},
};
constexpr struct option DISABLE_LONG_OPTIONS[] = {
{"ability", required_argument, nullptr, 'a'},
{"bundle", required_argument, nullptr, 'b'},
{nullptr, 0, nullptr, 0},
};
constexpr struct option SET_LONG_OPTIONS[] = {
{"value", required_argument, nullptr, 'v'},
{nullptr, 0, nullptr, 0},
};
} // namespace
AccessibilityAbilityShellCommand::AccessibilityAbilityShellCommand(int argc, char* argv[])
: ShellCommand(argc, argv, ACCESSIBILITY_TOOL_NAME)
{
for (int i = 0; i < argc_; i++) {
HILOG_INFO("argv_[%{public}d]: %{public}s", i, argv_[i]);
}
if (abilityClientPtr_ == nullptr) {
abilityClientPtr_ = Accessibility::AccessibilitySystemAbilityClient::GetInstance();
if (abilityClientPtr_ == nullptr) {
HILOG_ERROR("Get accessibility system ability client failed.");
}
}
int32_t addPermissionResult = AccessibilityUtils::AddPermission();
if (addPermissionResult != 0) {
HILOG_ERROR("Add permission for accessibility tool failed.");
}
}
ErrCode AccessibilityAbilityShellCommand::init()
{
messageMap_ = {
{
Accessibility::RET_ERR_FAILED,
"reason: system exception.",
},
{
Accessibility::RET_ERR_INVALID_PARAM,
"reason: invalid param.",
},
{
Accessibility::RET_ERR_NULLPTR,
"reason: nullptr exception.",
},
{
Accessibility::RET_ERR_IPC_FAILED,
"reason: ipc failed.",
},
{
Accessibility::RET_ERR_SAMGR,
"reason: samgr error.",
},
{
Accessibility::RET_ERR_NO_PERMISSION,
"reason: no permissions.",
},
{
Accessibility::RET_ERR_TIME_OUT,
"reason: execution timeout.",
},
{
Accessibility::RET_ERR_CONNECTION_EXIST,
"reason: the ability is already enabled.",
},
{
Accessibility::RET_ERR_NO_CAPABILITY,
"reason: capabilities is wrong.",
},
{
Accessibility::RET_ERR_NOT_INSTALLED,
"reason: the auxiliary application is not installed.",
},
{
Accessibility::RET_ERR_NOT_ENABLED,
"reason: the auxiliary application is not enabled.",
}
};
return OHOS::ERR_OK;
}
ErrCode AccessibilityAbilityShellCommand::CreateMessageMap()
{
return OHOS::ERR_OK;
}
ErrCode AccessibilityAbilityShellCommand::CreateCommandMap()
{
commandMap_ = {
{"help", std::bind(&AccessibilityAbilityShellCommand::RunAsHelpCommand, this)},
{"enable", std::bind(&AccessibilityAbilityShellCommand::RunAsEnableAbility, this)},
{"disable", std::bind(&AccessibilityAbilityShellCommand::RunAsDisableAbility, this)},
{"list", std::bind(&AccessibilityAbilityShellCommand::RunAsGetInstalledAbilities, this)},
{"setShortKeyState", std::bind(&AccessibilityAbilityShellCommand::RunAsSetShortKeyState, this)},
{"setMouseKeyState", std::bind(&AccessibilityAbilityShellCommand::RunAsSetMouseKeyState, this)},
{"setCaptionState", std::bind(&AccessibilityAbilityShellCommand::RunAsSetCaptionState, this)},
{"setMouseAutoClick", std::bind(&AccessibilityAbilityShellCommand::RunAsSetMouseAutoClick, this)},
{"setShortKeyTarget", std::bind(&AccessibilityAbilityShellCommand::RunAsSetShortKeyTarget, this)},
{"setHighContrastTextState", std::bind(&AccessibilityAbilityShellCommand::RunAsSetHighContrastTextState, this)},
{"setInvertColorState", std::bind(&AccessibilityAbilityShellCommand::RunAsSetInvertColorState, this)},
{"setDaltonizationColorFilter",
std::bind(&AccessibilityAbilityShellCommand::RunAsSetDaltonizationColorFilter, this)},
{"setContentTimeout", std::bind(&AccessibilityAbilityShellCommand::RunAsSetContentTimeout, this)},
{"setAnimationOffState", std::bind(&AccessibilityAbilityShellCommand::RunAsSetAnimationOffState, this)},
{"setBrightnessDiscount", std::bind(&AccessibilityAbilityShellCommand::RunAsSetBrightnessDiscount, this)},
{"setAudioMonoState", std::bind(&AccessibilityAbilityShellCommand::RunAsSetAudioMonoState, this)},
{"setAudioBalance", std::bind(&AccessibilityAbilityShellCommand::RunAsSetAudioBalance, this)},
};
return OHOS::ERR_OK;
}
ErrCode AccessibilityAbilityShellCommand::RunAsHelpCommand()
{
resultReceiver_.append(ACCESSIBILITY_HELP_MSG);
return OHOS::ERR_OK;
}
ErrCode AccessibilityAbilityShellCommand::MakeEnableCommandArgumentFromCmd(AccessibilityCommandArgument& argument)
{
int option = -1;
int counter = 0;
argument.command = "enable";
while (true) {
counter++;
option = getopt_long(argc_, argv_, ENABLE_SHORT_OPTIONS.c_str(), ENABLE_LONG_OPTIONS, nullptr);
HILOG_INFO("option: %{public}d, optopt: %{public}d, optind: %{public}d", option, optopt, optind);
if (optind < 0 || optind > argc_) {
return OHOS::ERR_INVALID_VALUE;
}
if (option == -1) {
if (counter == 1 && strcmp(argv_[optind], cmd_.c_str()) == 0) {
resultReceiver_.append(argument.command + ": " + ACCESSIBILITY_HELP_MSG_NO_OPTION);
return OHOS::ERR_INVALID_VALUE;
}
break;
}
if (option == '?') {
switch (optopt) {
case 'a': {
resultReceiver_.append(argument.command + ": " + ACCESSIBILITY_ABILITY_NO_ABILITY_ARGUMENT_VALUE);
return OHOS::ERR_INVALID_VALUE;
}
case 'b': {
resultReceiver_.append(argument.command + ": " + ACCESSIBILITY_ABILITY_NO_BUNDLE_ARGUMENT_VALUE);
return OHOS::ERR_INVALID_VALUE;
}
case 'c': {
resultReceiver_.append(argument.command + ": " +
ACCESSIBILITY_ABILITY_NO_CAPABILITIES_ARGUMENT_VALUE);
return OHOS::ERR_INVALID_VALUE;
}
default: {
break;
}
}
}
switch (option) {
case 'a': {
argument.abilityName = optarg;
argument.abilityArgumentNum++;
break;
}
case 'b': {
argument.bundleName = optarg;
argument.bundleArgumentNum++;
break;
}
case 'c': {
argument.capabilityNames = optarg;
argument.capabilityNamesArgumentNum++;
break;
}
default: {
argument.unknownArgumentNum++;
argument.unknownArguments.push_back(argv_[optind - 1]);
break;
}
}
}
return CheckEnableCommandArgument(argument, resultReceiver_);
}
ErrCode AccessibilityAbilityShellCommand::MakeDisableCommandArgumentFromCmd(AccessibilityCommandArgument& argument)
{
argument.command = "disable";
ErrCode result = MakeCommandArgumentFromCmd(argument);
if (result == OHOS::ERR_OK) {
return CheckDisableCommandArgument(argument, resultReceiver_);
}
return result;
}
ErrCode AccessibilityAbilityShellCommand::RunAsEnableAbility()
{
AccessibilityCommandArgument argument;
ErrCode result = MakeEnableCommandArgumentFromCmd(argument);
if (result == OHOS::ERR_OK) {
auto& config = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance();
(void)config.InitializeContext();
std::string name = argument.bundleName + "/" + argument.abilityName;
std::string capabilityNames = argument.capabilityNames;
uint32_t capabilities = AccessibilityUtils::GetCapabilityValue(capabilityNames);
Accessibility::RetError ret = config.EnableAbility(name, capabilities);
if (ret == Accessibility::RET_OK) {
resultReceiver_ = ACCESSIBILITY_STRING_ENABLE_ABILITY_OK + "\n";
} else {
resultReceiver_ = ACCESSIBILITY_STRING_ENABLE_ABILITY_NG;
resultReceiver_.append(GetMessageFromCode(ret));
}
} else {
resultReceiver_.append("\n");
resultReceiver_.append(ACCESSIBILITY_HELP_MSG_ENABLE_ABILITY);
result = OHOS::ERR_INVALID_VALUE;
}
return result;
}
ErrCode AccessibilityAbilityShellCommand::RunAsDisableAbility()
{
AccessibilityCommandArgument argument;
ErrCode result = MakeDisableCommandArgumentFromCmd(argument);
if (result == OHOS::ERR_OK) {
auto& config = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance();
(void)config.InitializeContext();
std::string name = argument.bundleName + "/" + argument.abilityName;
Accessibility::RetError ret = config.DisableAbility(name);
if (ret == Accessibility::RET_OK) {
resultReceiver_ = ACCESSIBILITY_STRING_DISABLE_ABILITY_OK + "\n";
} else {
resultReceiver_ = ACCESSIBILITY_STRING_DISABLE_ABILITY_NG;
resultReceiver_.append(GetMessageFromCode(ret));
}
} else {
resultReceiver_.append("\n");
resultReceiver_.append(ACCESSIBILITY_HELP_MSG_DISABLE_ABILITY);
result = OHOS::ERR_INVALID_VALUE;
}
return result;
}
ErrCode AccessibilityAbilityShellCommand::RunAsGetEnabledAbilities()
{
ErrCode result = OHOS::ERR_OK;
std::vector<std::string> enabledAbilities = GetEnabledAbilities();
if (!enabledAbilities.empty()) {
for (const auto& ability : enabledAbilities) {
resultReceiver_.append(ability + "\n");
}
} else {
result = OHOS::ERR_INVALID_VALUE;
}
return result;
}
ErrCode AccessibilityAbilityShellCommand::RunAsGetInstalledAbilities()
{
ErrCode result = OHOS::ERR_OK;
std::vector<Accessibility::AccessibilityAbilityInfo> installedAbilities = GetInstalledAbilities();
if (!installedAbilities.empty()) {
resultReceiver_.append(AccessibilityUtils::FormatAbilityInfos(installedAbilities));
resultReceiver_.append(ACCESSIBILITY_HELP_MSG_LIST_ABILITIES);
} else {
result = OHOS::ERR_INVALID_VALUE;
}
return result;
}
const std::vector<std::string> AccessibilityAbilityShellCommand::GetEnabledAbilities()
{
std::vector<std::string> enabledAbilities;
if (abilityClientPtr_ != nullptr &&
(abilityClientPtr_->GetEnabledAbilities(enabledAbilities) != Accessibility::RET_OK)) {
HILOG_ERROR("Failed to GetEnabledAbilities");
}
return enabledAbilities;
}
const std::vector<Accessibility::AccessibilityAbilityInfo> AccessibilityAbilityShellCommand::GetInstalledAbilities()
{
std::vector<Accessibility::AccessibilityAbilityInfo> installedAbilities;
const uint32_t allTypes = Accessibility::AccessibilityAbilityTypes::ACCESSIBILITY_ABILITY_TYPE_ALL;
const Accessibility::AbilityStateType stateType = Accessibility::AbilityStateType::ABILITY_STATE_INSTALLED;
if (abilityClientPtr_ != nullptr &&
(abilityClientPtr_->GetAbilityList(allTypes, stateType, installedAbilities) != Accessibility::RET_OK)) {
HILOG_ERROR("Failed to GetInstalledAbilities");
}
return installedAbilities;
}
bool AccessibilityAbilityShellCommand::CheckBundleArgument(
const AccessibilityCommandArgument& argument,
std::string& resultMessage)
{
if (argument.bundleArgumentNum == 0) {
resultMessage.append(ACCESSIBILITY_ABILITY_NO_BUNDLE_ARGUMENT);
return false;
}
if (argument.bundleArgumentNum > 1) {
resultMessage.append(ACCESSIBILITY_ABILITY_DUPLICATE_ARGUMENT);
return false;
}
if (argument.bundleName.empty() || argument.bundleName[0] == '-') {
resultMessage.append(ACCESSIBILITY_ABILITY_NO_BUNDLE_ARGUMENT_VALUE);
return false;
}
return true;
}
bool AccessibilityAbilityShellCommand::CheckAbilityArgument(
const AccessibilityCommandArgument& argument,
std::string& resultMessage)
{
if (argument.abilityArgumentNum == 0) {
resultMessage.append(ACCESSIBILITY_ABILITY_NO_ABILITY_ARGUMENT);
return false;
}
if (argument.abilityArgumentNum > 1) {
resultMessage.append(ACCESSIBILITY_ABILITY_DUPLICATE_ARGUMENT);
return false;
}
if (argument.abilityName.empty() || argument.abilityName[0] == '-') {
resultMessage.append(ACCESSIBILITY_ABILITY_NO_ABILITY_ARGUMENT_VALUE);
return false;
}
return true;
}
bool AccessibilityAbilityShellCommand::CheckCapabilitiesArgument(
const AccessibilityCommandArgument& argument,
std::vector<Accessibility::AccessibilityAbilityInfo>& installedAbilities,
std::string& resultMessage)
{
if (argument.capabilityNamesArgumentNum == 0) {
resultMessage.append(ACCESSIBILITY_ABILITY_NO_CAPABILITIES_ARGUMENT);
return false;
}
if (argument.capabilityNamesArgumentNum > 1) {
resultMessage.append(ACCESSIBILITY_ABILITY_DUPLICATE_ARGUMENT);
return false;
}
if (argument.capabilityNames.empty() || argument.capabilityNames[0] == '-') {
resultMessage.append(ACCESSIBILITY_ABILITY_NO_CAPABILITIES_ARGUMENT_VALUE);
return false;
}
return true;
}
bool AccessibilityAbilityShellCommand::CheckParamValidity(
const AccessibilityCommandArgument& argument,
std::vector<Accessibility::AccessibilityAbilityInfo>& installedAbilities,
std::string& resultMessage)
{
const std::string& abilityName = argument.abilityName;
const std::string& bundleName = argument.bundleName;
const std::string& capabilityNames = argument.capabilityNames;
bool isExisted = false;
for (auto& ability : installedAbilities) {
if (ability.GetName() == abilityName && ability.GetPackageName() == bundleName) {
isExisted = true;
const std::string staticCapabilityNames = AccessibilityUtils::GetStaticCapabilityNames(ability);
std::string invalidCapabilityNames = AccessibilityUtils::GetInvalidCapabilityNames(capabilityNames,
staticCapabilityNames);
if (!invalidCapabilityNames.empty()) {
resultMessage.append("the capabilities " + invalidCapabilityNames + ACCESSIBILITY_ABILITY_NOT_FOUND);
return false;
}
}
}
if (!isExisted) {
resultMessage.append("the auxiliary application " +
bundleName + "/" + abilityName + ACCESSIBILITY_ABILITY_NOT_FOUND);
return false;
}
return true;
}
ErrCode AccessibilityAbilityShellCommand::CheckEnableCommandArgument(const AccessibilityCommandArgument& argument,
std::string& resultMessage)
{
ErrCode result = OHOS::ERR_OK;
resultMessage.append(argument.command + ": ");
int32_t totalArgumentNum = argument.bundleArgumentNum + argument.abilityArgumentNum +
argument.capabilityNamesArgumentNum + argument.unknownArgumentNum;
if (totalArgumentNum > ACCESSIBILITY_ENABLE_COMMAND_ARGUMENT_NUM) {
resultReceiver_.append(ACCESSIBILITY_ABILITY_TOO_MANY_ARGUMENT);
if (argument.bundleArgumentNum > 1 || argument.abilityArgumentNum > 1 ||
argument.capabilityNamesArgumentNum > 1) {
resultMessage.append("and exist duplicated arguments");
}
if (argument.unknownArgumentNum > 0) {
resultMessage.append("and exist unknown arguments ");
resultMessage.append(AccessibilityUtils::GetUnknownArgumentsMsg(argument.unknownArguments));
}
return OHOS::ERR_INVALID_VALUE;
}
if (argument.unknownArgumentNum > 0) {
resultMessage.append("unknown arguments ");
resultMessage.append(AccessibilityUtils::GetUnknownArgumentsMsg(argument.unknownArguments));
return OHOS::ERR_INVALID_VALUE;
}
std::vector<Accessibility::AccessibilityAbilityInfo> installedAbilities = GetInstalledAbilities();
if (!CheckAbilityArgument(argument, resultMessage)) {
HILOG_ERROR("abilityName = %{public}s is invalid", argument.abilityName.c_str());
return OHOS::ERR_INVALID_VALUE;
}
if (!CheckBundleArgument(argument, resultMessage)) {
HILOG_ERROR("bundleName = %{public}s is invalid", argument.bundleName.c_str());
return OHOS::ERR_INVALID_VALUE;
}
if (!CheckCapabilitiesArgument(argument, installedAbilities, resultMessage)) {
HILOG_ERROR("capabilityNames = %{public}s is invalid", argument.capabilityNames.c_str());
return OHOS::ERR_INVALID_VALUE;
}
if (!CheckParamValidity(argument, installedAbilities, resultMessage)) {
HILOG_ERROR("%{public}s/%{public}s is not installed",
argument.bundleName.c_str(), argument.abilityName.c_str());
return OHOS::ERR_INVALID_VALUE;
}
std::vector<std::string> enabledAbilities = GetEnabledAbilities();
std::string currentAbility = argument.bundleName + "/" + argument.abilityName;
for (const auto& ability : enabledAbilities) {
if (ability == currentAbility) {
resultMessage.append("the auxiliary application has been enabled.");
return OHOS::ERR_INVALID_VALUE;
}
}
return result;
}
ErrCode AccessibilityAbilityShellCommand::CheckDisableCommandArgument(const AccessibilityCommandArgument& argument,
std::string& resultMessage)
{
ErrCode result = CheckCommandArgument(argument, resultMessage);
if (result == OHOS::ERR_OK) {
std::vector<std::string> enabledAbilities = GetEnabledAbilities();
std::string currentAbility = argument.bundleName + "/" + argument.abilityName;
bool isEnabled = false;
for (const auto& ability : enabledAbilities) {
if (ability == currentAbility) {
isEnabled = true;
break;
}
}
if (!isEnabled) {
resultMessage.append("the auxiliary application was not enabled and could not be disabled.");
return OHOS::ERR_INVALID_VALUE;
}
}
return result;
}
ErrCode AccessibilityAbilityShellCommand::CheckCommandArgument(const AccessibilityCommandArgument& argument,
std::string& resultMessage)
{
resultMessage.append(argument.command + ": ");
int32_t totalArgumentNum = argument.bundleArgumentNum + argument.abilityArgumentNum +
argument.capabilityNamesArgumentNum + argument.unknownArgumentNum;
if (totalArgumentNum > ACCESSIBILITY_DISABLE_COMMAND_ARGUMENT_NUM) {
resultReceiver_.append(ACCESSIBILITY_ABILITY_TOO_MANY_ARGUMENT);
if (argument.bundleArgumentNum > 1 || argument.abilityArgumentNum > 1) {
resultMessage.append("and exist duplicated arguments.");
}
if (argument.unknownArgumentNum > 0) {
resultMessage.append("and exist unknown arguments ");
resultMessage.append(AccessibilityUtils::GetUnknownArgumentsMsg(argument.unknownArguments));
}
return OHOS::ERR_INVALID_VALUE;
}
if (argument.unknownArgumentNum > 0) {
resultMessage.append("unknown arguments ");
resultMessage.append(AccessibilityUtils::GetUnknownArgumentsMsg(argument.unknownArguments));
return OHOS::ERR_INVALID_VALUE;
}
std::vector<Accessibility::AccessibilityAbilityInfo> installedAbilities = GetInstalledAbilities();
if (!CheckAbilityArgument(argument, resultMessage)) {
HILOG_ERROR("abilityName = %{public}s is invalid", argument.abilityName.c_str());
return OHOS::ERR_INVALID_VALUE;
}
if (!CheckBundleArgument(argument, resultMessage)) {
HILOG_ERROR("bundleName = %{public}s is invalid", argument.bundleName.c_str());
return OHOS::ERR_INVALID_VALUE;
}
if (!CheckParamValidity(argument, installedAbilities, resultMessage)) {
HILOG_ERROR("%{public}s/%{public}s is not installed",
argument.bundleName.c_str(), argument.abilityName.c_str());
return OHOS::ERR_INVALID_VALUE;
}
return OHOS::ERR_OK;
}
ErrCode AccessibilityAbilityShellCommand::CheckSetCommandArgument(const AccessibilityCommandArgument& argument,
std::string& resultMessage)
{
resultMessage.append(argument.command + ": ");
int32_t totalArgumentNum = argument.setArgumentNum + argument.unknownArgumentNum;
if (totalArgumentNum > ACCESSIBILITY_SET_COMMAND_ARGUMENT_NUM) {
resultReceiver_.append(ACCESSIBILITY_ABILITY_TOO_MANY_ARGUMENT);
if (argument.setArgumentNum > 1) {
resultMessage.append("and exist duplicated arguments.");
}
if (argument.unknownArgumentNum > 0) {
resultMessage.append("and exist unknown arguments ");
resultMessage.append(AccessibilityUtils::GetUnknownArgumentsMsg(argument.unknownArguments));
}
return OHOS::ERR_INVALID_VALUE;
}
if (argument.unknownArgumentNum > 0) {
resultMessage.append("unknown arguments ");
resultMessage.append(AccessibilityUtils::GetUnknownArgumentsMsg(argument.unknownArguments));
return OHOS::ERR_INVALID_VALUE;
}
if (argument.setArgumentNum == 0) {
resultMessage.append(ACCESSIBILITY_HELP_MSG_NO_OPTION);
return OHOS::ERR_INVALID_VALUE;
}
return OHOS::ERR_OK;
}
ErrCode AccessibilityAbilityShellCommand::RunAsSetScreenMagnificationState()
{
AccessibilityCommandArgument argument;
argument.command = "setScreenMagnificationState";
ErrCode result = MakeSetCommandArgumentFromCmd(argument);
if (result == OHOS::ERR_OK && !AccessibilityUtils::IsValidStateString(argument.value)) {
resultReceiver_.append(ACCESSIBILITY_ABILITY_SET_VALUE_INVALID);
result = OHOS::ERR_INVALID_VALUE;
}
if (result == OHOS::ERR_OK) {
auto& config = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance();
(void)config.InitializeContext();
bool state = std::atoi(argument.value.c_str()) == 1;
Accessibility::RetError ret = config.SetScreenMagnificationState(state);
if (ret == Accessibility::RET_OK) {
resultReceiver_ = ACCESSIBILITY_SET_SCREEN_MAGNIFICATION_STATE_OK + "\n";
} else {
resultReceiver_ = ACCESSIBILITY_SET_SCREEN_MAGNIFICATION_STATE_NG;
resultReceiver_.append(GetMessageFromCode(ret));
}
} else {
resultReceiver_.append("\n");
resultReceiver_.append(ACCESSIBILITY_HELP_MSG_SET_SCREEN_MAGNIFICATION_STATE);
result = OHOS::ERR_INVALID_VALUE;
}
return result;
}
ErrCode AccessibilityAbilityShellCommand::RunAsSetShortKeyState()
{
AccessibilityCommandArgument argument;
argument.command = "setShortKeyState";
ErrCode result = MakeSetCommandArgumentFromCmd(argument);
if (result == OHOS::ERR_OK && !AccessibilityUtils::IsValidStateString(argument.value)) {
resultReceiver_.append(ACCESSIBILITY_ABILITY_SET_VALUE_INVALID);
result = OHOS::ERR_INVALID_VALUE;
}
if (result == OHOS::ERR_OK) {
auto& config = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance();
(void)config.InitializeContext();
bool state = std::atoi(argument.value.c_str()) == 1;
Accessibility::RetError ret = config.SetShortKeyState(state);
if (ret == Accessibility::RET_OK) {
resultReceiver_ = ACCESSIBILITY_SET_SHORT_KEY_STATE_OK + "\n";
} else {
resultReceiver_ = ACCESSIBILITY_SET_SHORT_KEY_STATE_NG;
resultReceiver_.append(GetMessageFromCode(ret));
}
} else {
resultReceiver_.append("\n");
resultReceiver_.append(ACCESSIBILITY_HELP_MSG_SET_SHORT_KEY_STATE);
result = OHOS::ERR_INVALID_VALUE;
}
return result;
}
ErrCode AccessibilityAbilityShellCommand::RunAsSetMouseKeyState()
{
AccessibilityCommandArgument argument;
argument.command = "setMouseKeyState";
ErrCode result = MakeSetCommandArgumentFromCmd(argument);
if (result == OHOS::ERR_OK && !AccessibilityUtils::IsValidStateString(argument.value)) {
resultReceiver_.append(ACCESSIBILITY_ABILITY_SET_VALUE_INVALID);
result = OHOS::ERR_INVALID_VALUE;
}
if (result == OHOS::ERR_OK) {
auto& config = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance();
(void)config.InitializeContext();
bool state = std::atoi(argument.value.c_str()) == 1;
Accessibility::RetError ret = config.SetMouseKeyState(state);
if (ret == Accessibility::RET_OK) {
resultReceiver_ = ACCESSIBILITY_SET_MOUSE_KEY_STATE_OK + "\n";
} else {
resultReceiver_ = ACCESSIBILITY_SET_MOUSE_KEY_STATE_NG;
resultReceiver_.append(GetMessageFromCode(ret));
}
} else {
resultReceiver_.append("\n");
resultReceiver_.append(ACCESSIBILITY_HELP_MSG_SET_MOUSE_KEY_STATE);
result = OHOS::ERR_INVALID_VALUE;
}
return result;
}
ErrCode AccessibilityAbilityShellCommand::RunAsSetCaptionState()
{
AccessibilityCommandArgument argument;
argument.command = "setCaptionState";
ErrCode result = MakeSetCommandArgumentFromCmd(argument);
if (result == OHOS::ERR_OK && !AccessibilityUtils::IsValidStateString(argument.value)) {
resultReceiver_.append(ACCESSIBILITY_ABILITY_SET_VALUE_INVALID);
result = OHOS::ERR_INVALID_VALUE;
}
if (result == OHOS::ERR_OK) {
auto& config = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance();
(void)config.InitializeContext();
bool state = std::atoi(argument.value.c_str()) == 1;
Accessibility::RetError ret = config.SetCaptionsState(state);
if (ret == Accessibility::RET_OK) {
resultReceiver_ = ACCESSIBILITY_SET_CAPTION_STATE_OK + "\n";
} else {
resultReceiver_ = ACCESSIBILITY_SET_CAPTION_STATE_NG;
resultReceiver_.append(GetMessageFromCode(ret));
}
} else {
resultReceiver_.append("\n");
resultReceiver_.append(ACCESSIBILITY_HELP_MSG_SET_CAPTION_STATE);
result = OHOS::ERR_INVALID_VALUE;
}
return result;
}
ErrCode AccessibilityAbilityShellCommand::RunAsSetMouseAutoClick()
{
AccessibilityCommandArgument argument;
argument.command = "setMouseAutoClick";
ErrCode result = MakeSetCommandArgumentFromCmd(argument);
if (result == OHOS::ERR_OK && !AccessibilityUtils::IsValidIntString(argument.value,
MOUSE_AUTO_CLICK_TIME_LOW_BOUND, MOUSE_AUTO_CLICK_TIME_HIGH_BOUND)) {
resultReceiver_.append(ACCESSIBILITY_ABILITY_SET_VALUE_INVALID);
result = OHOS::ERR_INVALID_VALUE;
}
if (result == OHOS::ERR_OK) {
auto& config = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance();
(void)config.InitializeContext();
float time = 1.0 * std::atoi(argument.value.c_str()) / 100;
Accessibility::RetError ret = config.SetMouseAutoClick(time);
if (ret == Accessibility::RET_OK) {
resultReceiver_ = ACCESSIBILITY_SET_AUTO_CLICK_TIME_OK + "\n";
} else {
resultReceiver_ = ACCESSIBILITY_SET_AUTO_CLICK_TIME_NG;
resultReceiver_.append(GetMessageFromCode(ret));
}
} else {
resultReceiver_.append("\n");
resultReceiver_.append(ACCESSIBILITY_HELP_MSG_SET_AUTO_CLICK_TIME);
result = OHOS::ERR_INVALID_VALUE;
}
return result;
}
ErrCode AccessibilityAbilityShellCommand::RunAsSetShortKeyTarget()
{
AccessibilityCommandArgument argument;
ErrCode result = MakeSetShortKeyTargetCommandArgumentFromCmd(argument);
if (result == OHOS::ERR_OK) {
auto& config = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance();
(void)config.InitializeContext();
std::string name = argument.bundleName + "/" + argument.abilityName;
Accessibility::RetError ret = config.SetShortkeyTarget(name);
if (ret == Accessibility::RET_OK) {
resultReceiver_ = ACCESSIBILITY_SET_SHORT_KEY_TARGET_OK + "\n";
} else {
resultReceiver_ = ACCESSIBILITY_SET_SHORT_KEY_TARGET_NG;
resultReceiver_.append(GetMessageFromCode(ret));
}
} else {
resultReceiver_.append("\n");
resultReceiver_.append(ACCESSIBILITY_HELP_MSG_SET_SHORT_KEY_TARGET);
result = OHOS::ERR_INVALID_VALUE;
}
return result;
}
ErrCode AccessibilityAbilityShellCommand::RunAsSetHighContrastTextState()
{
AccessibilityCommandArgument argument;
argument.command = "setHighContrastTextState";
ErrCode result = MakeSetCommandArgumentFromCmd(argument);
if (result == OHOS::ERR_OK && !AccessibilityUtils::IsValidStateString(argument.value)) {
resultReceiver_.append(ACCESSIBILITY_ABILITY_SET_VALUE_INVALID);
result = OHOS::ERR_INVALID_VALUE;
}
if (result == OHOS::ERR_OK) {
auto& config = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance();
(void)config.InitializeContext();
bool state = std::atoi(argument.value.c_str()) == 1;
Accessibility::RetError ret = config.SetHighContrastTextState(state);
if (ret == Accessibility::RET_OK) {
resultReceiver_ = ACCESSIBILITY_SET_HIGH_CONTRAST_TEXT_STATE_OK + "\n";
} else {
resultReceiver_ = ACCESSIBILITY_SET_HIGH_CONTRAST_TEXT_STATE_NG;
resultReceiver_.append(GetMessageFromCode(ret));
}
} else {
resultReceiver_.append("\n");
resultReceiver_.append(ACCESSIBILITY_HELP_MSG_HIGH_CONTRAST_TEXT_STATE);
result = OHOS::ERR_INVALID_VALUE;
}
return result;
}
ErrCode AccessibilityAbilityShellCommand::RunAsSetInvertColorState()
{
AccessibilityCommandArgument argument;
argument.command = "setInvertColorState";
ErrCode result = MakeSetCommandArgumentFromCmd(argument);
if (result == OHOS::ERR_OK && !AccessibilityUtils::IsValidStateString(argument.value)) {
resultReceiver_.append(ACCESSIBILITY_ABILITY_SET_VALUE_INVALID);
result = OHOS::ERR_INVALID_VALUE;
}
if (result == OHOS::ERR_OK) {
auto& config = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance();
(void)config.InitializeContext();
bool state = std::atoi(argument.value.c_str()) == 1;
Accessibility::RetError ret = config.SetInvertColorState(state);
if (ret == Accessibility::RET_OK) {
resultReceiver_ = ACCESSIBILITY_SET_INVERT_COLOR_STATE_OK + "\n";
} else {
resultReceiver_ = ACCESSIBILITY_SET_INVERT_COLOR_STATE_NG;
resultReceiver_.append(GetMessageFromCode(ret));
}
} else {
resultReceiver_.append("\n");
resultReceiver_.append(ACCESSIBILITY_HELP_MSG_SET_INVERT_COLOR_STATE);
result = OHOS::ERR_INVALID_VALUE;
}
return result;
}
ErrCode AccessibilityAbilityShellCommand::RunAsSetDaltonizationColorFilter()
{
AccessibilityCommandArgument argument;
argument.command = "setDaltonizationColorFilter";
ErrCode result = MakeSetCommandArgumentFromCmd(argument);
if (result == OHOS::ERR_OK && !AccessibilityUtils::IsValidIntString(argument.value,
DALTIONIZATION_TYPE_LOW_BOUND, DALTIONIZATION_TYPE_HIGH_BOUND)) {
resultReceiver_.append(ACCESSIBILITY_ABILITY_SET_VALUE_INVALID);
return OHOS::ERR_INVALID_VALUE;
}
if (result == OHOS::ERR_OK) {
auto& config = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance();
(void)config.InitializeContext();
int32_t value = std::atoi(argument.value.c_str());
AccessibilityConfig::DALTONIZATION_TYPE type = AccessibilityConfig::DALTONIZATION_TYPE::Normal;
switch (value) {
case TYPE_NORMAL: {
type = AccessibilityConfig::DALTONIZATION_TYPE::Normal;
break;
}
case TYPE_PROTANOMALY: {
type = AccessibilityConfig::DALTONIZATION_TYPE::Protanomaly;
break;
}
case TYPE_DEUTERANOMALY: {
type = AccessibilityConfig::DALTONIZATION_TYPE::Deuteranomaly;
break;
}
case TYPE_TRITANOMALY: {
type = AccessibilityConfig::DALTONIZATION_TYPE::Tritanomaly;
break;
}
default: {
break;
}
}
Accessibility::RetError ret = config.SetDaltonizationColorFilter(type);
if (ret == Accessibility::RET_OK) {
resultReceiver_ = ACCESSIBILITY_SET_DALTONIZATIONZATION_COLOR_FILTER_OK + "\n";
} else {
resultReceiver_ = ACCESSIBILITY_SET_DALTONIZATIONZATION_COLOR_FILTER_NG;
resultReceiver_.append(GetMessageFromCode(ret));
}
} else {
resultReceiver_.append("\n");
resultReceiver_.append(ACCESSIBILITY_HELP_MSG_SET_DALTONIZATION_COLOR_FILTER);
result = OHOS::ERR_INVALID_VALUE;
}
return result;
}
ErrCode AccessibilityAbilityShellCommand::RunAsSetContentTimeout()
{
AccessibilityCommandArgument argument;
argument.command = "setContentTimeout";
ErrCode result = MakeSetCommandArgumentFromCmd(argument);
if (result == OHOS::ERR_OK && !AccessibilityUtils::IsValidIntString(argument.value,
CONTENT_TIME_OUT_TIME_LOW_BOUND, CONTENT_TIME_OUT_TIME_HIGH_BOUND)) {
resultReceiver_.append(ACCESSIBILITY_ABILITY_SET_VALUE_INVALID);
result = OHOS::ERR_INVALID_VALUE;
}
if (result == OHOS::ERR_OK) {
auto& config = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance();
(void)config.InitializeContext();
int32_t time = std::atoi(argument.value.c_str());
Accessibility::RetError ret = config.SetContentTimeout(time);
if (ret == Accessibility::RET_OK) {
resultReceiver_ = ACCESSIBILITY_SET_CONTENT_TIME_OK + "\n";
} else {
resultReceiver_ = ACCESSIBILITY_SET_CONTENT_TIME_NG;
resultReceiver_.append(GetMessageFromCode(ret));
}
} else {
resultReceiver_.append("\n");
resultReceiver_.append(ACCESSIBILITY_HELP_MSG_SET_CONTENT_TIME_OUT);
result = OHOS::ERR_INVALID_VALUE;
}
return result;
}
ErrCode AccessibilityAbilityShellCommand::RunAsSetAnimationOffState()
{
AccessibilityCommandArgument argument;
argument.command = "setAnimationOffState";
ErrCode result = MakeSetCommandArgumentFromCmd(argument);
if (result == OHOS::ERR_OK && !AccessibilityUtils::IsValidStateString(argument.value)) {
resultReceiver_.append(ACCESSIBILITY_ABILITY_SET_VALUE_INVALID);
result = OHOS::ERR_INVALID_VALUE;
}
if (result == OHOS::ERR_OK) {
auto& config = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance();
(void)config.InitializeContext();
bool state = std::atoi(argument.value.c_str()) == 1;
Accessibility::RetError ret = config.SetAnimationOffState(state);
if (ret == Accessibility::RET_OK) {
resultReceiver_ = ACCESSIBILITY_SET_ANIMATION_OFF_STATE_OK + "\n";
} else {
resultReceiver_ = ACCESSIBILITY_SET_ANIMATION_OFF_STATE_NG;
resultReceiver_.append(GetMessageFromCode(ret));
}
} else {
resultReceiver_.append("\n");
resultReceiver_.append(ACCESSIBILITY_HELP_MSG_ANIMATION_OFF_STATE);
result = OHOS::ERR_INVALID_VALUE;
}
return result;
}
ErrCode AccessibilityAbilityShellCommand::RunAsSetBrightnessDiscount()
{
AccessibilityCommandArgument argument;
argument.command = "setSetBrightnessDiscount";
ErrCode result = MakeSetCommandArgumentFromCmd(argument);
if (result == OHOS::ERR_OK && !AccessibilityUtils::IsValidIntString(argument.value,
BRIGHTNESS_DISCOUNT_LOW_BOUND, BRIGHTNESS_DISCOUNT_HIGH_BOUND)) {
resultReceiver_.append(ACCESSIBILITY_ABILITY_SET_VALUE_INVALID);
result = OHOS::ERR_INVALID_VALUE;
}
if (result == OHOS::ERR_OK) {
auto& config = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance();
(void)config.InitializeContext();
float discount = 1.0 * std::atoi(argument.value.c_str()) / 100;
Accessibility::RetError ret = config.SetBrightnessDiscount(discount);
if (ret == Accessibility::RET_OK) {
resultReceiver_ = ACCESSIBILITY_SET_BRIGHTNESS_DISCOUNT_OK + "\n";
} else {
resultReceiver_ = ACCESSIBILITY_SET_BRIGHTNESS_DISCOUNT_NG;
resultReceiver_.append(GetMessageFromCode(ret));
}
} else {
resultReceiver_.append("\n");
resultReceiver_.append(ACCESSIBILITY_HELP_MSG_SET_BRIGHTNESS_DISCOUNT);
result = OHOS::ERR_INVALID_VALUE;
}
return result;
}
ErrCode AccessibilityAbilityShellCommand::RunAsSetAudioMonoState()
{
AccessibilityCommandArgument argument;
argument.command = "setAudioMonoState";
ErrCode result = MakeSetCommandArgumentFromCmd(argument);
if (result == OHOS::ERR_OK && !AccessibilityUtils::IsValidStateString(argument.value)) {
resultReceiver_.append(ACCESSIBILITY_ABILITY_SET_VALUE_INVALID);
result = OHOS::ERR_INVALID_VALUE;
}
if (result == OHOS::ERR_OK) {
auto& config = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance();
(void)config.InitializeContext();
bool state = std::atoi(argument.value.c_str()) == 1;
Accessibility::RetError ret = config.SetAudioMonoState(state);
if (ret == Accessibility::RET_OK) {
resultReceiver_ = ACCESSIBILITY_SET_AUDIO_MONO_STATE_OK + "\n";
} else {
resultReceiver_ = ACCESSIBILITY_SET_AUDIO_MONO_STATE_NG;
resultReceiver_.append(GetMessageFromCode(ret));
}
} else {
resultReceiver_.append("\n");
resultReceiver_.append(ACCESSIBILITY_HELP_MSG_SET_AUDIO_MONO_STATE);
result = OHOS::ERR_INVALID_VALUE;
}
return result;
}
ErrCode AccessibilityAbilityShellCommand::RunAsSetAudioBalance()
{
AccessibilityCommandArgument argument;
argument.command = "setAudioBalance";
ErrCode result = MakeSetCommandArgumentFromCmd(argument);
if (result == OHOS::ERR_OK && !AccessibilityUtils::IsValidIntString(argument.value,
AUDIO_BALANCE_LOW_BOUND, AUDIO_BALANCE_HIGH_BOUND)) {
resultReceiver_.append(ACCESSIBILITY_ABILITY_SET_VALUE_INVALID);
result = OHOS::ERR_INVALID_VALUE;
}
if (result == OHOS::ERR_OK) {
auto& config = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance();
(void)config.InitializeContext();
float balance = 1.0 * std::atoi(argument.value.c_str()) / 100;
Accessibility::RetError ret = config.SetAudioBalance(balance);
if (ret == Accessibility::RET_OK) {
resultReceiver_ = ACCESSIBILITY_SET_AUDIO_BALANCE_OK + "\n";
} else {
resultReceiver_ = ACCESSIBILITY_SET_AUDIO_BALANCE_NG;
resultReceiver_.append(GetMessageFromCode(ret));
}
} else {
resultReceiver_.append("\n");
resultReceiver_.append(ACCESSIBILITY_HELP_MSG_SET_AUDIO_BALANCE);
result = OHOS::ERR_INVALID_VALUE;
}
return result;
}
ErrCode AccessibilityAbilityShellCommand::MakeSetShortKeyTargetCommandArgumentFromCmd(
AccessibilityCommandArgument& argument)
{
argument.command = "setShortkeyTarget";
ErrCode result = MakeCommandArgumentFromCmd(argument);
if (result == OHOS::ERR_OK) {
return CheckCommandArgument(argument, resultReceiver_);
}
return result;
}
ErrCode AccessibilityAbilityShellCommand::MakeCommandArgumentFromCmd(AccessibilityCommandArgument& argument)
{
int option = -1;
int counter = 0;
while (true) {
counter++;
option = getopt_long(argc_, argv_, DISABLE_SHORT_OPTIONS.c_str(), DISABLE_LONG_OPTIONS, nullptr);
HILOG_INFO("option: %{public}d, optopt: %{public}d, optind: %{public}d", option, optopt, optind);
if (optind < 0 || optind > argc_) {
return OHOS::ERR_INVALID_VALUE;
}
if (option == -1) {
if (counter == 1 && strcmp(argv_[optind], cmd_.c_str()) == 0) {
resultReceiver_.append(argument.command + ": " + ACCESSIBILITY_HELP_MSG_NO_OPTION);
return OHOS::ERR_INVALID_VALUE;
}
break;
}
if (option == '?') {
option = optopt;
switch (option) {
case 'a': {
resultReceiver_.append(argument.command + ": " + ACCESSIBILITY_ABILITY_NO_ABILITY_ARGUMENT_VALUE);
return OHOS::ERR_INVALID_VALUE;
}
case 'b': {
resultReceiver_.append(argument.command + ": " + ACCESSIBILITY_ABILITY_NO_BUNDLE_ARGUMENT_VALUE);
return OHOS::ERR_INVALID_VALUE;
}
default: {
break;
}
}
}
switch (option) {
case 'a': {
argument.abilityName = optarg;
argument.abilityArgumentNum++;
break;
}
case 'b': {
argument.bundleName = optarg;
argument.bundleArgumentNum++;
break;
}
default: {
argument.unknownArgumentNum++;
argument.unknownArguments.push_back(argv_[optind - 1]);
break;
}
}
}
return OHOS::ERR_OK;
}
ErrCode AccessibilityAbilityShellCommand::MakeSetCommandArgumentFromCmd(AccessibilityCommandArgument& argument)
{
int option = -1;
int counter = 0;
while (true) {
counter++;
option = getopt_long(argc_, argv_, SET_SHORT_OPTIONS.c_str(), SET_LONG_OPTIONS, nullptr);
HILOG_INFO("option: %{public}d, optopt: %{public}d, optind: %{public}d", option, optopt, optind);
if (optind < 0 || optind > argc_) {
return OHOS::ERR_INVALID_VALUE;
}
if (option == -1) {
if (counter == 1 && strcmp(argv_[optind], cmd_.c_str()) == 0) {
resultReceiver_.append(argument.command + ": " + ACCESSIBILITY_HELP_MSG_NO_OPTION);
return OHOS::ERR_INVALID_VALUE;
}
break;
}
if (option == '?') {
option = optopt;
switch (option) {
case 'v': {
resultReceiver_.append(argument.command + ": " + ACCESSIBILITY_ABILITY_NO_SET_ARGUMENT_VALUE);
return OHOS::ERR_INVALID_VALUE;
}
default: {
break;
}
}
}
switch (option) {
case 'v': {
argument.value = optarg;
argument.setArgumentNum++;
break;
}
default: {
argument.unknownArgumentNum++;
argument.unknownArguments.push_back(argv_[optind - 1]);
break;
}
}
}
return CheckSetCommandArgument(argument, resultReceiver_);
}
} // namespace AAFwk
} // namespace OHOS