/*
* 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.internal.utils;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.StringWriter;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.zip.ZipEntry;
import java.util.zip.ZipException;
import java.util.zip.ZipInputStream;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.OutputKeys;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import org.eclipse.core.runtime.Path;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import com.motorolamobility.preflighting.core.exception.PreflightingToolException;
import com.motorolamobility.preflighting.core.i18n.PreflightingCoreNLS;
import com.motorolamobility.preflighting.core.logging.PreflightingLogger;
public final class AaptUtils
{
private static final String ANDROID_SMALL_SCREENS = "android:smallScreens";
public static final String APP_VALIDATOR_TEMP_DIR = "MotodevAppValidator";
private static final String JAVA_TEMP_DIR_PROPERTY = "java.io.tmpdir";
private static final String TEMP_DIR_PATH = System.getProperty(JAVA_TEMP_DIR_PROPERTY);
// Temp folder used for APK extracting
public static final File tmpAppValidatorFolder =
new File(TEMP_DIR_PATH, APP_VALIDATOR_TEMP_DIR);
private static final String CLASSES_DEX = "classes.dex"; //$NON-NLS-1$
private static final String RESOURCES_ARSC = "resources.arsc"; //$NON-NLS-1$
private static final String XML_FILE = "xml"; //$NON-NLS-1$
private static final String ELEMENT_NODE = "E:"; //$NON-NLS-1$
private static final String ATTRIBUTE_NODE = "A:"; //$NON-NLS-1$
private static final String NAMESPACE_XMLNS = "N:"; //$NON-NLS-1$
private static HashMap<String, HashMap<String, String>> resourceValues =
new HashMap<String, HashMap<String, String>>();
private static Map<String, String> navigationMap;
private static Map<String, String> nightMap;
private static Map<String, String> keyboardMap;
private static Map<String, String> touchMap;
private static Map<String, String> densityMap;
private static Map<String, String> sizeMap;
private static Map<String, String> orientationMap;
private static Map<String, String> longMap;
private static Map<String, String> navHiddenMap;
private static Map<String, String> keyHiddenMap;
private static Map<String, String> typeMap;
public static final String APK_EXTENSION = ".apk";
public static final String ZIP_EXTENSION = ".zip";
private static Map<Pattern, Map<String, String>> localizationAttributesMap2 =
new HashMap<Pattern, Map<String, String>>();
private static Map<Pattern, String> localizationAttributesMap1 = new HashMap<Pattern, String>();
private static Pattern[] patternArray = new Pattern[18];
static
{
// Initialize specific maps
navigationMap = new HashMap<String, String>();
navigationMap.put("1", "nonav");
navigationMap.put("2", "dpad");
navigationMap.put("3", "trackball");
navigationMap.put("4", "wheel");
nightMap = new HashMap<String, String>();
nightMap.put("16", "notnight");
nightMap.put("32", "night");
keyboardMap = new HashMap<String, String>();
keyboardMap.put("1", "nokeys");
keyboardMap.put("2", "qwerty");
keyboardMap.put("3", "12key");
touchMap = new HashMap<String, String>();
touchMap.put("1", "notouch");
touchMap.put("2", "stylus");
touchMap.put("3", "finger");
densityMap = new HashMap<String, String>();
densityMap.put("no", "nodpi");
densityMap.put("120", "ldpi");
densityMap.put("160", "mdpi");
densityMap.put("240", "hdpi");
sizeMap = new HashMap<String, String>();
sizeMap.put("1", "small");
sizeMap.put("2", "normal");
sizeMap.put("3", "large");
orientationMap = new HashMap<String, String>();
orientationMap.put("1", "port");
orientationMap.put("2", "land");
orientationMap.put("3", "square");
longMap = new HashMap<String, String>();
longMap.put("16", "notlong");
longMap.put("32", "long");
navHiddenMap = new HashMap<String, String>();
navHiddenMap.put("8", "navhidden");
navHiddenMap.put("4", "navexposed");
keyHiddenMap = new HashMap<String, String>();
keyHiddenMap.put("1", "keyexposed");
keyHiddenMap.put("2", "keyhidden");
typeMap = new HashMap<String, String>();
typeMap.put("3", "car");
// initialize localization folder attributes
// the order of patternArray elements are extremely important, do not
// modify it
localizationAttributesMap1.put(patternArray[0] = Pattern.compile("mcc=[0-9]+"), "mcc");
localizationAttributesMap1.put(patternArray[1] = Pattern.compile("mnc=[0-9]+"), "mnc");
localizationAttributesMap1.put(patternArray[2] = Pattern.compile("lang=[a-z]+"), "");
localizationAttributesMap1.put(patternArray[3] = Pattern.compile("cnt=[A-Z]+"), "r");
localizationAttributesMap2.put(patternArray[4] = Pattern.compile("sz=[0-9]"), sizeMap);
localizationAttributesMap2.put(patternArray[5] = Pattern.compile("lng=[0-9]+"), longMap);
localizationAttributesMap2.put(patternArray[6] = Pattern.compile("orient=[0-9]"),
orientationMap);
localizationAttributesMap2.put(patternArray[7] = Pattern.compile("type=[0-9]"), typeMap);
localizationAttributesMap2.put(patternArray[8] = Pattern.compile("night=[0-9]+"), nightMap);
localizationAttributesMap2.put(patternArray[9] = Pattern.compile("density=[0-9]+"),
densityMap);
localizationAttributesMap2.put(patternArray[10] = Pattern.compile("touch=[0-9]"), touchMap);
localizationAttributesMap2.put(patternArray[11] = Pattern.compile("keyhid=[0-9]"),
keyHiddenMap);
localizationAttributesMap2
.put(patternArray[12] = Pattern.compile("kbd=[0-9]"), keyboardMap);
localizationAttributesMap2.put(patternArray[13] = Pattern.compile("navhid=[0-9]"),
navHiddenMap);
localizationAttributesMap2.put(patternArray[14] = Pattern.compile("nav=[0-9]"),
navigationMap);
localizationAttributesMap1.put(patternArray[15] = Pattern.compile("\\sw=[0-9]+"), "");
localizationAttributesMap1.put(patternArray[16] = Pattern.compile("\\sh=[0-9]+"), "x");
localizationAttributesMap1.put(patternArray[17] = Pattern.compile("sdk=[0-9]+"), "v");
}
/**
* Cleans resources maps among executions for applications
*/
public static void cleanApplicationResourceValues()
{
resourceValues.clear();
}
public static void extractFilesFromAPK(File apkFile, String sdkPath, File tmpProjectFile)
throws PreflightingToolException
{
if ((tmpProjectFile != null) && tmpProjectFile.exists() && tmpProjectFile.canWrite())
{
ZipInputStream apkInputStream = null;
FileOutputStream apkOutputStream = null;
try
{
// create the buffer and the the zip stream
byte[] buf = new byte[1024];
apkInputStream = new ZipInputStream(new FileInputStream(apkFile.getAbsolutePath()));
ZipEntry apkZipEntry = null;
try
{
apkZipEntry = apkInputStream.getNextEntry();
}
catch (Exception e)
{
PreflightingLogger.error(ApkUtils.class,
"It was not possible to read the android package.", e); //$NON-NLS-1$
}
if (apkZipEntry == null)
{
throw new IOException("Invalid APK file.");
}
String folders = null;
File fileToCreate = null;
// create res folder
fileToCreate = new File(tmpProjectFile, "res");
if (!fileToCreate.exists())
{
fileToCreate.mkdirs();
}
// create the resources file
Map<File, Document> languageMap =
retrieveLocalizationStringsMapFromAPK(sdkPath, apkFile.getAbsolutePath(),
"ProjectResourcesValues.xml");
createLocalizationFilesFromMap(languageMap, fileToCreate);
// iterates through each entry to be extracted of the android
// package
while (apkZipEntry != null)
{
try
{
String apkEntryName = apkZipEntry.getName();
if (apkEntryName.indexOf(Path.SEPARATOR) != -1)
{
// creates the directory structure
folders =
apkEntryName.substring(0,
apkEntryName.lastIndexOf(Path.SEPARATOR));
fileToCreate = new File(tmpProjectFile, folders);
if (!fileToCreate.exists())
{
fileToCreate.mkdirs();
}
}
if (apkEntryName.endsWith(XML_FILE))
{
// Gets XML from the parser
fileToCreate = new File(tmpProjectFile, apkEntryName);
createXMLFile(sdkPath, apkFile.getAbsolutePath(), apkEntryName,
fileToCreate);
}
// filter files which is desired to create
else if (!apkEntryName.endsWith(RESOURCES_ARSC)
&& !apkEntryName.endsWith(CLASSES_DEX))
{
// write the file
try
{
apkOutputStream =
new FileOutputStream(tmpProjectFile.getAbsolutePath()
+ Path.SEPARATOR + apkEntryName);
int length = 0;
while ((length = apkInputStream.read(buf, 0, 1024)) > -1)
{
apkOutputStream.write(buf, 0, length);
}
}
finally
{
if (apkOutputStream != null)
{
try
{
apkOutputStream.close();
}
catch (IOException e)
{
//Do Nothing.
}
}
}
}
}
catch (ZipException zipException)
{
// throw exception because the apk is probably corrupt
PreflightingLogger
.error(ApkUtils.class,
"It was not possible to read the android package; it is probably corrupt.", zipException); //$NON-NLS-1$
throw new PreflightingToolException(
PreflightingCoreNLS.ApkUtils_ImpossibleExtractAndroidPackageMessage,
zipException);
}
catch (IOException ioException)
{
// log the error but do not thrown an exception because
// it will be attempted to create all files
PreflightingLogger.error(ApkUtils.class,
"It was not possible to extract the android package.", ioException); //$NON-NLS-1$
}
finally
{
apkInputStream.closeEntry();
apkZipEntry = apkInputStream.getNextEntry();
}
}
}
catch (IOException ioException)
{
PreflightingLogger.error(ApkUtils.class,
"It was not possible to read the android package.", ioException); //$NON-NLS-1$
throw new PreflightingToolException(
PreflightingCoreNLS.ApkUtils_ImpossibleExtractAndroidPackageMessage,
ioException);
}
finally
{
try
{
if (apkInputStream != null)
{
apkInputStream.close();
}
if (apkOutputStream != null)
{
apkOutputStream.close();
}
}
catch (IOException ioException)
{
// Do Nothing.
}
}
}
else
{
PreflightingLogger.error(ApkUtils.class,
"It was not possible to read the android package."); //$NON-NLS-1$
throw new PreflightingToolException(
PreflightingCoreNLS.ApkUtils_ImpossibleExtractAndroidPackageMessage);
}
}
/**
* Given an APK file, all folders and DOMs for creating the directory
* structure with the localization files are returned in a {@link Map}. <br>
* The {@link Map} returned holds the following info: [{@link File},
* {@link Document}] in which the {@link File} represents the folder path in
* which the {@link Document} is to be created.
*
* @param aaptPath
* AAP tool path.
* @param apkPath
* APK file which the strings of translation are retrieved.
* @param xmlFileName
* XML file name generated by the AAP tool.
*
* @return The {@link Map} structure holding the {@link File}s and
* {@link Document}s necessary to create the directory tree for
* translation.
*
* @throws PreflightingToolException
* Exception thrown in case anything goes wrong extracting data.
*/
public static Map<File, Document> retrieveLocalizationStringsMapFromAPK(String aaptPath,
String apkPath, String xmlFileName) throws PreflightingToolException
{
BufferedReader bReader = null;
InputStreamReader reader = null;
Map<File, Document> map = new HashMap<File, Document>();
try
{
Process aapt =
runAAPTCommandForExtractingResourcesAndValues(aaptPath, apkPath, xmlFileName);
// read output and store it in a buffer
reader = new InputStreamReader(aapt.getInputStream());
bReader = new BufferedReader(reader);
// patterns used to retrieve lines for language, key and values of
// string translations
Pattern languagePattern = Pattern.compile("config\\s[0-9]+");
Pattern stringKeyPattern =
Pattern.compile("[\\s]{2,}resource.+:string/[a-zA-Z0-9\\._$]+:");
Pattern stringArrayKeyPattern =
Pattern.compile("[\\s]{2,}resource.+:array/[a-zA-Z0-9\\._$]+:");
Pattern stringArrayCountPattern = Pattern.compile("Count=[0-9]+");
Pattern stringValuePattern = Pattern.compile("\".*\"");
Matcher matcher = null;
Document document = null;
Element resourceElement = null;
Element stringElement = null;
File languageDirectory = null;
int stringArraySize = 0;
String folderName = null;
String stringArraySizeText = null;
String key = null;
String value = null;
String[] arrayValue = null;
String infoLine = "";
while ((infoLine = bReader.readLine()) != null)
{
// try to match with language
matcher = languagePattern.matcher(infoLine);
if (matcher.find())
{
// in case there are a document and file, add it to the map
if ((document != null) && (languageDirectory != null)
&& (resourceElement != null)
&& (resourceElement.getChildNodes() != null)
&& (resourceElement.getChildNodes().getLength() > 0))
{
map.put(languageDirectory, document);
// reset them
languageDirectory = null;
document = null;
}
// get the folder name based on the language
folderName = createResourcesSubfolders(infoLine, "values");
languageDirectory = new File(folderName);
// try to find an existent directory
document = findDocumentByLanguageDirectory(map, languageDirectory);
// the DOM was not found - initialize variables
if (document == null)
{
document = createNewDocument();
resourceElement = document.createElement("resources");
document.appendChild(resourceElement);
}
// the DOM was found - get the resources element (root
// element)
else
{
resourceElement = document.getDocumentElement();
}
}
// try to match with single string keys
matcher = stringKeyPattern.matcher(infoLine);
if (matcher.find())
{
key = matcher.group();
key = key.split(":string/")[1].split(":")[0];
infoLine = "";
do
{
// go the the next line in order to read the value
infoLine += bReader.readLine();
}
// do not delete the bReader.ready() statement because this avoids infinitive loops in case the regular expression fails
while (!infoLine.matches(".*\".*\".*") && bReader.ready());
matcher = stringValuePattern.matcher(infoLine);
if (matcher.find())
{
value = matcher.group();
value = value.substring(1, value.length() - 1);
// create element to be appended to the resource element
appendNewElementToNode("string", "name", key, value, resourceElement,
document);
}
}
// try to match with array string keys
matcher = stringArrayKeyPattern.matcher(infoLine);
if (matcher.find())
{
key = matcher.group();
key = key.split(":array/")[1].split(":")[0];
// go the the next line in order to get the number of
// elements in the array
infoLine = bReader.readLine();
matcher = stringArrayCountPattern.matcher(infoLine);
if (matcher.find())
{
stringArraySizeText = matcher.group();
stringArraySize = Integer.parseInt(stringArraySizeText.split("=")[1]);
// get each string of the array
arrayValue = new String[stringArraySize];
for (int arrayStringIndex = 0; arrayStringIndex < stringArraySize; arrayStringIndex++)
{
try
{
// go the the next line in order to read the
// value
infoLine = bReader.readLine();
matcher = stringValuePattern.matcher(infoLine);
matcher.find();
value = matcher.group();
value = value.substring(1, value.length() - 1);
}
catch (Exception e)
{
// TODO fix this (for now, just keep going, but
// this value may be necessary in the future)
value = "(reference)";
}
arrayValue[arrayStringIndex] = value;
}
// append array-string element
stringElement =
appendNewElementToNode("string-array", "name", key, null,
resourceElement, document);
// create and append the array of strings
for (int arrayStringIndex = 0; arrayStringIndex < stringArraySize; arrayStringIndex++)
{
value = arrayValue[arrayStringIndex];
appendNewElementToNode("item", null, null, value, stringElement,
document);
}
}
}
}
// in case there are a document and file, add it to the map
if ((document != null) && (languageDirectory != null) && (resourceElement != null)
&& (resourceElement.getChildNodes() != null)
&& (resourceElement.getChildNodes().getLength() > 0))
{
map.put(languageDirectory, document);
// reset them
languageDirectory = null;
document = null;
}
}
catch (IOException ioException)
{
PreflightingLogger.error(ApkUtils.class, ioException.getMessage());
throw new PreflightingToolException(ioException.getMessage(), ioException);
}
finally
{
// close resources
if (reader != null)
{
try
{
reader.close();
}
catch (IOException e)
{
//Do Nothing.
}
}
if (bReader != null)
{
try
{
bReader.close();
}
catch (IOException e)
{
//Do Nothing.
}
}
}
return map;
}
/**
* Execute the AAPT command: aapt d --values resources [ApkFile].apk >
* [XMLFileName].xml.
*
* @param aaptPath
* AAPT path.
* @param apkPath
* Target APK File path.
* @param xmlFileName
* XML file name which will be generated.
*
* @return The {@link Process} created the the execution of the AAPT
* command.
*
* @throws IOException
* Exception thrown in case the command execution fails.
*/
private static Process runAAPTCommandForExtractingResourcesAndValues(String aaptPath,
String apkPath, String xmlFileName) throws IOException
{
// execute command: aapt.exe d --values resources <name>.apk <name>.xml
String[] aaptCommand = new String[]
{
aaptPath, "d", "--values", "resources", apkPath, xmlFileName //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
};
return Runtime.getRuntime().exec(aaptCommand);
}
/**
* Put data from {@link Map}, created in method
* {@link #retrieveLocalizationStringsMapFromAPK(String, String, String)}
* into the /res directory using the given parameter {@link File}.
*
* @param map
* {@link Map} which data will be extracted.
* @param resFile
* {@link File} structure which will hold the tree model holding
* directories and translation files.
* @throws PreflightingToolException
*/
private static void createLocalizationFilesFromMap(Map<File, Document> map, File resFile)
throws PreflightingToolException
{
Set<File> fileSet = map.keySet();
File stringFolder = null;
// iterate through all directories
for (File key : fileSet)
{
// create temporary directories
stringFolder = new File(resFile, key.getPath());
if (!stringFolder.exists())
{
stringFolder.mkdirs();
}
// create XML file
createXmlFromDom(map.get(key), new File(resFile.getAbsolutePath() + Path.SEPARATOR
+ key.getPath() + File.separator + "strings.xml"));
}
}
/**
* Create a XML File based on an AAPT output from a APK embedded file.
*
* @param aaptPath
* AAPT path.
* @param apkPath
* APK path.
* @param xmlFileName
* the XML file name which is embedded in the APT and is to be
* created as an XML file.
* @param fileToCreate
* XML file to be created.
*
* @throws PreflightingToolException
* Exception thrown when there are problems creating the XML
* file. The exception message describe in details the problem.
*/
public static void createXMLFile(String aaptPath, String apkPath, String xmlFileName,
File fileToCreate) throws PreflightingToolException
{
// command for AAPT tool which gets the XML-to-be file to be worked on
String[] aaptCommand = new String[]
{
aaptPath, "dump", "xmltree", apkPath, xmlFileName //$NON-NLS-1$ //$NON-NLS-2$
};
// execute AAPT command
Process aapt = null;
try
{
aapt = Runtime.getRuntime().exec(aaptCommand);
}
catch (IOException ioException)
{
PreflightingLogger.error(ApkUtils.class, "Problems executing AAPT command.", //$NON-NLS-1$
ioException);
throw new PreflightingToolException(
PreflightingCoreNLS.ApkUtils_AaptExecutionProblemMessage, ioException);
}
Map<String, String> namespaceMap = new HashMap<String, String>();
Map<Integer, LineElement> map =
readToMap(aapt, aaptPath, apkPath, fileToCreate.getAbsolutePath(), namespaceMap);
if (!map.isEmpty())
{
Integer outerRow = map.keySet().size();
Integer innerRow;
while (outerRow > 0)
{
LineElement childElement = map.get(outerRow);
innerRow = outerRow - 1;
while (innerRow > 0)
{
LineElement parentElement = map.get(innerRow);
if (parentElement.getDepth() < childElement.getDepth())
{
parentElement.addChildLine(outerRow);
break;
}
innerRow--;
}
outerRow--;
}
// create new DOM
Document document = createNewDocument();
// populate it
addNodes(document, map, map.get(1), null);
// add schema
for (String namespace : namespaceMap.keySet())
{
document.getDocumentElement().setAttribute("xmlns:" + namespace,
namespaceMap.get(namespace));
}
// create XML file
createXmlFromDom(document, fileToCreate);
}
}
/**
* generate folder names according to configurations
*
* @param lineRead
* line read from aapt output
* @param folderPrefix
* The first name of all folders.
* @return the directory name
* @throws PreflightingToolException
* Exception thrown when the entered line has a bad format.
*/
private static String createResourcesSubfolders(String lineRead, String folderPrefix)
throws PreflightingToolException
{
Pattern configPattern = Pattern.compile("config\\s[0-9]");
Matcher matcher = null;
StringBuffer strBuf = new StringBuffer(lineRead);
// try to match with type
matcher = configPattern.matcher(strBuf);
if (matcher.find())
{
for (int i = 0; i < 18; i++)
{
matcher = patternArray[i].matcher(strBuf);
if (matcher.find())
{
String result = matcher.group();
String value = result.split("=")[1];
// special treatment
if (localizationAttributesMap2.containsKey(patternArray[i]))
{
String nameSegment =
localizationAttributesMap2.get(patternArray[i]).get(value);
if (nameSegment != null)
{
folderPrefix += "-" + nameSegment;
}
}
else
{
String nameSegment =
localizationAttributesMap1.get(patternArray[i]) + value;
// treat the specific case of height, whose value is
// preceded by x egg. 1024x864
if (i != 16)
{
folderPrefix += "-" + nameSegment;
}
else
{
folderPrefix += nameSegment;
}
}
}
}
}
else
{
PreflightingLogger.error("The entered line has a bad format.");
throw new PreflightingToolException("The entered line has a bad format.");
}
return folderPrefix;
}
/**
* Create a XML file from a {@link Document}.
*
* @param document
* Document to be turned into a XML File.
* @param xmlFile
* XML file which will receive the {@link Document} stream.
*
* @throws PreflightingToolException
* Exception thrown when there are problems creating the XML
* file.
*/
private static void createXmlFromDom(Document document, File xmlFile)
throws PreflightingToolException
{
StreamResult result = null;
DOMSource source = null;
Transformer transformer = null;
FileOutputStream fo = null;
StringWriter sw = null;
try
{
// get factory
TransformerFactory transformerFactory = TransformerFactory.newInstance();
// get transformer and configure it
transformer = transformerFactory.newTransformer();
transformer.setOutputProperty(OutputKeys.ENCODING, "utf-8"); //$NON-NLS-1$
transformer.setOutputProperty(OutputKeys.OMIT_XML_DECLARATION, "no"); //$NON-NLS-1$
transformer.setOutputProperty(OutputKeys.INDENT, "yes"); //$NON-NLS-1$
transformer.setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "4"); //$NON-NLS-1$ //$NON-NLS-2$
// create the XML file
source = new DOMSource(document);
sw = new StringWriter();
result = new StreamResult(sw);
transformer.transform(source, result);
fo = new FileOutputStream(xmlFile);
fo.write(sw.toString().getBytes("utf-8"));
}
catch (Exception ex)
{
//log error, but try to continue validation without the XML file with problem
PreflightingLogger.error(ApkUtils.class, "Problems creating the XML file.", ex); //$NON-NLS-1$
}
finally
{
try
{
// Close streams and stuff
if (fo != null)
{
fo.close();
}
if (result.getWriter() != null)
{
result.getWriter().close();
}
if (sw != null)
{
sw.close();
}
}
catch (IOException e)
{
// do nothing
}
}
}
/**
* Create a new {@link Document}.
*
* @return A newly-created {@link Document} object.
*
* @throws PreflightingToolException
* Exception thrown when there are problems creating a new
* {@link Document}.
*/
private static Document createNewDocument() throws PreflightingToolException
{
DocumentBuilderFactory documentBuilderFactory = DocumentBuilderFactory.newInstance();
DocumentBuilder documentBuilder = null;
try
{
documentBuilder = documentBuilderFactory.newDocumentBuilder();
}
catch (ParserConfigurationException pcException)
{
PreflightingLogger
.error(ApkUtils.class, "Problems creating DOM isntance.", pcException); //$NON-NLS-1$
throw new PreflightingToolException(
PreflightingCoreNLS.ApkUtils_DomInstanceProblemMessage, pcException);
}
// create DOM
Document document = documentBuilder.newDocument();
return document;
}
/**
* Create a Map holding the AAPT XML output info.
*
* @param aaptProccess
* AAPT execution process - its data will be processed here
* @param aaptPath
* APPT path
* @param apkPath
* APK path
* @param xmlFileName
* XML file name
*
* @return The Map holding APPT XML output info.
*
* @throws PreflightingToolException
* Exception thrown in case there are problems reading the APPT
* XML output info from the process.
*/
public static Map<Integer, LineElement> readToMap(Process aaptProccess, String aaptPath,
String apkPath, String xmlFileName, Map<String, String> namespaceMap)
throws PreflightingToolException
{
InputStreamReader reader = new InputStreamReader(aaptProccess.getInputStream());
BufferedReader bReader = new BufferedReader(reader);
// list for the map
List<LineElement> lineList = new ArrayList<LineElement>();
LineElement lineElement;
String infoLine;
try
{
while ((infoLine = bReader.readLine()) != null)
{
if (infoLine.length() > 0)
{
lineElement = new LineElement();
if (infoLine.contains(ELEMENT_NODE) || infoLine.contains(ELEMENT_NODE))
{
lineElement.setType(LineElement.LineType.ELEMENT);
lineElement.setDepth(infoLine.split(ELEMENT_NODE)[0].length());
lineElement.setName(getElementLineName(infoLine));
lineList.add(lineElement);
}
else if (infoLine.contains(ATTRIBUTE_NODE))
{
lineElement.setType(LineElement.LineType.ATTRIBUTE);
lineElement.setDepth(infoLine.split(ATTRIBUTE_NODE)[0].length());
lineElement.setName(getElementLineName(infoLine));
lineElement.setValue(getElementLineValue(aaptPath, apkPath, xmlFileName,
infoLine));
lineList.add(lineElement);
}
else if (infoLine.contains(NAMESPACE_XMLNS))
{
String namespace = infoLine.split(NAMESPACE_XMLNS)[1].trim();
if (namespace.indexOf("=") != -1)
{
String id = namespace.substring(0, namespace.indexOf("="));
String url = namespace.substring(namespace.indexOf("=") + 1);
namespaceMap.put(id, url);
}
}
}
}
}
catch (IOException ioException)
{
PreflightingLogger.error(ApkUtils.class,
"Problems reading AAPT command execution result.", ioException); //$NON-NLS-1$
throw new PreflightingToolException(
PreflightingCoreNLS.ApkUtils_AaptResultReadProblemMessage, ioException);
}
finally
{
// close resources
try
{
if (bReader != null)
{
bReader.close();
}
if (reader != null)
{
reader.close();
}
}
catch (IOException ioException)
{
PreflightingLogger.error(ApkUtils.class,
"Problems reading AAPT command execution result.", ioException); //$NON-NLS-1$
throw new PreflightingToolException(
PreflightingCoreNLS.ApkUtils_AaptResultReadProblemMessage, ioException);
}
}
Map<Integer, LineElement> map = new HashMap<Integer, LineElement>();
Integer counter = 0;
for (LineElement elem : lineList)
{
++counter;
map.put(counter, elem);
}
return map;
}
/**
* Get the Element Line?s Name from a text line. It could either be an
* Element or an Attribute.
*
* @param lineText
* Text Line where the Name will be retrieved.
*
* @return Returns the Name.
*/
private static String getElementLineName(String lineText)
{
Matcher matcher = null;
Pattern pattern = null;
String matchText = null;
String name = null;
// try to match the element pattern
pattern = Pattern.compile("(E: .+ ){1}"); //$NON-NLS-1$
matcher = pattern.matcher(lineText);
// in case there is a match, populate the Line Element object
if (matcher.find())
{
matchText = matcher.group();
name = matchText.split(ELEMENT_NODE)[1].trim();
}
else
{
// try to match the attribute pattern
pattern = Pattern.compile("(A:){1}"); //$NON-NLS-1$
matcher = pattern.matcher(lineText);
if (matcher.find())
{
// since there is an element pattern, get its name
pattern = Pattern.compile("^ *A:\\s*[\\w:\\w]*"); //$NON-NLS-1$
matcher = pattern.matcher(lineText);
if (matcher.find())
{
matchText = matcher.group();
// get the name
name = matchText.split(ATTRIBUTE_NODE)[1];
// adjust it
name = name.trim();
}
}
}
return name;
}
/**
* Try to find the {@link Document} associated with a certain language
* directory path. In case nothing is found, null is returned.
*
* @param map
* {@link Map} in which the search will be made.
* @param languageDirectory
* Directory holding the path to be compared, in order to find
* the {@link Document} in the given {@link Map}. This Object is
* updated with a reference to the object in the {@link Map}.
*
* @return {@link Document} element associated, in case a match is
* successful.
*/
private static Document findDocumentByLanguageDirectory(Map<File, Document> map,
File languageDirectory)
{
Document document = null;
Set<File> languageFolders = map.keySet();
if (languageFolders != null)
{
for (File languageFolder : languageFolders)
{
if (languageFolder.getPath().equals(languageDirectory.getPath()))
{
document = map.get(languageFolder);
languageDirectory = languageFolder;
break;
}
}
}
return document;
}
/**
* Given a certain parent {@link Element} and {@link Document}, append a
* child {@link Element} with Tag Name (which cannot be null), Node
* Attribute Name, Node Attribute Value (which both are null at the same
* time or none is null at all), Node Value (which can be null).
*
* @param nodeTagName
* Node Tag Name.
* @param nodeAttributeName
* Node Attribute Name.
* @param nodeAttributeValue
* Node Attribute Value.
* @param nodeValue
* Node Value.
* @param elementToBeApppendedTo
* Parent {@link Element} which the new created {@link Element}
* will be appended to.
* @param document
* {@link Document} which everything belongs to.
*
* @return Returns the created {@link Element}.
*/
private static Element appendNewElementToNode(String nodeTagName, String nodeAttributeName,
String nodeAttributeValue, String nodeValue, Element elementToBeApppendedTo,
Document document)
{
// create element and append it
Element element = document.createElement(nodeTagName);
if ((nodeAttributeName != null) && (nodeAttributeValue != null))
{
element.setAttribute(nodeAttributeName, nodeAttributeValue);
}
if (nodeValue != null)
{
element.setTextContent(nodeValue);
}
elementToBeApppendedTo.appendChild(element);
return element;
}
/**
* Add all attributes and children in a {@link Document}, given a
* {@link LineElement}.
*
* @param document
* DOM where elements are added.
* @param map
* Map holding all {@link LineElement}s.
* @param elem
* Element to be added to the DOM.
* @param rootElement
* Root element.
*/
private static void addNodes(Document document, Map<Integer, LineElement> map,
LineElement elem, Element rootElement)
{
if (elem.getType() == LineElement.LineType.ELEMENT)
{
// add element or root
Element element = document.createElement(elem.getName());
if (rootElement == null)
{
document.appendChild(element);
}
else
{
rootElement.appendChild(element);
}
// add children
for (Integer childElementMapIndex : elem.getChildLines())
{
LineElement childElement = map.get(childElementMapIndex);
// add all attributes from this node
if (childElement.getType() == LineElement.LineType.ATTRIBUTE)
{
element.setAttribute(childElement.getName(), childElement.getValue());
}
// add a child element
else
{
addNodes(document, map, childElement, element);
}
}
}
}
/**
* Retrieve the Value of an Text line.
*
* @param lineText
* Text line where the value will be retrieved from.
*
* @return Value retrieved.
*/
private static String getElementLineValue(String aaptPath, String apkPath, String xmlFileName,
String lineText)
{
Matcher matcher = null;
Pattern pattern = null;
String matchText = null;
String name = null;
// Get the values, depending on their pattern
// start with Raw values
pattern = Pattern.compile("(\\(Raw: \".*\"\\)){1}"); //$NON-NLS-1$
matcher = pattern.matcher(lineText);
if (matcher.find())
{
matchText = matcher.group();
// get the element within ""
pattern = Pattern.compile("(\".*\"){1}"); //$NON-NLS-1$
matcher = pattern.matcher(matchText);
if (matcher.find())
{
matchText = matcher.group();
name = matchText.replaceAll("\"", "").trim(); //$NON-NLS-1$ //$NON-NLS-2$
}
}
else
{
// get values after @
pattern = Pattern.compile("(\\)=@.*){1}"); //$NON-NLS-1$
matcher = pattern.matcher(lineText);
if (matcher.find())
{
matchText = matcher.group();
name = matchText.replaceAll("\\)=@", "").trim(); //$NON-NLS-1$ //$NON-NLS-2$
name = getResourceMatch(aaptPath, apkPath, xmlFileName, name);
}
else
{
// get values with type
pattern = Pattern.compile("(\\(type .*\\).*){1}"); //$NON-NLS-1$
matcher = pattern.matcher(lineText);
if (matcher.find())
{
matchText = matcher.group();
name = matchText.replaceAll("(\\(type .*\\))", ""); //$NON-NLS-1$ //$NON-NLS-2$
name = name.replace("0x", ""); //$NON-NLS-1$ //$NON-NLS-2$
try
{
long longValue = Long.parseLong(name, 16);
name = Long.toHexString(longValue).trim();
// TODO: correctly handle types instead of doing this kind of verification
if (lineText.contains(ANDROID_SMALL_SCREENS)
|| lineText.contains("android:normalScreens")
|| lineText.contains("android:largeScreens")
|| lineText.contains("android:xlargeScreens")
|| lineText.contains("android:anyDensity")
|| lineText.contains("android:resizeable"))
{
name = longValue == 0 ? "false" : "true";
}
}
catch (NumberFormatException ex)
{
/*
* Do nothing because the number could not be converted
* to an integer. Leave it as it is to put in the XML
* file.
*/
}
}
}
}
return name;
}
/**
* Get the Resource reference from a @x value in the AAPT XML output.
*
* @param aaptPath
* AAPT Path.
* @param apkPath
* APK Path.
* @param xmlFileName
* XML file Name
* @param resourceId
* Resource Id which the value will be retrieved.
*
* @return Value referenced by a resource Id.
*/
private static String getResourceMatch(String aaptPath, String apkPath, String xmlFileName,
String resourceId)
{
xmlFileName = xmlFileName.substring(xmlFileName.indexOf(".tmp") + 5);
// we parse a xml file only once, so we check if its values are already
// stored
if (resourceValues.get(xmlFileName) == null)
{
HashMap<String, String> currentMap = new HashMap<String, String>();
BufferedReader bReader = null;
InputStreamReader reader = null;
try
{
Process aapt =
runAAPTCommandForExtractingResourcesAndValues(aaptPath, apkPath,
xmlFileName);
// read output and store it in a buffer
reader = new InputStreamReader(aapt.getInputStream());
bReader = new BufferedReader(reader);
String infoLine = ""; //$NON-NLS-1$
StringBuffer strBuf = new StringBuffer();
while ((infoLine = bReader.readLine()) != null)
{
strBuf.append(infoLine);
strBuf.append("\n"); //$NON-NLS-1$
}
// apply pattern to retrieve resource id and its value
Pattern pattern =
Pattern.compile("resource\\s[0-9a-fxA-FX]+\\s[a-zA-Z_0-9.]+:[a-z0-9./_]+:"); //$NON-NLS-1$
Matcher matcher = pattern.matcher(strBuf);
Pattern keyPattern = Pattern.compile("\\s[0-9a-fxA-FX]+\\s"); //$NON-NLS-1$
Pattern valuePattern = Pattern.compile(":[a-z0-9./_]+:"); //$NON-NLS-1$
while (matcher.find())
{
String match = matcher.group();
// key matcher
Matcher keyMatcher = keyPattern.matcher(match);
keyMatcher.find();
String key = keyMatcher.group();
key = key.trim();
// aapt output has a resource reference for each
// configuration
// e.g. a drawable resource can present three densities:
// hpdi, mpdi, lpdi
if (!currentMap.containsKey(key))
{
// value matcher
Matcher valueMatcher = valuePattern.matcher(match);
valueMatcher.find();
String value = valueMatcher.group();
value = "@" + value.substring(1, value.length() - 1); //$NON-NLS-1$
currentMap.put(key, value);
}
}
// store in global variable
resourceValues.put(xmlFileName, currentMap);
}
catch (Exception e)
{
PreflightingLogger.error(ApkUtils.class, e.getMessage());
}
finally
{
if (reader != null)
{
try
{
reader.close();
}
catch (IOException e)
{
//Do nothing.
}
}
if (bReader != null)
{
try
{
bReader.close();
}
catch (IOException e)
{
//Do nothing.
}
}
}
}
return resourceValues.get(xmlFileName).get(resourceId);
}
}
/**
* Class which holds each line information from the AAPT XML output.
*/
class LineElement
{
/**
* Enumerator which determines which type of the emement it is to be put in
* the XML file.
*/
public enum LineType
{
ELEMENT, ATTRIBUTE
}
private final List<Integer> childLines = new ArrayList<Integer>();
/**
* Get the list of children indexes.
*
* @return List of children indexes.
*/
public List<Integer> getChildLines()
{
Collections.sort(childLines);
return childLines;
}
/**
* Add a child index representation.
*
* @param index
* Child inex representation.
*/
public void addChildLine(Integer index)
{
childLines.add(index);
}
private LineType type;
/**
* Get the {@link LineType}.
*
* @return The {@link LineType}.
*/
public LineType getType()
{
return type;
}
/**
* Set the {@link LineType}.
*
* @param type
* The {@link LineType}.
*/
public void setType(LineType type)
{
this.type = type;
}
/**
* Get the Name.
*
* @return The name.
*/
public String getName()
{
return name;
}
/**
* Set the Name.
*
* @param name
* The name.
*/
public void setName(String name)
{
this.name = name;
}
/**
* Get the node depth.
*
* @return The node depth.
*/
public int getDepth()
{
return depth;
}
/**
* Set the node depth.
*
* @param depth
* The node depth.
*/
public void setDepth(int depth)
{
this.depth = depth;
}
private String name;
private String value;
/**
* Get the Node value.
*
* @return The node value.
*/
public String getValue()
{
return value;
}
/**
* Set the node value.
*
* @param value
* The node value.
*/
public void setValue(String value)
{
this.value = value;
}
private int depth;
}