/*
* 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.jps.android;
import com.android.sdklib.BuildToolInfo;
import com.android.tools.idea.jps.AndroidTargetBuilder;
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.Processor;
import com.intellij.util.containers.HashMap;
import com.intellij.util.containers.HashSet;
import com.intellij.util.execution.ParametersListUtil;
import org.jetbrains.android.compiler.tools.AndroidDxRunner;
import org.jetbrains.android.util.AndroidBuildTestingManager;
import org.jetbrains.android.util.AndroidCommonUtils;
import org.jetbrains.android.util.AndroidCompilerMessageKind;
import org.jetbrains.annotations.NonNls;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.jps.android.builder.AndroidDexBuildTarget;
import org.jetbrains.jps.android.builder.AndroidPreDexBuildTarget;
import org.jetbrains.jps.android.model.JpsAndroidDexCompilerConfiguration;
import org.jetbrains.jps.android.model.JpsAndroidExtensionService;
import org.jetbrains.jps.android.model.JpsAndroidModuleExtension;
import org.jetbrains.jps.android.model.JpsAndroidSdkProperties;
import org.jetbrains.jps.builders.BuildOutputConsumer;
import org.jetbrains.jps.builders.BuildRootDescriptor;
import org.jetbrains.jps.builders.DirtyFilesHolder;
import org.jetbrains.jps.cmdline.ClasspathBootstrap;
import org.jetbrains.jps.incremental.*;
import org.jetbrains.jps.incremental.messages.BuildMessage;
import org.jetbrains.jps.incremental.messages.CompilerMessage;
import org.jetbrains.jps.incremental.messages.ProgressMessage;
import org.jetbrains.jps.model.JpsProject;
import org.jetbrains.jps.model.JpsSimpleElement;
import org.jetbrains.jps.model.java.JpsJavaSdkType;
import org.jetbrains.jps.model.library.JpsLibrary;
import org.jetbrains.jps.model.library.sdk.JpsSdk;
import org.jetbrains.jps.model.module.JpsModule;
import java.io.File;
import java.io.IOException;
import java.util.*;
/**
* @author Eugene.Kudelevsky
*/
public class AndroidDexBuilder extends AndroidTargetBuilder<BuildRootDescriptor, AndroidDexBuildTarget> {
private static final Logger LOG = Logger.getInstance("#org.jetbrains.jps.android.AndroidDexBuilder");
@NonNls private static final String DEX_BUILDER_NAME = "Android Dex";
@NonNls private static final String PRO_GUARD_BUILDER_NAME = "ProGuard";
public AndroidDexBuilder() {
super(Collections.singletonList(AndroidDexBuildTarget.MyTargetType.INSTANCE));
}
@Override
protected void buildTarget(@NotNull final AndroidDexBuildTarget buildTarget,
@NotNull DirtyFilesHolder<BuildRootDescriptor, AndroidDexBuildTarget> holder,
@NotNull BuildOutputConsumer outputConsumer,
@NotNull CompileContext context) throws ProjectBuildException, IOException {
assert !AndroidJpsUtil.isLightBuild(context);
try {
if (!doDexBuild(buildTarget, context, holder.hasDirtyFiles() || holder.hasRemovedFiles(), outputConsumer)) {
throw new StopBuildException();
}
}
catch (ProjectBuildException e) {
throw e;
}
catch (Exception e) {
AndroidJpsUtil.handleException(context, e, DEX_BUILDER_NAME, LOG);
}
}
private static boolean isPredexingInScope(@NotNull CompileContext context) {
final JpsProject project = context.getProjectDescriptor().getProject();
return context.getScope().isAffected(new AndroidPreDexBuildTarget(project));
}
private static boolean doDexBuild(@NotNull AndroidDexBuildTarget target,
@NotNull CompileContext context,
boolean hasDirtyFiles,
@NotNull BuildOutputConsumer outputConsumer) throws IOException {
final JpsModule module = target.getModule();
final JpsAndroidModuleExtension extension = AndroidJpsUtil.getExtension(module);
assert extension != null;
assert !extension.isLibrary();
final AndroidPlatform platform = AndroidJpsUtil.getAndroidPlatform(module, context, DEX_BUILDER_NAME);
if (platform == null) {
return false;
}
File dexOutputDir = AndroidJpsUtil.getDirectoryForIntermediateArtifacts(context, module);
dexOutputDir = AndroidJpsUtil.createDirIfNotExist(dexOutputDir, context, DEX_BUILDER_NAME);
if (dexOutputDir == null) {
return false;
}
final ProGuardOptions proGuardOptions = AndroidJpsUtil.getProGuardConfigIfShouldRun(context, extension);
if (proGuardOptions != null) {
if (proGuardOptions.getCfgFiles() == null) {
context.processMessage(new CompilerMessage(DEX_BUILDER_NAME, BuildMessage.Kind.ERROR,
AndroidJpsBundle
.message("android.jps.errors.cannot.find.proguard.cfg", module.getName())));
return false;
}
}
final File proguardCfgOutputFile = new File(dexOutputDir, AndroidCommonUtils.PROGUARD_CFG_OUTPUT_FILE_NAME);
final AndroidProGuardStateStorage proGuardOptionsStorage =
context.getProjectDescriptor().dataManager.getStorage(target, AndroidProGuardOptionsStorageProvider.INSTANCE);
final AndroidProGuardStateStorage.MyState oldProGuardState = proGuardOptionsStorage.read();
final Set<String> fileSet;
AndroidProGuardStateStorage.MyState newProGuardState = null;
try {
if (proGuardOptions != null) {
final List<String> proguardCfgFilePathsList = new ArrayList<String>();
for (File file : proGuardOptions.getCfgFiles()) {
proguardCfgFilePathsList.add(file.getAbsolutePath());
}
proguardCfgFilePathsList.add(proguardCfgOutputFile.getPath());
final String[] proguardCfgFilePaths = ArrayUtil.toStringArray(proguardCfgFilePathsList);
final String outputJarPath =
FileUtil.toSystemDependentName(dexOutputDir.getPath() + '/' + AndroidCommonUtils.PROGUARD_OUTPUT_JAR_NAME);
final Pair<Boolean, AndroidProGuardStateStorage.MyState> pair = runProguardIfNecessary(
extension, target, platform, context, outputJarPath, proguardCfgFilePaths,
hasDirtyFiles, oldProGuardState);
if (pair == null) {
// error reported
return false;
}
if (!pair.getFirst()) {
// nothing changed
return true;
}
newProGuardState = pair.getSecond();
assert newProGuardState != null;
fileSet = Collections.singleton(outputJarPath);
}
else {
if (!hasDirtyFiles && oldProGuardState == null) {
return true;
}
final List<BuildRootDescriptor> roots = context.getProjectDescriptor().getBuildRootIndex().getTargetRoots(target, context);
fileSet = new HashSet<String>();
final boolean predexingEnabled = extension.isPreDexingEnabled() && isPredexingInScope(context);
for (BuildRootDescriptor root : roots) {
final File rootFile = root.getRootFile();
if (!rootFile.exists()) {
continue;
}
if (root instanceof AndroidDexBuildTarget.MyClassesDirBuildRootDescriptor) {
final AndroidDexBuildTarget.ClassesDirType type =
((AndroidDexBuildTarget.MyClassesDirBuildRootDescriptor)root).getClassesDirType();
if (type == AndroidDexBuildTarget.ClassesDirType.JAVA) {
fileSet.add(rootFile.getPath());
}
else if (type == AndroidDexBuildTarget.ClassesDirType.ANDROID_APP) {
AndroidJpsUtil.addSubdirectories(rootFile, fileSet);
}
}
else if (root instanceof AndroidDexBuildTarget.MyJarBuildRootDescriptor) {
if (((AndroidDexBuildTarget.MyJarBuildRootDescriptor)root).isPreDexed() == predexingEnabled) {
fileSet.add(rootFile.getPath());
}
}
}
}
final boolean success;
if (fileSet.size() > 0) {
final String[] files = new String[fileSet.size()];
int i = 0;
for (String filePath : fileSet) {
files[i++] = FileUtil.toSystemDependentName(filePath);
}
context.processMessage(new ProgressMessage(AndroidJpsBundle.message("android.jps.progress.dex", module.getName())));
Arrays.sort(files);
success = runDex(platform, dexOutputDir.getPath(), files, context, module, outputConsumer);
}
else {
success = true;
}
if (success) {
proGuardOptionsStorage.update(newProGuardState);
}
return success;
}
catch (IOException e) {
AndroidJpsUtil.reportExceptionError(context, null, e, DEX_BUILDER_NAME);
return false;
}
}
@NotNull
@Override
public String getPresentableName() {
return DEX_BUILDER_NAME;
}
private static boolean runDex(@NotNull AndroidPlatform platform,
@NotNull String outputDir,
@NotNull String[] compileTargets,
@NotNull CompileContext context,
@NotNull JpsModule module,
@NotNull BuildOutputConsumer outputConsumer) throws IOException {
final String outFilePath = outputDir + File.separatorChar + AndroidCommonUtils.CLASSES_FILE_NAME;
return runDex(platform, outFilePath, compileTargets, context, module.getProject(), outputConsumer,
DEX_BUILDER_NAME, module.getName());
}
public static boolean runDex(@NotNull AndroidPlatform platform,
@NotNull String outFilePath,
@NotNull String[] compileTargets,
@NotNull CompileContext context,
@NotNull JpsProject project, @NotNull BuildOutputConsumer outputConsumer,
@NotNull String builderName,
@NotNull String srcTargetName) throws IOException {
BuildToolInfo buildToolInfo = platform.getTarget().getBuildToolInfo();
if (buildToolInfo == null) {
return false;
}
final String dxJarPath = FileUtil.toSystemDependentName(buildToolInfo.getPath(BuildToolInfo.PathId.DX_JAR));
final AndroidBuildTestingManager testingManager = AndroidBuildTestingManager.getTestingManager();
final File dxJar = new File(dxJarPath);
if (testingManager == null && !dxJar.isFile()) {
context.processMessage(
new CompilerMessage(builderName, BuildMessage.Kind.ERROR, AndroidJpsBundle.message("android.jps.cannot.find.file", dxJarPath)));
return false;
}
final List<String> programParamList = new ArrayList<String>();
programParamList.add(dxJarPath);
programParamList.add(outFilePath);
final JpsAndroidDexCompilerConfiguration configuration =
JpsAndroidExtensionService.getInstance().getDexCompilerConfiguration(project);
final List<String> vmOptions;
if (configuration != null) {
vmOptions = new ArrayList<String>();
vmOptions.addAll(ParametersListUtil.parse(configuration.getVmOptions()));
if (!AndroidCommonUtils.hasXmxParam(vmOptions)) {
vmOptions.add("-Xmx" + configuration.getMaxHeapSize() + "M");
}
programParamList.addAll(Arrays.asList("--optimize", Boolean.toString(configuration.isOptimize())));
if (configuration.isForceJumbo()) {
programParamList.addAll(Arrays.asList("--forceJumbo", Boolean.TRUE.toString()));
}
if (configuration.isCoreLibrary()) {
programParamList.add("--coreLibrary");
}
}
else {
vmOptions = Collections.singletonList("-Xmx1024M");
}
programParamList.addAll(Arrays.asList(compileTargets));
programParamList.add("--exclude");
final List<String> classPath = new ArrayList<String>();
classPath.add(ClasspathBootstrap.getResourcePath(AndroidDxRunner.class));
classPath.add(ClasspathBootstrap.getResourcePath(FileUtilRt.class));
final File outFile = new File(outFilePath);
if (outFile.exists() && !outFile.delete()) {
context.processMessage(new CompilerMessage(builderName, BuildMessage.Kind.WARNING,
AndroidJpsBundle.message("android.jps.cannot.delete.file", outFilePath)));
}
final String javaExecutable = getJavaExecutable(platform, context, builderName);
if (javaExecutable == null) {
return false;
}
final List<String> commandLine = ExternalProcessUtil
.buildJavaCommandLine(javaExecutable, AndroidDxRunner.class.getName(),
Collections.<String>emptyList(), classPath, vmOptions, programParamList);
LOG.info(AndroidCommonUtils.command2string(commandLine));
final String[] commands = ArrayUtil.toStringArray(commandLine);
final Process process;
if (testingManager != null) {
process = testingManager.getCommandExecutor().createProcess(
commands, Collections.<String, String>emptyMap());
}
else {
process = Runtime.getRuntime().exec(commands);
}
final HashMap<AndroidCompilerMessageKind, List<String>> messages = new HashMap<AndroidCompilerMessageKind, List<String>>(3);
messages.put(AndroidCompilerMessageKind.ERROR, new ArrayList<String>());
messages.put(AndroidCompilerMessageKind.WARNING, new ArrayList<String>());
messages.put(AndroidCompilerMessageKind.INFORMATION, new ArrayList<String>());
AndroidCommonUtils.handleDexCompilationResult(process, outFilePath, messages);
AndroidJpsUtil.addMessages(context, messages, builderName, srcTargetName);
final boolean success = messages.get(AndroidCompilerMessageKind.ERROR).size() == 0;
if (success) {
final List<String> srcFiles = new ArrayList<String>();
for (String compileTargetPath : compileTargets) {
final File compileTarget = new File(compileTargetPath);
if (compileTarget.isFile()) {
srcFiles.add(compileTargetPath);
}
else if(compileTarget.isDirectory()) {
AndroidJpsUtil.processClassFilesAndJarsRecursively(compileTarget, new Processor<File>() {
@Override
public boolean process(File file) {
if (file.isFile()) {
srcFiles.add(file.getPath());
}
return true;
}
});
}
}
outputConsumer.registerOutputFile(outFile, srcFiles);
}
return success;
}
@Nullable
private static String getJavaExecutable(@NotNull AndroidPlatform platform, @NotNull CompileContext context, @NotNull String builderName) {
final JpsSdk<JpsSimpleElement<JpsAndroidSdkProperties>> sdk = platform.getSdk();
final String jdkName = sdk.getSdkProperties().getData().getJdkName();
final JpsLibrary javaSdk = context.getProjectDescriptor().getModel().getGlobal().getLibraryCollection().findLibrary(jdkName);
if (javaSdk == null || !javaSdk.getType().equals(JpsJavaSdkType.INSTANCE)) {
context.processMessage(new CompilerMessage(builderName, BuildMessage.Kind.ERROR,
AndroidJpsBundle.message("android.jps.errors.java.sdk.not.specified", jdkName)));
return null;
}
return JpsJavaSdkType.getJavaExecutable((JpsSdk<?>)javaSdk.getProperties());
}
private static Pair<Boolean, AndroidProGuardStateStorage.MyState>
runProguardIfNecessary(@NotNull JpsAndroidModuleExtension extension,
@NotNull AndroidDexBuildTarget target,
@NotNull AndroidPlatform platform,
@NotNull CompileContext context,
@NotNull String outputJarPath,
@NotNull String[] proguardCfgPaths,
boolean hasDirtyFiles,
@Nullable AndroidProGuardStateStorage.MyState oldState)
throws IOException {
final JpsModule module = extension.getModule();
final File[] proguardCfgFiles = new File[proguardCfgPaths.length];
for (int i = 0; i < proguardCfgFiles.length; i++) {
proguardCfgFiles[i] = new File(proguardCfgPaths[i]);
if (!proguardCfgFiles[i].exists()) {
context.processMessage(new CompilerMessage(PRO_GUARD_BUILDER_NAME, BuildMessage.Kind.ERROR,
AndroidJpsBundle.message("android.jps.cannot.find.file", proguardCfgPaths[i])));
return null;
}
}
final File mainContentRoot = AndroidJpsUtil.getMainContentRoot(extension);
if (mainContentRoot == null) {
context.processMessage(new CompilerMessage(PRO_GUARD_BUILDER_NAME, BuildMessage.Kind.ERROR, AndroidJpsBundle
.message("android.jps.errors.main.content.root.not.found", module.getName())));
return null;
}
final String javaExecutable = getJavaExecutable(platform, context, PRO_GUARD_BUILDER_NAME);
if (javaExecutable == null) {
return null;
}
final File proguardLogsDir = extension.getProguardLogsDir();
final File logsDir;
if (proguardLogsDir != null) {
logsDir = proguardLogsDir;
}
else {
logsDir = new File(mainContentRoot.getPath() + '/' + AndroidCommonUtils.DIRECTORY_FOR_LOGS_NAME);
}
final AndroidProGuardStateStorage.MyState newState = new AndroidProGuardStateStorage.MyState(
proguardCfgFiles);
if (!hasDirtyFiles && newState.equals(oldState)) {
return Pair.create(false, null);
}
final List<String> classesDirs = new ArrayList<String>();
final List<String> libClassesDirs = new ArrayList<String>();
final List<String> externalJars = new ArrayList<String>();
final List<String> providedJars = new ArrayList<String>();
final List<BuildRootDescriptor> roots = context.getProjectDescriptor().getBuildRootIndex().getTargetRoots(target, context);
for (BuildRootDescriptor root : roots) {
final File rootFile = root.getRootFile();
if (!rootFile.exists()) {
continue;
}
if (root instanceof AndroidDexBuildTarget.MyClassesDirBuildRootDescriptor) {
final AndroidDexBuildTarget.ClassesDirType type =
((AndroidDexBuildTarget.MyClassesDirBuildRootDescriptor)root).getClassesDirType();
if (type == AndroidDexBuildTarget.ClassesDirType.JAVA ||
type == AndroidDexBuildTarget.ClassesDirType.ANDROID_APP) {
AndroidJpsUtil.addSubdirectories(rootFile, classesDirs);
}
else {
AndroidJpsUtil.addSubdirectories(rootFile, libClassesDirs);
}
}
else if (root instanceof AndroidDexBuildTarget.MyJarBuildRootDescriptor) {
final AndroidDexBuildTarget.MyJarBuildRootDescriptor jarRoot =
(AndroidDexBuildTarget.MyJarBuildRootDescriptor)root;
if (!jarRoot.isLibPackage() && !jarRoot.isPreDexed()) {
externalJars.add(rootFile.getPath());
}
}
else if (root instanceof AndroidDexBuildTarget.MyProvidedJarBuildRootDescriptor) {
providedJars.add(rootFile.getPath());
}
}
final String[] classFilesDirOsPaths = ArrayUtil.toStringArray(classesDirs);
final String[] libClassFilesDirOsPaths = ArrayUtil.toStringArray(libClassesDirs);
final String[] externalJarOsPaths = ArrayUtil.toStringArray(externalJars);
final String[] providedJarOsPaths = ArrayUtil.toStringArray(providedJars);
final String inputJarOsPath = AndroidCommonUtils.buildTempInputJar(classFilesDirOsPaths, libClassFilesDirOsPaths);
final AndroidBuildTestingManager testingManager = AndroidBuildTestingManager.getTestingManager();
if (testingManager != null) {
testingManager.getCommandExecutor().checkJarContent("proguard_input_jar", inputJarOsPath);
}
if (!logsDir.exists()) {
if (!logsDir.mkdirs()) {
context.processMessage(new CompilerMessage(
PRO_GUARD_BUILDER_NAME, BuildMessage.Kind.ERROR,
AndroidJpsBundle.message("android.jps.cannot.create.directory", FileUtil.toSystemDependentName(logsDir.getPath()))));
return null;
}
}
final JpsAndroidDexCompilerConfiguration configuration =
JpsAndroidExtensionService.getInstance().getDexCompilerConfiguration(module.getProject());
String proguardVmOptions = configuration != null ? configuration.getProguardVmOptions() : null;
if (proguardVmOptions == null) {
proguardVmOptions = "";
}
context.processMessage(new ProgressMessage(AndroidJpsBundle.message("android.jps.progress.proguard", module.getName())));
final Map<AndroidCompilerMessageKind, List<String>> messages =
AndroidCommonUtils.launchProguard(platform.getTarget(), platform.getSdkToolsRevision(), platform.getSdk().getHomePath(),
javaExecutable, proguardVmOptions, proguardCfgPaths, inputJarOsPath, externalJarOsPaths,
providedJarOsPaths, outputJarPath, logsDir.getPath());
AndroidJpsUtil.addMessages(context, messages, PRO_GUARD_BUILDER_NAME, module.getName());
return messages.get(AndroidCompilerMessageKind.ERROR).isEmpty()
? Pair.create(true, newState) : null;
}
}