1 files changed, 808 insertions, 0 deletions
diff --git a/src/plugins/preflighting/src/com/motorolamobility/preflighting/internal/help/printer/HelpPrinter.java b/src/plugins/preflighting/src/com/motorolamobility/preflighting/internal/help/printer/HelpPrinter.java
new file mode 100644
index 0000000..a85d8e0
--- /dev/null
+++ b/src/plugins/preflighting/src/com/motorolamobility/preflighting/internal/help/printer/HelpPrinter.java
@@ -0,0 +1,808 @@
+/*
+ * 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.help.printer;
+
+import java.io.BufferedWriter;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintStream;
+import java.io.UnsupportedEncodingException;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import javax.xml.parsers.ParserConfigurationException;
+import javax.xml.transform.TransformerException;
+
+import org.apache.xerces.jaxp.DocumentBuilderFactoryImpl;
+import org.w3c.dom.Document;
+import org.w3c.dom.Element;
+
+import com.motorolamobility.preflighting.core.checker.CheckerDescription;
+import com.motorolamobility.preflighting.core.checker.CheckerExtension;
+import com.motorolamobility.preflighting.core.checker.IChecker;
+import com.motorolamobility.preflighting.core.checker.condition.Condition;
+import com.motorolamobility.preflighting.core.checker.condition.ICondition;
+import com.motorolamobility.preflighting.core.devicespecification.DeviceSpecification;
+import com.motorolamobility.preflighting.core.devicespecification.DevicesSpecsContainer;
+import com.motorolamobility.preflighting.core.devicespecification.DevicesSpecsContainer.SpecKey;
+import com.motorolamobility.preflighting.core.exception.PreflightingExtensionPointException;
+import com.motorolamobility.preflighting.core.logging.PreflightingLogger;
+import com.motorolamobility.preflighting.core.utils.XmlUtils;
+import com.motorolamobility.preflighting.core.validation.ParameterDescription;
+import com.motorolamobility.preflighting.core.validation.ValidationManager;
+import com.motorolamobility.preflighting.core.validation.ValidationManagerConfiguration;
+import com.motorolamobility.preflighting.core.validation.Value;
+import com.motorolamobility.preflighting.i18n.PreflightingNLS;
+import com.motorolamobility.preflighting.internal.PreflightingPlugin;
+
+/**
+ * Class responsible for printing help information to the console / command line.
+ *
+ */
+public class HelpPrinter
+{
+
+    private static final String SEPARATOR = ",";
+
+    private static final String XML_TAG_CHECKERS = "Checkers";
+
+    private static final String XML_TAG_SPECS = "Specs";
+
+    private static final String XML_TAG_SPEC = "Spec";
+
+    private static final String XML_TAG_SPEC_DEVICES = "SpecDevices";
+
+    private static final String XML_TAG_DEVICES = "Devices";
+
+    private static final String ATTRIBUTE_LEVEL = "level";
+
+    private static final String XML_TAG_CONDITION = "Condition";
+
+    private static final String XML_TAG_VALUE_DESCRIPTION = "ValueDescription";
+
+    private static final String ATTRIBUTE_NAME = "name";
+
+    private static final String XML_TAG_PARAMETER = "Parameter";
+
+    private static final String XML_TAG_DESCRIPTION = "Description";
+
+    private static final String ATTRIBUTE_ID = "id";
+
+    public static final String XML_TAG_CHECKER = "Checker";
+
+    public static final String XML_TAG_DEVICE = "Device";
+
+    public static Document devicesCheckersSpecsMapDocument = null;
+
+    /**
+     * Line separator
+     */
+    private final static String NEWLINE = System.getProperty("line.separator"); //$NON-NLS-1$
+
+    /**
+     * Tab character
+     */
+    private final static String TAB = "\t"; //$NON-NLS-1$
+
+    /**
+     * I/O Exception message logging.
+     */
+    private final static String IO_ERROR = PreflightingNLS.HelpPrinter_IOExceptionMessage;
+
+    private static final String XML_TAG_APP_VALIDATOR = "AppValidator";
+
+    private static final String XML_ATTRIBUTE_APPVALIDATOR_VERSION = "version";
+
+    private static final String XML_ATTRIBUTE_MOTODEV_LINK = "description_url";
+
+    private static final HashMap<String, Document> cache = new HashMap<String, Document>();
+
+    /**
+     * Print help data.
+     * @param parameters Help data
+     * @param printSyntax Whether syntax should be printed or not
+     * @param printStream 
+     * @param checker checker to get the description and parameters returned
+     */
+    public static void printHelp(PrintStream printStream, List<ParameterDescription> parameters,
+            boolean printSyntax)
+    {
+        if (parameters.size() > 0)
+        {
+            StringBuilder stringBuilder = new StringBuilder();
+
+            if (printSyntax)
+            {
+                stringBuilder.append(PreflightingNLS.HelpPrinter_Usage + " ");
+                stringBuilder.append("\t" + PreflightingNLS.HelpPrinter_ProgramName);
+                stringBuilder
+                        .append("[OPTION[PRM]]...\n\t" + PreflightingNLS.HelpPrinter_ProgramName + "[OPTION[PRM]]... -input [FILE] [OPTION[PRM]]...\n");//$NON-NLS-1$
+                stringBuilder.append(PreflightingNLS.HelpPrinter_ProgramDescritpion + NEWLINE
+                        + NEWLINE);
+            }
+
+            stringBuilder.append(PreflightingNLS.HelpPrinter_OptionsMessage + NEWLINE);
+            // Iterate through the parameters and print the info
+            for (ParameterDescription p : parameters)
+            {
+                /*
+                 * The output format will be something like this:
+                 * 
+                 * Parameter info:
+                 *  -{Parameter name} [TAB] Default value: {defaultValue} - {Description}
+                 *      [TAB] {value1} Type: {type} - Description
+                 */
+
+                // Append parameter name
+                if (p.getName() != null)
+                {
+                    stringBuilder.append("-" + p.getName()); //$NON-NLS-1$
+                    int totalLenght = p.getName().length();
+                    if (p.getValueDescription() != null)
+                    {
+                        stringBuilder.append(" " + p.getValueDescription()); //$NON-NLS-1$
+                        totalLenght += p.getValueDescription().length() + 1;
+                    }
+                    if (totalLenght < 25)
+                    {
+                        int i = 25 - totalLenght;
+                        while (i > 0)
+                        {
+                            stringBuilder.append(" ");
+                            i--;
+                        }
+                    }
+                }
+
+                // Append default value
+                if (p.getDefaultValue() != null)
+                {
+                    stringBuilder.append(PreflightingNLS.HelpPrinter_DefaultMessage
+                            + p.getDefaultValue().getValue());
+                    stringBuilder.append(" "); //$NON-NLS-1$
+                }
+
+                // Append description
+                if (p.getDescription() != null)
+                {
+                    stringBuilder.append("- "); //$NON-NLS-1$
+                    stringBuilder.append(p.getDescription());
+                    stringBuilder.append(NEWLINE);
+                }
+
+                // Append values information
+                for (Value v : p.getAllowedValues())
+                {
+                    stringBuilder.append(TAB);
+
+                    // Append value
+                    if (v.getValue() != null)
+                    {
+                        stringBuilder.append(v.getValue());
+                        stringBuilder.append(" - "); //$NON-NLS-1$
+                    }
+
+                    // Append description
+                    if (v.getDescription() != null)
+                    {
+                        stringBuilder.append(v.getDescription());
+                        stringBuilder.append(NEWLINE);
+                    }
+                }
+
+            }
+
+            printStream.print(stringBuilder.toString());
+            printStream.flush();
+        }
+
+    }
+
+    /**
+     * Prints a XML file which contains a list of devices, their id for App Validator and provider
+     * @param stream The stream used to print the XML file
+     * @throws ParserConfigurationException 
+     * @throws TransformerException 
+     * @throws UnsupportedEncodingException 
+     */
+    public static void printXMLDevicesList(PrintStream stream) throws ParserConfigurationException,
+            UnsupportedEncodingException, TransformerException
+    {
+
+        ValidationManager validationManager = new ValidationManager();
+
+        DevicesSpecsContainer devicesSpecsContainer = validationManager.getDevicesSpecsContainer();
+
+        Document document =
+                DocumentBuilderFactoryImpl.newInstance().newDocumentBuilder().newDocument();
+        Element appvalidatorElement = createAppvalidatorNode(document);
+
+        for (DeviceSpecification deviceInfo : devicesSpecsContainer.getDeviceSpecifications())
+        {
+            appvalidatorElement.appendChild(createDeviceNode(deviceInfo, document));
+        }
+
+        XmlUtils.printXMLFormat(document);
+
+        validationManager = null;
+    }
+
+    private static Element createDeviceNode(DeviceSpecification deviceInfo, Document document)
+    {
+        Element deviceNode = document.createElement(XML_TAG_DEVICE);
+        deviceNode.setTextContent(deviceInfo.getName());
+
+        deviceNode.setAttribute("id", deviceInfo.getId());
+        deviceNode.setAttribute("provider", deviceInfo.getProvider());
+
+        return deviceNode;
+    }
+
+    /**
+     * Prints a XML file which contains a list of checkers and all the information regarding each checker
+     * @param stream The stream used to print the XML file
+     */
+    public static void printXMLCheckerList(PrintStream stream)
+            throws PreflightingExtensionPointException, ParserConfigurationException,
+            UnsupportedEncodingException, TransformerException
+    {
+
+        Map<String, CheckerExtension> checkers = ValidationManager.loadCheckers();
+        Collection<CheckerExtension> checkerExtensions = checkers.values();
+
+        Document document =
+                DocumentBuilderFactoryImpl.newInstance().newDocumentBuilder().newDocument();
+        Element appvalidatorElement = null;
+
+        appvalidatorElement = createAppvalidatorNode(document);
+
+        for (CheckerExtension extension : checkerExtensions)
+        {
+            Element node = getXMLCheckerNode(extension, document);
+            appvalidatorElement.appendChild(node);
+        }
+
+        XmlUtils.printXMLFormat(document);
+
+    }
+
+    private static Element createAppvalidatorNode(Document document)
+    {
+
+        Element appValElem = document.createElement(XML_TAG_APP_VALIDATOR);
+        document.appendChild(appValElem);
+        String appValidatorVersion = PreflightingPlugin.getInstance().getAppValidatorVersion();
+        ValidationManagerConfiguration valManagerConfiguration =
+                ValidationManagerConfiguration.getInstance();
+        String motodevLink =
+                valManagerConfiguration
+                        .getProperty(ValidationManagerConfiguration.ConfigProperties.BASE_URL_PROPERTY
+                                .getName());
+
+        appValElem.setAttribute(XML_ATTRIBUTE_APPVALIDATOR_VERSION, appValidatorVersion);
+        appValElem.setAttribute(XML_ATTRIBUTE_MOTODEV_LINK, motodevLink);
+
+        return appValElem;
+    }
+
+    /**
+     * Generate a XML node for a specific checker
+     */
+    private static Element getXMLCheckerNode(CheckerExtension extension, Document document)
+    {
+
+        Element checkerNode = document.createElement(XML_TAG_CHECKER);
+        checkerNode.setAttribute(ATTRIBUTE_ID, extension.getId());
+
+        Element descriptionNode = document.createElement(XML_TAG_DESCRIPTION);
+        descriptionNode.setTextContent(extension.getDescription());
+
+        checkerNode.appendChild(descriptionNode);
+
+        IChecker checker = extension.getChecker();
+        List<Condition> conditionList = getSortedConditions(checker);
+
+        appendConditions(checkerNode, document, conditionList);
+        appendParameters(checkerNode, document, checker);
+
+        return checkerNode;
+    }
+
+    private static void appendParameters(Element checkerNode, Document document, IChecker checker)
+    {
+        List<ParameterDescription> paremeterDescriptionList = checker.getParameterDescriptions();
+        if ((paremeterDescriptionList != null) && (paremeterDescriptionList.size() > 0))
+        {
+            for (ParameterDescription param : paremeterDescriptionList)
+            {
+                Element parameterNode = document.createElement(XML_TAG_PARAMETER);
+                parameterNode.setAttribute(ATTRIBUTE_NAME, param.getName());
+
+                Element valueDescriptionNode = document.createElement(XML_TAG_VALUE_DESCRIPTION);
+                valueDescriptionNode.setTextContent(param.getValueDescription());
+
+                Element paramDescrNode = document.createElement(XML_TAG_DESCRIPTION);
+                paramDescrNode.setTextContent(param.getDescription());
+
+                parameterNode.appendChild(valueDescriptionNode);
+                parameterNode.appendChild(paramDescrNode);
+                checkerNode.appendChild(parameterNode);
+            }
+        }
+    }
+
+    private static void appendConditions(Element checkerNode, Document document,
+            List<Condition> conditionList)
+    {
+        for (ICondition condition : conditionList)
+        {
+            Element conditionNode = document.createElement(XML_TAG_CONDITION);
+            conditionNode.setAttribute(ATTRIBUTE_ID, condition.getId());
+            conditionNode.setAttribute(ATTRIBUTE_LEVEL, condition.getSeverityLevel().toString());
+
+            Element conditionDescrNode = document.createElement(XML_TAG_DESCRIPTION);
+            conditionDescrNode.setTextContent(condition.getDescription());
+
+            conditionNode.appendChild(conditionDescrNode);
+            checkerNode.appendChild(conditionNode);
+        }
+    }
+
+    /**
+     * Prints the description from the extension point declaration and 
+     * print the parameters returned by the checker itself.
+     * @param checkerExtension
+     */
+    public static void printHelpChecker(PrintStream out, CheckerExtension checkerExtension)
+    {
+        StringBuilder stringBuilder = new StringBuilder();
+
+        stringBuilder.append(PreflightingNLS.HelperPrinter_CheckerId + checkerExtension.getId()
+                + NEWLINE);
+        stringBuilder.append(PreflightingNLS.HelperPrinter_CheckerDescription
+                + checkerExtension.getDescription() + NEWLINE);
+
+        IChecker checker = checkerExtension.getChecker();
+
+        // Append condition information
+        List<Condition> conditionList = getSortedConditions(checker);
+
+        // Size < 0 should never happen, but you never can be too sure...
+        if ((conditionList != null) && (conditionList.size() > 0))
+        {
+            // Iterate through the condition and print the descriptions
+            stringBuilder.append(NEWLINE);
+            stringBuilder.append(PreflightingNLS.HelperPrinter_CheckerHasConditions + NEWLINE);
+
+            stringBuilder.append(NEWLINE);
+            stringBuilder.append(TAB);
+            stringBuilder.append("Default level");
+            stringBuilder.append(TAB);
+
+            stringBuilder.append("Condition ID");
+            stringBuilder.append(TAB);
+            stringBuilder.append(TAB);
+            stringBuilder.append(TAB);
+            stringBuilder.append("Description");
+            stringBuilder.append(NEWLINE);
+
+            for (ICondition c : conditionList)
+            {
+                stringBuilder.append(TAB);
+                stringBuilder.append(c.getSeverityLevel().toString());
+                stringBuilder.append(TAB);
+                stringBuilder.append(TAB);
+                stringBuilder.append(c.getId());
+                stringBuilder.append(TAB);
+                if (c.getId().length() < 24)
+                {
+                    stringBuilder.append(TAB);
+                }
+                if (c.getId().length() < 15)
+                {
+                    stringBuilder.append(TAB);
+                }
+                stringBuilder.append(c.getDescription());
+                stringBuilder.append(NEWLINE);
+            }
+
+            stringBuilder.append(NEWLINE);
+        }
+
+        List<ParameterDescription> paremeterDescriptionList = checker.getParameterDescriptions();
+        if (paremeterDescriptionList != null)
+        {
+
+            if (paremeterDescriptionList.size() > 0)
+            {
+                stringBuilder.append(PreflightingNLS.HelperPrinter_CheckerUsesParameters + NEWLINE);
+            }
+            else
+            {
+                stringBuilder.append(PreflightingNLS.HelperPrinter_CheckerDoesNotUseParameters
+                        + NEWLINE);
+            }
+            for (ParameterDescription returnParam : paremeterDescriptionList)
+            {
+                String paramMessage =
+                        TAB + returnParam.getName() + " = " + returnParam.getValueDescription();
+                if ((returnParam.getType() != null) && (returnParam.getType().toString() != null))
+                {
+                    paramMessage += " [" + returnParam.getType().toString() + "]";
+                }
+                paramMessage += TAB + "- " + returnParam.getDescription() + NEWLINE;
+                stringBuilder.append(paramMessage);
+            }
+        }
+
+        out.print(stringBuilder.toString());
+    }
+
+    /**
+     * Return a sorted list of checker conditions according to it default level
+     * 
+     * @param checker the checker what have the conditions
+     * @return the sorted list of conditions
+     */
+    private static List<Condition> getSortedConditions(IChecker checker)
+    {
+        List<Condition> conditionList = new ArrayList(checker.getConditions().values());
+
+        // Sort the conditions list
+        Collections.sort(conditionList, new Comparator<Condition>()
+        {
+            public int compare(Condition o1, Condition o2)
+            {
+                if (o1.getSeverityLevel().ordinal() > o2.getSeverityLevel().ordinal())
+                {
+                    return +1;
+                }
+                else
+                {
+                    return -1;
+                }
+            }
+        });
+        return conditionList;
+    }
+
+    public static void printDevicesList(List<Value> list, PrintStream printStream)
+    {
+        if (list.size() > 0)
+        {
+            StringBuilder stringBuilder = new StringBuilder();
+
+            stringBuilder.append(PreflightingNLS.HelpPrinter_Device_Id + " name - [id]");
+            stringBuilder.append(NEWLINE);
+            for (Value current : list)
+            {
+                //Append device ID
+                stringBuilder.append(TAB);
+                stringBuilder.append(current.getValue());
+                stringBuilder.append(NEWLINE);
+            }
+            printStream.print(stringBuilder.toString());
+            // Clean string builder
+            stringBuilder.delete(0, stringBuilder.length());
+        }
+    }
+
+    public static void printDevicesDescription(String deviceDescription, String deviceId,
+            PrintStream printStream)
+    {
+        if ((deviceDescription != null) && !deviceDescription.trim().equals(""))
+        {
+            printStream.print(deviceDescription);
+            printStream.println();
+        }
+        else
+        {
+            //device id not found
+            printStream.print(PreflightingNLS
+                    .bind(PreflightingNLS.GlobalInputParamsValidator_NonExistentDeviceIdMessage,
+                            deviceId));
+        }
+    }
+
+    public static void printCheckersList(List<CheckerDescription> list, PrintStream printStream)
+    {
+        if (list.size() > 0)
+        {
+            StringBuilder stringBuilder = new StringBuilder();
+
+            /*
+             * Header
+             */
+
+            // Iterate through the values and print the info                
+            for (CheckerDescription checker : list)
+            {
+                /*
+                 * The output format will be something like this:
+                 * 
+                 * {value} {TAB} {Description}
+                 */
+
+                //Append ID
+                stringBuilder.append(PreflightingNLS.HelpPrinter_Checker_Id);
+                stringBuilder.append(TAB);
+                stringBuilder.append(TAB);
+                stringBuilder.append(checker.getId());
+                stringBuilder.append(NEWLINE);
+
+                //Append Name
+                stringBuilder.append(PreflightingNLS.HelpPrinter_Checker_Name);
+                stringBuilder.append(TAB);
+                stringBuilder.append(TAB);
+                if ((checker.getName() != null))
+                {
+                    stringBuilder.append(checker.getName());
+                }
+                else
+                {
+                    stringBuilder.append(PreflightingNLS.HelpPrinter_Checker_NotAvailable);
+                }
+                stringBuilder.append(NEWLINE);
+
+                //Append Description
+                stringBuilder.append(PreflightingNLS.HelpPrinter_Checker_Description);
+                stringBuilder.append(TAB);
+                if ((checker.getName() != null))
+                {
+                    stringBuilder.append(checker.getDescription());
+                }
+                else
+                {
+                    stringBuilder.append(PreflightingNLS.HelpPrinter_Checker_NotAvailable);
+                }
+                stringBuilder.append(NEWLINE);
+                stringBuilder.append(NEWLINE);
+
+                printStream.print(stringBuilder.toString());
+
+                // Clean string builder
+                stringBuilder.delete(0, stringBuilder.length());
+            }
+        }
+    }
+
+    /**
+     * Print a list of values.
+     * @param values The list of values
+     * @param stream The output stream
+     */
+    public static void printList(List<Value> values, OutputStream stream)
+    {
+        if (values.size() > 0)
+        {
+            /*
+             * Writer used for output
+             */
+            BufferedWriter writer = null;
+            StringBuilder stringBuilder = new StringBuilder();
+
+            writer = new BufferedWriter(new OutputStreamWriter(stream));
+
+            try
+            {
+                // Iterate through the values and print the info
+                for (Value v : values)
+                {
+                    /*
+                     * The output format will be something like this:
+                     * 
+                     * {value} {TAB} {Description}
+                     */
+
+                    stringBuilder.append(v.getValue());
+                    stringBuilder.append(TAB);
+                    if (v.getDescription() != null)
+                    {
+                        stringBuilder.append(v.getDescription());
+                    }
+
+                    writer.write(stringBuilder.toString());
+                    writer.flush();
+
+                    // Clean string builder
+                    stringBuilder.delete(0, stringBuilder.length());
+
+                }
+            }
+            catch (IOException e)
+            {
+
+                PreflightingLogger.error(HelpPrinter.class, IO_ERROR + e.getMessage());
+
+            }
+            finally
+            {
+                try
+                {
+                    writer.close();
+                }
+                catch (IOException e)
+                {
+                    PreflightingLogger.error(HelpPrinter.class, IO_ERROR + e.getMessage());
+                }
+            }
+        }
+
+    }
+
+    private static Element createSpecDevicesMapNode(ValidationManager validationManager,
+            Document document, String categories)
+    {
+        Element specDevicesNode = document.createElement(XML_TAG_SPEC_DEVICES);
+        Map<SpecKey, List<DeviceSpecification>> specDevsMap =
+                validationManager.getDevicesSpecsContainer().getSpecDevFilterMap();
+
+        //Set<SpecKey> specs = specDevsMap.keySet();
+        String[] specs = categories.split(SEPARATOR);
+
+        for (String specStr : specs)
+        {
+            SpecKey spec = SpecKey.valueOf(specStr);
+            Element specNode = document.createElement(XML_TAG_SPEC);
+            specNode.setAttribute(ATTRIBUTE_ID, spec.getId());
+
+            List<DeviceSpecification> devs = specDevsMap.get(spec);
+
+            if (devs != null)
+            {
+                for (DeviceSpecification dev : devs)
+                {
+                    Element devNode = document.createElement(XML_TAG_DEVICE);
+                    devNode.setAttribute(ATTRIBUTE_ID, dev.getId());
+                    specNode.appendChild(devNode);
+                }
+            }
+
+            specDevicesNode.appendChild(specNode);
+        }
+
+        return specDevicesNode;
+    }
+
+    private static Element creatSpecsNode(ValidationManager validationManager, Document document,
+            String categories)
+    {
+
+        Element specsNode = document.createElement(XML_TAG_SPECS);
+        String[] specList = categories.split(SEPARATOR);
+
+        //SpecKey[] specs = SpecKey.values();
+        //for (SpecKey spec : specs)
+        for (String spec : specList)
+        {
+            Element specNode = document.createElement(XML_TAG_SPEC);
+            specNode.setAttribute(ATTRIBUTE_ID, spec);//spec.getId());
+            specNode.setAttribute(ATTRIBUTE_NAME, spec);//spec.getId());
+
+            specsNode.appendChild(specNode);
+        }
+
+        return specsNode;
+    }
+
+    private static Element createCheckersNode(ValidationManager validationManager, Document document)
+    {
+
+        Element checkersNode = document.createElement(XML_TAG_CHECKERS);
+
+        List<CheckerDescription> checkers = validationManager.getCheckersDescription();
+
+        for (CheckerDescription checker : checkers)
+        {
+            Element checkerNode = document.createElement(XML_TAG_CHECKER);
+            checkerNode.setAttribute(ATTRIBUTE_ID, checker.getId());
+            checkerNode.setAttribute(ATTRIBUTE_NAME, checker.getName());
+
+            checkersNode.appendChild(checkerNode);
+        }
+
+        return checkersNode;
+    }
+
+    private static Element createDevicesNode(ValidationManager validationManager, Document document)
+    {
+
+        Element devicesNode = document.createElement(XML_TAG_DEVICES);
+        DevicesSpecsContainer devicesSpecsContainer = validationManager.getDevicesSpecsContainer();
+        List<DeviceSpecification> devices = devicesSpecsContainer.getDeviceSpecifications();
+
+        // order by device name
+        Collections.sort(devices, new Comparator<DeviceSpecification>()
+        {
+            public int compare(DeviceSpecification d1, DeviceSpecification d2)
+            {
+                return d1.getName().compareToIgnoreCase(d2.getName());
+            }
+        });
+
+        for (DeviceSpecification devSpec : devices)
+        {
+
+            Element deviceNode = document.createElement(XML_TAG_DEVICE);
+
+            deviceNode.setAttribute(ATTRIBUTE_ID, devSpec.getId());
+            deviceNode.setAttribute(ATTRIBUTE_NAME, devSpec.getName().replace("�", "&#8482;"));
+
+            devicesNode.appendChild(deviceNode);
+        }
+
+        return devicesNode;
+    }
+
+    /**
+     * Print an XML file with: list of checkers, list of devices, map of specifications vs devices
+     * @param stream The output stream
+     * @throws ParserConfigurationException 
+     * @throws TransformerException 
+     * @throws UnsupportedEncodingException 
+     */
+    public static void printXMLDevicesCheckersSpecsMap(PrintStream stream)
+            throws ParserConfigurationException, UnsupportedEncodingException, TransformerException
+    {
+
+        // TODO: implement a configuration file or another way to keep this list
+        String categories =
+                SpecKey.screenSize_Small.getId() + SEPARATOR + SpecKey.screenSize_XLarge.getId()
+                        + SEPARATOR + SpecKey.screenOrientation_Port.getId() + SEPARATOR
+                        + SpecKey.screenOrientation_Land.getId() + SEPARATOR
+                        + SpecKey.pixelDensity_High.getId() + SEPARATOR
+                        + SpecKey.pixelDensity_Low.getId() + SEPARATOR
+                        + SpecKey.pixelDensity_Medium.getId() + SEPARATOR
+                        + SpecKey.pixelDensity_XHigh.getId();
+
+        if (cache.get(categories) == null)
+        {
+            Document document =
+                    DocumentBuilderFactoryImpl.newInstance().newDocumentBuilder().newDocument();
+            Element appvalidatorElement = createAppvalidatorNode(document);
+
+            ValidationManager validationManager = new ValidationManager();
+
+            Element checkersNode = createCheckersNode(validationManager, document);
+            appvalidatorElement.appendChild(checkersNode);
+
+            Element devicesNode = createDevicesNode(validationManager, document);
+            appvalidatorElement.appendChild(devicesNode);
+
+            Element specsNode = creatSpecsNode(validationManager, document, categories);
+            appvalidatorElement.appendChild(specsNode);
+
+            Element specDevicesMapNode =
+                    createSpecDevicesMapNode(validationManager, document, categories);
+            appvalidatorElement.appendChild(specDevicesMapNode);
+
+            cache.put(categories, document);
+        }
+
+        XmlUtils.printXMLFormat(cache.get(categories));
+
+        XmlUtils.printXMLFormat(cache.get(categories));
+
+    }
+
+}