path: root/src/plugins/preflighting/src/com/motorolamobility/preflighting/internal/commandinput/ApplicationParameterInterpreter.java

/*
 * 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;
    }
}