| /* | |
| * Copyright (C) 2012 The Android Open Source Project | |
| * | |
| * 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. | |
| */ | |
| package com.motorolamobility.preflighting.core.validation; | |
| import java.io.File; | |
| import java.io.IOException; | |
| import java.util.HashSet; | |
| import java.util.List; | |
| import java.util.Map; | |
| import java.util.Set; | |
| import com.motorolamobility.preflighting.core.checker.CheckerExtension; | |
| import com.motorolamobility.preflighting.core.checker.condition.ICondition; | |
| import com.motorolamobility.preflighting.core.devicespecification.DeviceSpecification; | |
| import com.motorolamobility.preflighting.core.exception.PreflightingExtensionPointException; | |
| import com.motorolamobility.preflighting.core.i18n.PreflightingCoreNLS; | |
| import com.motorolamobility.preflighting.core.sdk.SdkUtils; | |
| import com.motorolamobility.preflighting.core.utils.LimitedList; | |
| import com.motorolamobility.preflighting.core.validation.ValidationManager.InputParameter; | |
| import com.motorolamobility.preflighting.core.validation.ValidationManager.WarningLevelAdjustmentType; | |
| import com.motorolamobility.preflighting.core.validation.ValidationResultData.SEVERITY; | |
| import com.motorolamobility.preflighting.core.verbose.DebugVerboseOutputter; | |
| import com.motorolamobility.preflighting.core.verbose.DebugVerboseOutputter.VerboseLevel; | |
| /** | |
| * Utility class (static) which validates global parameters passed to App Validator. | |
| */ | |
| public final class GlobalInputParamsValidator | |
| { | |
| /** | |
| * Constant for the variable that holds the system path. | |
| */ | |
| public static final String PATH_ENVIRONMENT_VARIABLE = "path"; //$NON-NLS-1$ | |
| private static final String WARNING_LEVEL_ADJUSTMENT_CHECKER_SEPARATOR = " "; //$NON-NLS-1$ | |
| private static final String WARNING_LEVEL_ADJUSTMENT_CHECKER_MESSAGE_SEPARATOR = ", "; //$NON-NLS-1$ | |
| /** | |
| * Validates all global parameters passed to the application. | |
| * Returns the ValidationResult object containing only ValidationResultData | |
| * corresponding to errors on given parameters. | |
| * | |
| * @param params the global parameters passed to App Validator. | |
| * @param adjustedWarningLevelInfo The object to hold information about warning level configuration. | |
| * @return ValidationResult object containing the validation errors, if any. | |
| */ | |
| public static ValidationResult validateGlobalParams(List<Parameter> params, | |
| Map<WarningLevelAdjustmentType, Set<String>> adjustedWarningLevelInfo, | |
| List<DeviceSpecification> deviceSpecifications, ValidationManager validationManager) | |
| { | |
| ValidationResult globalResult = new ValidationResult(null, LimitedList.UNLIMITED); | |
| ValidationResultData resultData = null; | |
| boolean sdkParamFound = false; | |
| boolean appPathParamFound = false; | |
| for (Parameter param : params) | |
| { | |
| resultData = new ValidationResultData(); | |
| String inputParam = param.getParameterType(); | |
| String inputParamValue = param.getValue(); | |
| if (InputParameter.SDK_PATH.getAlias().equals(inputParam)) | |
| { | |
| validateSdkParam(resultData, inputParamValue); | |
| sdkParamFound = true; | |
| // say that sdk path passed as parameter is being used | |
| DebugVerboseOutputter | |
| .printVerboseMessage( | |
| PreflightingCoreNLS.GlobalInputParamsValidator_VerboseMessage_UsingParamSDKPath, | |
| VerboseLevel.v1); | |
| } | |
| else if (InputParameter.APPLICATION_PATH.getAlias().equals(inputParam)) | |
| { | |
| validateApplicationPathParam(resultData, inputParamValue); | |
| appPathParamFound = true; | |
| } | |
| else if (InputParameter.DEVICE_DESCRIPTION.getAlias().equals(inputParam)) | |
| { | |
| validateDescribeDeviceParam(resultData, inputParamValue, deviceSpecifications); | |
| } | |
| else if (InputParameter.WARNING_TO_ERROR.getAlias().equals(inputParam) | |
| || (InputParameter.ERROR_TO_WARNING.getAlias().equals(inputParam))) | |
| { | |
| validateWarningAdjustmentParameter(resultData, inputParamValue, inputParam, | |
| adjustedWarningLevelInfo, validationManager); | |
| } | |
| else if (InputParameter.LIMIT.getAlias().equals(inputParam)) | |
| { | |
| validateLimitParam(resultData, inputParamValue); | |
| } | |
| else | |
| { | |
| // unknown parameter passed | |
| resultData.setSeverity(SEVERITY.ERROR); | |
| resultData | |
| .setIssueDescription(PreflightingCoreNLS.GlobalInputParamsValidator_UnknownParameterMessage | |
| + param.getParameterType()); | |
| } | |
| if (!resultData.getSeverity().equals(SEVERITY.OK)) | |
| { | |
| globalResult.addValidationResult(resultData); | |
| } | |
| } | |
| resultData = new ValidationResultData(); | |
| if (!appPathParamFound) | |
| { | |
| resultData.setSeverity(SEVERITY.ERROR); | |
| resultData | |
| .setIssueDescription(PreflightingCoreNLS.GlobalInputParamsValidator_AppPathParameterMissing); | |
| globalResult.addValidationResult(resultData); | |
| } | |
| else if (!sdkParamFound) | |
| { | |
| DebugVerboseOutputter | |
| .printVerboseMessage( | |
| PreflightingCoreNLS.GlobalInputParamsValidator_VerboseMessage_CheckingSystemPathForSDK, | |
| VerboseLevel.v2); | |
| boolean aaptFound = true; | |
| String[] aaptCommand = new String[] | |
| { | |
| "aapt", "help" //$NON-NLS-1$ //$NON-NLS-2$ | |
| }; | |
| // test AAPT command | |
| try | |
| { | |
| Runtime.getRuntime().exec(aaptCommand); | |
| } | |
| catch (IOException ioException) | |
| { | |
| //aapt not found | |
| aaptFound = false; | |
| DebugVerboseOutputter | |
| .printVerboseMessage( | |
| PreflightingCoreNLS.GlobalInputParamsValidator_VerboseMessage_SDKPathNotFoundOnSystemPath, | |
| VerboseLevel.v2); | |
| } | |
| if (!aaptFound) | |
| { | |
| resultData.setSeverity(SEVERITY.ERROR); | |
| resultData | |
| .setIssueDescription(PreflightingCoreNLS.GlobalInputParamsValidator_SdkPathParameterMissing); | |
| } | |
| else | |
| { | |
| params.add(new Parameter(ValidationManager.InputParameter.SDK_PATH.getAlias(), | |
| "aapt")); //$NON-NLS-1$ | |
| // say that system sdk path is being used | |
| DebugVerboseOutputter | |
| .printVerboseMessage( | |
| PreflightingCoreNLS.GlobalInputParamsValidator_VerboseMessage_UsingSystemSDKPath, | |
| VerboseLevel.v1); | |
| } | |
| if ((resultData.getSeverity() != null) && !resultData.getSeverity().equals(SEVERITY.OK)) | |
| { | |
| globalResult.addValidationResult(resultData); | |
| } | |
| } | |
| return globalResult; | |
| } | |
| private static void validateApplicationPathParam(ValidationResultData resultData, | |
| String inputParamValue) | |
| { | |
| File appPath = new File(inputParamValue); | |
| if (!appPath.exists()) | |
| { | |
| resultData.setSeverity(SEVERITY.ERROR); | |
| resultData | |
| .setIssueDescription(PreflightingCoreNLS.GlobalInputParamsValidator_NonExistentApplicationPathMessage | |
| + inputParamValue); | |
| } | |
| else | |
| { | |
| resultData.setSeverity(SEVERITY.OK); | |
| } | |
| } | |
| private static void validateLimitParam(ValidationResultData resultData, String paramValue) | |
| { | |
| resultData.setSeverity(SEVERITY.OK); | |
| if (paramValue != null) | |
| { | |
| try | |
| { | |
| int limit = Integer.parseInt(paramValue); | |
| if (limit >= 0) | |
| { | |
| return; | |
| } | |
| } | |
| catch (NumberFormatException nfe) | |
| { | |
| resultData.setSeverity(SEVERITY.ERROR); | |
| resultData.setIssueDescription(PreflightingCoreNLS.bind( | |
| PreflightingCoreNLS.GlobalInputParamsValidator_LimitParam, paramValue)); | |
| } | |
| } | |
| resultData.setSeverity(SEVERITY.ERROR); | |
| resultData.setIssueDescription(PreflightingCoreNLS.bind( | |
| PreflightingCoreNLS.GlobalInputParamsValidator_LimitParam, paramValue)); | |
| } | |
| /** | |
| * Validates if SDK parameter is valid (if SDK folder exists, is a directory and have the binaries required to run App Validator). | |
| * @param resultData result that is filled if there is any problem with SDK parameter. | |
| * @param inputParamValue the global input value passed to run App Validator. | |
| */ | |
| public static void validateSdkParam(ValidationResultData resultData, String inputParamValue) | |
| { | |
| File sdkFolder = new File(inputParamValue); | |
| if (!sdkFolder.exists()) | |
| { | |
| resultData.setSeverity(SEVERITY.ERROR); | |
| resultData | |
| .setIssueDescription(PreflightingCoreNLS.GlobalInputParamsValidator_NonExistentSdkPathMessage | |
| + inputParamValue); | |
| } | |
| else if (!sdkFolder.isDirectory()) | |
| { | |
| resultData.setSeverity(SEVERITY.ERROR); | |
| resultData | |
| .setIssueDescription(PreflightingCoreNLS.GlobalInputParamsValidator_SdkPathNotFolderMessage | |
| + inputParamValue); | |
| } | |
| // check if a particular tool is inside the folder (in this case, aapt), and | |
| // if it isn't, assume it is not a valid sdk folder | |
| else if (SdkUtils.getLatestAAPTToolPath(inputParamValue) == null) | |
| { | |
| resultData.setSeverity(SEVERITY.ERROR); | |
| resultData | |
| .setIssueDescription(PreflightingCoreNLS.GlobalInputParamsValidator_SdkPathNotValidSdkMessage | |
| + inputParamValue); | |
| } | |
| else | |
| { | |
| resultData.setSeverity(SEVERITY.OK); | |
| } | |
| } | |
| private static boolean validateDescribeDeviceParam(ValidationResultData resultData, | |
| String describeDeviceParamValue, List<DeviceSpecification> deviceSpecifications) | |
| { | |
| boolean deviceIdfound = false; | |
| if (deviceSpecifications != null) | |
| { | |
| for (DeviceSpecification spec : deviceSpecifications) | |
| { | |
| if ((spec.getId() != null) && spec.getId().equals(describeDeviceParamValue)) | |
| { | |
| deviceIdfound = true; | |
| break; | |
| } | |
| } | |
| } | |
| return deviceIdfound; | |
| } | |
| private static void validateWarningAdjustmentParameter(ValidationResultData resultData, | |
| String inputParamValue, String inputParam, | |
| Map<WarningLevelAdjustmentType, Set<String>> adjustedWarningLevelInfo, | |
| ValidationManager validationManager) | |
| { | |
| DebugVerboseOutputter | |
| .printVerboseMessage( | |
| PreflightingCoreNLS.GlobalInputParamsValidator_WarningLevelAdjustmentParameterFoundMessage, | |
| VerboseLevel.v1); | |
| WarningLevelAdjustmentType adjustmentType; | |
| if (InputParameter.WARNING_TO_ERROR.getAlias().equals(inputParam)) | |
| { | |
| adjustmentType = WarningLevelAdjustmentType.INCREASE; | |
| } | |
| else | |
| { | |
| adjustmentType = WarningLevelAdjustmentType.DECREASE; | |
| } | |
| // trim parameter value for guaranteeing there is something on it other than white spaces | |
| if (inputParamValue != null) | |
| { | |
| inputParamValue = inputParamValue.trim(); | |
| } | |
| Set<String> checkerIdsToAdjust = adjustedWarningLevelInfo.get(adjustmentType); | |
| // if the parameter was not previously passed, create the list of checkers for it | |
| if (checkerIdsToAdjust == null) | |
| { | |
| checkerIdsToAdjust = new HashSet<String>(); | |
| adjustedWarningLevelInfo.put(adjustmentType, checkerIdsToAdjust); | |
| } | |
| // if the parameter was previously passed, this is not allowed (return immediately to avoid complicated code) | |
| else | |
| { | |
| resultData.setSeverity(SEVERITY.ERROR); | |
| resultData.setIssueDescription(PreflightingCoreNLS.bind( | |
| PreflightingCoreNLS.GlobalInputParamsValidator_RepeatedParameterErrorMessage, | |
| inputParam)); | |
| return; | |
| } | |
| // no checker id passed; all checkers will have their warning levels adjusted; | |
| // validation result is ok | |
| if ((inputParamValue == null) || (inputParamValue.length() == 0)) | |
| { | |
| DebugVerboseOutputter | |
| .printVerboseMessage( | |
| PreflightingCoreNLS.GlobalInputParamsValidator_WarningLevelAdjustmentAllCheckers, | |
| VerboseLevel.v1); | |
| resultData.setSeverity(SEVERITY.OK); | |
| } | |
| else | |
| { | |
| // retrieve passed checker ids, validate they exist, and add | |
| // them to a list of checker ids to be adjusted for warning level | |
| String[] completeIds = | |
| inputParamValue.split(WARNING_LEVEL_ADJUSTMENT_CHECKER_SEPARATOR); | |
| Map<String, CheckerExtension> knownCheckers = null; | |
| StringBuilder unknownCheckerIdsMessage = new StringBuilder(); | |
| StringBuilder knownCheckerIdsMessage = new StringBuilder(); | |
| boolean unknownCheckerFound = false; | |
| try | |
| { | |
| knownCheckers = ValidationManager.loadCheckers(); | |
| } | |
| catch (PreflightingExtensionPointException e) | |
| { | |
| // do nothing; the list of checkers will fail to be validated | |
| // and a correct message with unknown checkers will be used | |
| } | |
| for (String completeId : completeIds) | |
| { | |
| completeId = completeId.trim(); | |
| if (completeId.length() > 0) | |
| { | |
| //Grab the conditionID if exists, so we can verify it later. | |
| String[] checkerCondition = completeId.split("\\."); | |
| String checkerId = null; | |
| String conditionId = null; | |
| switch (checkerCondition.length) | |
| { | |
| case 0: | |
| //Do nothing, checkerId is already correct | |
| break; | |
| case 1: | |
| checkerId = checkerCondition[0]; | |
| break; | |
| case 2: | |
| checkerId = checkerCondition[0]; | |
| conditionId = checkerCondition[1]; | |
| break; | |
| default: | |
| unknownCheckerIdsMessage.append(completeId | |
| + WARNING_LEVEL_ADJUSTMENT_CHECKER_MESSAGE_SEPARATOR); | |
| unknownCheckerFound = true; | |
| } | |
| //Verify if checker is valid | |
| if ((knownCheckers == null) || !knownCheckers.containsKey(checkerId)) | |
| { | |
| unknownCheckerIdsMessage.append(completeId | |
| + WARNING_LEVEL_ADJUSTMENT_CHECKER_MESSAGE_SEPARATOR); | |
| unknownCheckerFound = true; | |
| } | |
| else | |
| { | |
| //Checker is valid now verify if the condition is valid | |
| boolean conditionValid = true; | |
| if (conditionId != null) | |
| { | |
| Map<String, ICondition> checkerConditions = | |
| knownCheckers.get(checkerId).getChecker().getConditions(); | |
| if (checkerConditions != null) | |
| { | |
| conditionValid = checkerConditions.containsKey(conditionId); | |
| } | |
| else | |
| { | |
| conditionValid = false; | |
| } | |
| } | |
| if (conditionValid) | |
| { | |
| checkerIdsToAdjust.add(completeId); | |
| knownCheckerIdsMessage.append(completeId | |
| + WARNING_LEVEL_ADJUSTMENT_CHECKER_MESSAGE_SEPARATOR); | |
| } | |
| else | |
| { | |
| unknownCheckerIdsMessage.append(completeId | |
| + WARNING_LEVEL_ADJUSTMENT_CHECKER_MESSAGE_SEPARATOR); | |
| unknownCheckerFound = true; | |
| } | |
| } | |
| } | |
| } | |
| if (unknownCheckerFound) | |
| { | |
| // remove last comma added | |
| unknownCheckerIdsMessage.delete(unknownCheckerIdsMessage | |
| .lastIndexOf(WARNING_LEVEL_ADJUSTMENT_CHECKER_MESSAGE_SEPARATOR), | |
| unknownCheckerIdsMessage.length()); | |
| String unknownCheckerIdsMessageStr = unknownCheckerIdsMessage.toString(); | |
| resultData.setSeverity(SEVERITY.ERROR); | |
| resultData | |
| .setIssueDescription(PreflightingCoreNLS | |
| .bind(PreflightingCoreNLS.GlobalInputParamsValidator_UnknownCheckersForWarningLevelAdjustmentMessage, | |
| unknownCheckerIdsMessageStr)); | |
| } | |
| else | |
| { | |
| // remove last comma added | |
| knownCheckerIdsMessage.delete(knownCheckerIdsMessage | |
| .lastIndexOf(WARNING_LEVEL_ADJUSTMENT_CHECKER_MESSAGE_SEPARATOR), | |
| knownCheckerIdsMessage.length()); | |
| String knownCheckerIdsMessageStr = knownCheckerIdsMessage.toString(); | |
| DebugVerboseOutputter | |
| .printVerboseMessage( | |
| PreflightingCoreNLS | |
| .bind(PreflightingCoreNLS.GlobalInputParamsValidator_WarningLevelAdjustmentFollowingCheckers, | |
| knownCheckerIdsMessageStr), VerboseLevel.v1); | |
| resultData.setSeverity(SEVERITY.OK); | |
| } | |
| } | |
| } | |
| } |