/*
* Copyright 2000-2012 JetBrains s.r.o.
*
* 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 org.jetbrains.android.compiler.tools;
import com.android.SdkConstants;
import com.android.sdklib.BuildToolInfo;
import com.android.sdklib.IAndroidTarget;
import com.android.sdklib.internal.build.SymbolLoader;
import com.android.sdklib.internal.build.SymbolWriter;
import com.intellij.openapi.diagnostic.Logger;
import com.intellij.openapi.util.Pair;
import com.intellij.openapi.util.io.FileUtil;
import com.intellij.openapi.util.io.FileUtilRt;
import com.intellij.util.ArrayUtil;
import com.intellij.util.containers.HashMap;
import com.intellij.util.containers.HashSet;
import com.intellij.util.containers.MultiMap;
import com.intellij.util.execution.ParametersListUtil;
import org.jetbrains.android.util.AndroidCommonUtils;
import org.jetbrains.android.util.AndroidCompilerMessageKind;
import org.jetbrains.android.util.AndroidExecutionUtil;
import org.jetbrains.annotations.NonNls;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import java.io.File;
import java.io.FileFilter;
import java.io.IOException;
import java.util.*;
/**
* AndroidApt decorator.
*
* @author Alexey Efimov
*/
public final class AndroidApt {
private static final Logger LOG = Logger.getInstance("#org.jetbrains.android.compiler.tools.AndroidApt");
@NonNls private static final String COMMAND_CRUNCH = "crunch";
@NonNls private static final String COMMAND_PACKAGE = "package";
private static final FileFilter PNG_FILES_FILTER = new FileFilter() {
@Override
public boolean accept(File file) {
return file.isDirectory() || FileUtilRt.extensionEquals(file.getName(), AndroidCommonUtils.PNG_EXTENSION);
}
};
private AndroidApt() {
}
public static Map<AndroidCompilerMessageKind, List<String>> compile(@NotNull IAndroidTarget target,
int platformToolsRevision,
@NotNull String manifestFileOsPath,
@NotNull String aPackage,
@NotNull String outDirOsPath,
@NotNull String[] resourceDirsOsPaths,
@NotNull String[] extraPackages,
boolean nonConstantFields,
@Nullable String proguardCfgOutputFileOsPath) throws IOException {
final List<Pair<String, String>> libRTxtFilesAndPackages = new ArrayList<Pair<String, String>>();
for (String extraPackage : extraPackages) {
libRTxtFilesAndPackages.add(Pair.create((String)null, extraPackage));
}
return compile(target, platformToolsRevision, manifestFileOsPath, aPackage, outDirOsPath, resourceDirsOsPaths,
libRTxtFilesAndPackages, nonConstantFields, proguardCfgOutputFileOsPath, null, false);
}
public static Map<AndroidCompilerMessageKind, List<String>> compile(@NotNull IAndroidTarget target,
int platformToolsRevision,
@NotNull String manifestFileOsPath,
@NotNull String aPackage,
@NotNull String outDirOsPath,
@NotNull String[] resourceDirsOsPaths,
@NotNull List<Pair<String, String>> libRTxtFilesAndPackages,
boolean nonConstantFields,
@Nullable String proguardCfgOutputFileOsPath,
@Nullable String rTxtOutDirOsPath,
boolean optimizeRFile) throws IOException {
final Map<AndroidCompilerMessageKind, List<String>> messages = new HashMap<AndroidCompilerMessageKind, List<String>>();
messages.put(AndroidCompilerMessageKind.ERROR, new ArrayList<String>());
messages.put(AndroidCompilerMessageKind.INFORMATION, new ArrayList<String>());
final File outOsDir = new File(outDirOsPath);
if (!outOsDir.exists()) {
if (!outOsDir.mkdirs()) {
messages.get(AndroidCompilerMessageKind.ERROR).add("Unable to create directory " + outDirOsPath);
}
}
final String packageFolderOsPath = FileUtil.toSystemDependentName(outDirOsPath + '/' + aPackage.replace('.', '/'));
/* We actually need to delete the manifest.java as it may become empty and
in this case aapt doesn't generate an empty one, but instead doesn't
touch it */
final File manifestJavaFile = new File(packageFolderOsPath + File.separatorChar + AndroidCommonUtils.MANIFEST_JAVA_FILE_NAME);
if (manifestJavaFile.exists()) {
if (!FileUtil.delete(manifestJavaFile)) {
messages.get(AndroidCompilerMessageKind.ERROR).add("Unable to delete " + manifestJavaFile.getPath());
}
}
final File rJavaFile = new File(packageFolderOsPath + File.separatorChar + AndroidCommonUtils.R_JAVA_FILENAME);
if (rJavaFile.exists()) {
if (!FileUtil.delete(rJavaFile)) {
messages.get(AndroidCompilerMessageKind.ERROR).add("Unable to delete " + rJavaFile.getPath());
}
}
final File[] extraRJavaFiles = new File[libRTxtFilesAndPackages.size()];
for (int i = 0, n = libRTxtFilesAndPackages.size(); i < n; i++) {
final String libPackage = libRTxtFilesAndPackages.get(i).getSecond();
final String libPackageFolderOsPath = FileUtil.toSystemDependentName(outDirOsPath + '/' + libPackage.replace('.', '/'));
extraRJavaFiles[i] = new File(libPackageFolderOsPath + File.separatorChar + AndroidCommonUtils.R_JAVA_FILENAME);
}
for (File extraRJavaFile : extraRJavaFiles) {
if (extraRJavaFile.exists()) {
if (!FileUtil.delete(extraRJavaFile)) {
messages.get(AndroidCompilerMessageKind.ERROR).add("Unable to delete " + extraRJavaFile.getPath());
}
}
}
if (platformToolsRevision < 0 || platformToolsRevision > 7) {
Map<AndroidCompilerMessageKind, List<String>> map =
doCompile(target, manifestFileOsPath, outDirOsPath, resourceDirsOsPaths, libRTxtFilesAndPackages,
null, nonConstantFields, proguardCfgOutputFileOsPath, rTxtOutDirOsPath, optimizeRFile);
if (map.get(AndroidCompilerMessageKind.ERROR).isEmpty()) {
makeFieldsNotFinal(extraRJavaFiles);
}
AndroidExecutionUtil.addMessages(messages, map);
return messages;
}
else {
messages.get(AndroidCompilerMessageKind.ERROR).add(
"'Platform Tools' package is out of date. Please update it through Android SDK manager");
return messages;
}
}
private static void makeFieldsNotFinal(@NotNull File[] libRJavaFiles) throws IOException {
for (File file : libRJavaFiles) {
if (file.isFile()) {
final String fileContent = AndroidCommonUtils.readFile(file);
FileUtil.writeToFile(file, fileContent.replace("public static final int ", "public static int "));
}
}
}
private static Map<AndroidCompilerMessageKind, List<String>> doCompile(@NotNull IAndroidTarget target,
@NotNull String manifestFileOsPath,
@NotNull String outDirOsPath,
@NotNull String[] resourceDirsOsPaths,
@NotNull List<Pair<String, String>> libRTxtFilesAndPackages,
@Nullable String customPackage,
boolean nonConstantIds,
@Nullable String proguardCfgOutputFileOsPath,
@Nullable String rTxtOutDirOsPath,
boolean optimizeRFile)
throws IOException {
final List<String> args = new ArrayList<String>();
BuildToolInfo buildToolInfo = target.getBuildToolInfo();
if (buildToolInfo == null) {
return Collections.singletonMap(AndroidCompilerMessageKind.ERROR, Collections.singletonList("No Build Tools in the Android SDK."));
}
args.add(buildToolInfo.getPath(BuildToolInfo.PathId.AAPT));
args.add("package");
args.add("-m");
if (nonConstantIds) {
args.add("--non-constant-id");
}
if (resourceDirsOsPaths.length > 1) {
args.add("--auto-add-overlay");
}
final Set<String> extraPackages = new HashSet<String>();
for (Pair<String, String> pair : libRTxtFilesAndPackages) {
extraPackages.add(pair.getSecond());
}
if (extraPackages.size() > 0) {
args.add("--extra-packages");
args.add(toPackagesString(ArrayUtil.toStringArray(extraPackages)));
}
if (customPackage != null) {
args.add("--custom-package");
args.add(customPackage);
}
if (rTxtOutDirOsPath != null) {
args.add("--output-text-symbols");
args.add(rTxtOutDirOsPath);
}
args.add("-J");
args.add(outDirOsPath);
args.add("-M");
args.add(manifestFileOsPath);
for (String libResFolderOsPath : resourceDirsOsPaths) {
args.add("-S");
args.add(libResFolderOsPath);
}
args.add("-I");
args.add(target.getPath(IAndroidTarget.ANDROID_JAR));
if (proguardCfgOutputFileOsPath != null) {
args.add("-G");
args.add(proguardCfgOutputFileOsPath);
}
final Map<AndroidCompilerMessageKind, List<String>> messages = AndroidExecutionUtil.doExecute(ArrayUtil.toStringArray(args));
LOG.info(AndroidCommonUtils.command2string(args));
if (messages.get(AndroidCompilerMessageKind.ERROR).size() > 0) {
return messages;
}
if (optimizeRFile && !libRTxtFilesAndPackages.isEmpty() && rTxtOutDirOsPath != null) {
final File rFile = new File(rTxtOutDirOsPath, SdkConstants.FN_RESOURCE_TEXT);
// if the project has no resources the file could not exist.
if (rFile.isFile()) {
final SymbolLoader fullSymbolValues = new SymbolLoader(rFile);
fullSymbolValues.load();
final MultiMap<String, SymbolLoader> libMap = new MultiMap<String, SymbolLoader>();
for (Pair<String, String> pair : libRTxtFilesAndPackages) {
final File rTextFile = new File(pair.getFirst());
final String libPackage = pair.getSecond();
if (rTextFile.isFile()) {
final SymbolLoader libSymbols = new SymbolLoader(rTextFile);
libSymbols.load();
libMap.putValue(libPackage, libSymbols);
}
}
for (Map.Entry<String, Collection<SymbolLoader>> entry : libMap.entrySet()) {
final String libPackage = entry.getKey();
final Collection<SymbolLoader> symbols = entry.getValue();
final SymbolWriter writer = new SymbolWriter(outDirOsPath, libPackage, fullSymbolValues);
for (SymbolLoader symbolLoader : symbols) {
writer.addSymbolsToWrite(symbolLoader);
}
writer.write();
}
}
}
return messages;
}
@NotNull
private static String toPackagesString(@NotNull String[] packages) {
final StringBuilder builder = new StringBuilder();
for (int i = 0, n = packages.length; i < n; i++) {
if (i > 0) {
builder.append(':');
}
builder.append(packages[i]);
}
return builder.toString();
}
public static Map<AndroidCompilerMessageKind, List<String>> crunch(@NotNull IAndroidTarget target,
@NotNull List<String> resPaths,
@NotNull String outputPath) throws IOException {
BuildToolInfo buildToolInfo = target.getBuildToolInfo();
if (buildToolInfo == null) {
return Collections.singletonMap(AndroidCompilerMessageKind.ERROR, Collections.singletonList("No Build Tools in the Android SDK."));
}
final ArrayList<String> args = new ArrayList<String>();
args.add(buildToolInfo.getPath(BuildToolInfo.PathId.AAPT));
args.add(COMMAND_CRUNCH);
File tempDir = null;
try {
if (resPaths.size() > 0) {
if (resPaths.size() == 1) {
args.add("-S");
args.add(resPaths.get(0));
}
else {
tempDir = FileUtil.createTempDirectory("android_combined_resources", "tmp");
for (int i = resPaths.size() - 1; i >= 0; i--) {
final String resDirPath = resPaths.get(i);
final File resDir = new File(resDirPath);
if (resDir.exists()) {
FileUtil.copyDir(resDir, tempDir, PNG_FILES_FILTER);
}
}
args.add("-S");
args.add(tempDir.getPath());
}
}
args.add("-C");
args.add(outputPath);
LOG.info(AndroidCommonUtils.command2string(args));
return AndroidExecutionUtil.doExecute(ArrayUtil.toStringArray(args));
}
finally {
if (tempDir != null) {
FileUtil.delete(tempDir);
}
}
}
public static Map<AndroidCompilerMessageKind, List<String>> packageResources(@NotNull IAndroidTarget target,
int platformToolsRevision,
@NotNull String manifestPath,
@NotNull String[] resPaths,
@NotNull String[] osAssetDirPaths,
@NotNull String outputPath,
@Nullable String configFilter,
boolean debugMode,
int versionCode,
@Nullable String customManifestPackage,
@Nullable String additionalParameters,
FileFilter assetsFilter) throws IOException {
for (String resDirPath : resPaths) {
if (FileUtil.isAncestor(resDirPath, outputPath, false)) {
throw new IOException("Resource directory " +
FileUtil.toSystemDependentName(resDirPath) +
" contains output " +
FileUtil.toSystemDependentName(outputPath));
}
}
for (String assetsDirPath : osAssetDirPaths) {
if (FileUtil.isAncestor(assetsDirPath, outputPath, false)) {
throw new IOException("Assets directory " +
FileUtil.toSystemDependentName(assetsDirPath) +
" contains output " +
FileUtil.toSystemDependentName(outputPath));
}
}
BuildToolInfo buildToolInfo = target.getBuildToolInfo();
if (buildToolInfo == null) {
return Collections.singletonMap(AndroidCompilerMessageKind.ERROR, Collections.singletonList("No Build Tools in the Android SDK."));
}
final ArrayList<String> args = new ArrayList<String>();
args.add(buildToolInfo.getPath(BuildToolInfo.PathId.AAPT));
args.add(COMMAND_PACKAGE);
for (String path : resPaths) {
args.add("-S");
args.add(path);
}
args.add("-f");
if (platformToolsRevision < 0 || platformToolsRevision > 7) {
args.add("--no-crunch");
}
if (resPaths.length > 1) {
args.add("--auto-add-overlay");
}
if (debugMode) {
args.add("--debug-mode");
}
if (versionCode > 0) {
args.add("--version-code");
args.add(Integer.toString(versionCode));
}
if (configFilter != null) {
args.add("-c");
args.add(configFilter);
}
args.add("-M");
args.add(manifestPath);
File tempDir = null;
try {
if (osAssetDirPaths.length > 0) {
final String[] nonEmptyAssetDirs = getNonEmptyExistingDirs(osAssetDirPaths);
if (nonEmptyAssetDirs.length > 0) {
if (nonEmptyAssetDirs.length == 1) {
args.add("-A");
args.add(nonEmptyAssetDirs[0]);
}
else {
tempDir = FileUtil.createTempDirectory("android_combined_assets", "tmp");
for (int i = nonEmptyAssetDirs.length - 1; i >= 0; i--) {
final String assetDir = nonEmptyAssetDirs[i];
FileUtil.copyDir(new File(assetDir), tempDir, assetsFilter);
}
args.add("-A");
args.add(tempDir.getPath());
}
}
}
args.add("-I");
args.add(target.getPath(IAndroidTarget.ANDROID_JAR));
if (customManifestPackage != null) {
args.add("--rename-manifest-package");
args.add(customManifestPackage);
}
if (additionalParameters != null && additionalParameters.length() > 0) {
args.addAll(ParametersListUtil.parse(additionalParameters));
}
args.add("-F");
args.add(outputPath);
LOG.info(AndroidCommonUtils.command2string(args));
return AndroidExecutionUtil.doExecute(ArrayUtil.toStringArray(args));
}
finally {
if (tempDir != null) {
FileUtil.delete(tempDir);
}
}
}
@NotNull
private static String[] getNonEmptyExistingDirs(@NotNull String[] dirs) {
final List<String> result = new ArrayList<String>();
for (String dirPath : dirs) {
final File dir = new File(dirPath);
if (dir.isDirectory()) {
final File[] children = dir.listFiles();
if (children != null && children.length > 0) {
result.add(dirPath);
}
}
}
return ArrayUtil.toStringArray(result);
}
}