/*
* 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.internal.commandinput;
import java.io.PrintStream;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import org.eclipse.osgi.util.NLS;
import com.motorolamobility.preflighting.core.checker.CheckerDescription;
import com.motorolamobility.preflighting.core.checker.CheckerExtension;
import com.motorolamobility.preflighting.core.exception.PreflightingToolException;
import com.motorolamobility.preflighting.core.validation.GlobalInputParamsValidator;
import com.motorolamobility.preflighting.core.validation.Parameter;
import com.motorolamobility.preflighting.core.validation.ParameterDescription;
import com.motorolamobility.preflighting.core.validation.ParameterType;
import com.motorolamobility.preflighting.core.validation.ValidationManager;
import com.motorolamobility.preflighting.core.validation.ValidationManager.InputParameter;
import com.motorolamobility.preflighting.core.validation.ValidationResultData;
import com.motorolamobility.preflighting.core.validation.ValidationResultData.SEVERITY;
import com.motorolamobility.preflighting.core.validation.Value;
import com.motorolamobility.preflighting.core.verbose.DebugVerboseOutputter;
import com.motorolamobility.preflighting.core.verbose.DebugVerboseOutputter.VerboseLevel;
import com.motorolamobility.preflighting.core.verbose.WarningLevelFilter;
import com.motorolamobility.preflighting.core.verbose.WarningLevelFilter.WarningLevel;
import com.motorolamobility.preflighting.i18n.PreflightingNLS;
import com.motorolamobility.preflighting.internal.commandinput.exception.ParameterParseException;
import com.motorolamobility.preflighting.internal.commandoutput.OutputterFactory;
import com.motorolamobility.preflighting.internal.daemon.Daemon;
import com.motorolamobility.preflighting.internal.help.printer.HelpPrinter;
public class ApplicationParameterInterpreter
{
public static final String PARAMETER_WARNING = "wN"; //$NON-NLS-1$
public static final String WARNING_FLAG = PARAMETER_WARNING.substring(0, 1);
public static final String PARAM_VERBOSITY = "vN"; //$NON-NLS-1$
public static final String VERBOSITY_FLAG = PARAM_VERBOSITY.substring(0, 1);
/**
* Theses parameters are defined by Application. Application interprets
* these parameters.
*/
public static final String PARAM_HELP = "help"; //$NON-NLS-1$
public static final String PARAM_LIST_CHECKERS = "list-checkers"; //$NON-NLS-1$
public static final String PARAM_LIST_DEVICES = "list-devices"; //$NON-NLS-1$
// Hidden parameter. For internal use only.
public static final String KEEP_TEMP_FILES = "keepTempFiles"; //$NON-NLS-1$
public static final String PARAM_DESC_DEVICE = "describe-device"; //$NON-NLS-1$
public static final String PARAM_DAEMON = "daemon"; //$NON-NLS-1$
private static final String PARAM_DEBUG = "showDebugMessages";
/**
* Check if there are application parameters within the parameter list.
* Also, retrieve verbosity and warning levels from command line, if any,
* and set the appropriate values.
*
* @param parameters
* all parameters passed to application
* @return true if there are application parameters, false otherwise
* @throws ParameterParseException
*/
public static boolean checkApplicationParameters(List<Parameter> parameters,
ValidationManager validationManager, PrintStream printStream)
throws ParameterParseException, PreflightingToolException
{
// retrieve warning level and verbosity level so that everything is
// set before the application actually runs
List<Parameter> parametersCopy = new ArrayList<Parameter>(parameters);
// Reset the boolean just to make sure that files are not deleted only
// when the user passes the appropriate argument
validationManager.setDeleteApkTempFolder(true);
for (Parameter param : parametersCopy)
{
String parameterType = param.getParameterType();
// Check for the hidden keepTempFiles parameter
if (parameterType.equals(KEEP_TEMP_FILES))
{
validationManager.setDeleteApkTempFolder(false);
parameters.remove(param);
}
// ignore "-wx", check only for "-wN" parameters (and "-vN")
else if (!InputParameter.WARNING_TO_ERROR.getAlias().equals(parameterType)
&& (parameterType.startsWith(VERBOSITY_FLAG) || parameterType
.startsWith(WARNING_FLAG)))
{
if (param.getValue() != null)
{
throw new ParameterParseException(NLS.bind(
PreflightingNLS.ApplicationParameterInterpreter_V_W_PARAMETER_ERROR,
parameterType));
}
if (parameterType.startsWith(VERBOSITY_FLAG))
{
VerboseLevel verboseLevel = DebugVerboseOutputter.DEFAULT_VERBOSE_LEVEL;
try
{
// if the value passed is not a valid enum value, an
// IllegalArgumentException
// will be thrown
verboseLevel =
VerboseLevel.valueOf(VerboseLevel.class, parameterType.trim());
DebugVerboseOutputter.setCurrentVerboseLevel(verboseLevel);
}
catch (Exception e)
{
throw new ParameterParseException(
PreflightingNLS.ApplicationParameterInterpreter_InvalidVerbosityLevel);
}
}
else if (parameterType.startsWith(WARNING_FLAG))
{
WarningLevel warningLevel = WarningLevelFilter.DEFAULT_WARNING_LEVEL;
try
{
// if the value passed is not a valid enum value, an
// IllegalArgumentException
// will be thrown
warningLevel =
WarningLevel.valueOf(WarningLevel.class, parameterType.trim());
}
catch (Exception e)
{
throw new ParameterParseException(
PreflightingNLS.ApplicationParameterInterpreter_InvalidWarningLevel);
}
WarningLevelFilter.setCurrentWarningLevel(warningLevel);
}
// remove from original list so it is not passed along
parameters.remove(param);
}
}
return checkHelpParameter(parameters, validationManager, printStream)
|| checkListParameters(parameters, validationManager, printStream)
|| checkDaemonParameter(parameters);
}
public static void validateOutputParam(String paramValue) throws ParameterParseException
{
if (paramValue != null)
{
if (!OutputterFactory.getInstance().isOutputterAvailable(paramValue).isOK())
{
throw new ParameterParseException(PreflightingNLS.bind(
PreflightingNLS.ApplicationParameterInterpreter_OutputParam, paramValue));
}
}
else
{
throw new ParameterParseException(PreflightingNLS.bind(
PreflightingNLS.ApplicationParameterInterpreter_OutputParam, ""));
}
}
private static boolean checkDaemonParameter(List<Parameter> parameters)
throws ParameterParseException, PreflightingToolException
{
boolean hasDaemonParameter = false;
Parameter pDaemon = getParameter(parameters, PARAM_DAEMON);
Parameter pSDK = getParameter(parameters, InputParameter.SDK_PATH.getAlias());
Parameter pDebug = getParameter(parameters, PARAM_DEBUG);
String sdkPath = (pSDK == null ? null : pSDK.getValue());
if (pDaemon != null)
{
hasDaemonParameter = true;
int serverPort = Daemon.DEFAULT_PORT;
if (pDaemon.getValue() != null)
{
try
{
serverPort = Integer.parseInt(pDaemon.getValue());
}
catch (NumberFormatException nfe)
{
throw new ParameterParseException(NLS.bind(
PreflightingNLS.ApplicationParameterInterpreter_InvalidPort,
pDaemon.getValue()));
}
}
else
{
DebugVerboseOutputter.printVerboseMessage(NLS.bind(
PreflightingNLS.ApplicationParameterInterpreter_UsingDefaultPort,
Daemon.DEFAULT_PORT), VerboseLevel.v0);
}
if (sdkPath != null)
{
ValidationResultData resultData = new ValidationResultData();
GlobalInputParamsValidator.validateSdkParam(resultData, sdkPath);
if (resultData.getSeverity() != SEVERITY.OK)
{
throw new ParameterParseException(resultData.getIssueDescription());
}
}
try
{
Daemon daemon = new Daemon(serverPort, sdkPath);
//The first connection test goes to console instead of nullStream
daemon.setDebugOn(true);
daemon.startDaemon();
//wait for daemon to bound port
Thread.sleep(Daemon.BOUND_TIMEOUT);
daemon.testDaemon();
// set debug true if the -debugDaemon is passed
daemon.setDebugOn(pDebug != null);
//never exits
daemon.join();
}
catch (Exception e)
{
throw new PreflightingToolException(e.getMessage(), e);
}
}
return hasDaemonParameter;
}
private static boolean checkListParameters(List<Parameter> parameters,
ValidationManager validationManager, PrintStream printStream)
throws ParameterParseException
{
boolean hasListParameter = false;
Parameter p = getParameter(parameters, PARAM_LIST_CHECKERS);
if (p != null)
{
hasListParameter = true;
List<CheckerDescription> checkers = validationManager.getCheckersDescription();
HelpPrinter.printCheckersList(checkers, printStream);
}
p = getParameter(parameters, PARAM_LIST_DEVICES);
if (p != null)
{
hasListParameter = true;
List<Value> devices = validationManager.getDevicesInfoList();
HelpPrinter.printDevicesList(devices, printStream);
}
p = getParameter(parameters, PARAM_DESC_DEVICE);
if (p != null)
{
hasListParameter = true;
String deviceId = p.getValue();
if (deviceId == null)
{
throw new ParameterParseException(PreflightingNLS.bind(
PreflightingNLS.CommandLineInputProcessor_IncorrectSyntax,
p.getParameterType()));
}
String deviceDescription = validationManager.getDeviceDescription(deviceId);
HelpPrinter.printDevicesDescription(deviceDescription, deviceId, printStream);
}
return hasListParameter;
}
private static boolean checkHelpParameter(List<Parameter> parameters,
ValidationManager validationManager, PrintStream printStream)
{
boolean hasHelpParam = false;
Parameter p = getParameter(parameters, PARAM_HELP);
if (p != null)
{
hasHelpParam = true;
List<ParameterDescription> paramsDescr = null;
if (p.getValue() != null)
{
CheckerExtension checkerExt = ValidationManager.getCheckerExtension(p.getValue());
if (checkerExt == null)
{
printStream
.print(PreflightingNLS.ApplicationParameterInterpreter_CheckerNotFound
+ p.getValue() + "\n\n"); //$NON-NLS-1$
paramsDescr = getAllParams(validationManager);
HelpPrinter.printHelp(printStream, paramsDescr, true);
}
else
{
// informed CHECKERID, print the description from the
// extension point declaration and print the parameters
// returned by the checker itself.
paramsDescr = validationManager.getParametersDescription(p.getValue());
// HelpPrinter.printHelp(paramsDescr, false);
HelpPrinter.printHelpChecker(printStream, checkerExt);
}
}
else
{
paramsDescr = getAllParams(validationManager);
HelpPrinter.printHelp(printStream, paramsDescr, true);
}
}
return hasHelpParam;
}
private static List<ParameterDescription> getAllParams(ValidationManager validationManager)
{
List<ParameterDescription> paramsDescr = new ArrayList<ParameterDescription>();
if (validationManager.getParametersDescription(null) != null)
{
paramsDescr.addAll(validationManager.getParametersDescription(null));
}
if (OutputterFactory.getInstance().getParameterDescriptions() != null)
{
paramsDescr.addAll(OutputterFactory.getInstance().getParameterDescriptions());
}
// TODO Confirm if it can be removed and also remove ununsed methods
/*
* paramsDescr.add(createHelpDescription());
* paramsDescr.add(createListDescription());
*/
ParameterDescription listCheckersDesc = new ParameterDescription();
listCheckersDesc.setDefaultValue(null);
listCheckersDesc.setName(PARAM_LIST_CHECKERS);
listCheckersDesc
.setDescription(PreflightingNLS.ApplicationParameterInterpreter_ListAvailableCheckersMessage);
paramsDescr.add(listCheckersDesc);
ParameterDescription listDevDesc = new ParameterDescription();
listDevDesc.setDefaultValue(null);
listDevDesc.setName(PARAM_LIST_DEVICES);
listDevDesc
.setDescription(PreflightingNLS.ApplicationParameterInterpreter_ListAvailableDevicesMessage);
paramsDescr.add(listDevDesc);
ParameterDescription describeDevice = new ParameterDescription();
describeDevice.setDefaultValue(null);
describeDevice.setName(PARAM_DESC_DEVICE);
describeDevice.setValueDescription("[DEV]");//$NON-NLS-1$
describeDevice
.setDescription(PreflightingNLS.ApplicationParameterInterpreter_DescribeDeviceMessage);
paramsDescr.add(describeDevice);
ParameterDescription helpDesc = new ParameterDescription();
helpDesc.setName(PARAM_HELP);
helpDesc.setDescription(PreflightingNLS.ApplicationParameterInterpreter_HelpMessage);
helpDesc.setValueDescription("[CHK]");//$NON-NLS-1$
helpDesc.setType(ParameterType.STRING);
paramsDescr.add(helpDesc);
ParameterDescription verbosityDesc = new ParameterDescription();
verbosityDesc.setName(PARAM_VERBOSITY);
verbosityDesc
.setDescription(PreflightingNLS.ApplicationParameterInterpreter_ParameterVerbosityDescription);
paramsDescr.add(verbosityDesc);
ParameterDescription warningDesc = new ParameterDescription();
warningDesc.setName(PARAMETER_WARNING);
warningDesc
.setDescription(PreflightingNLS.ApplicationParameterInterpreter_ParameterWarningDescription);
paramsDescr.add(warningDesc);
return paramsDescr;
}
public static Parameter getParameter(List<Parameter> parameters, String parameter)
{
Parameter param = null;
Iterator<Parameter> it = parameters.iterator();
while (it.hasNext() && (param == null))
{
Parameter p = it.next();
if (p.getParameterType().compareTo(parameter) == 0)
{
param = p;
}
}
return param;
}
}