aboutsummaryrefslogtreecommitdiffstats
path: root/anttasks
diff options
context:
space:
mode:
Diffstat (limited to 'anttasks')
-rw-r--r--anttasks/src/com/android/ant/AaptExecTask.java28
-rw-r--r--anttasks/src/com/android/ant/AidlExecTask.java5
-rw-r--r--anttasks/src/com/android/ant/BaseTask.java68
-rw-r--r--anttasks/src/com/android/ant/DependencyGraph.java277
-rw-r--r--anttasks/src/com/android/ant/DexExecTask.java176
5 files changed, 440 insertions, 114 deletions
diff --git a/anttasks/src/com/android/ant/AaptExecTask.java b/anttasks/src/com/android/ant/AaptExecTask.java
index 3e2350f..2c242d3 100644
--- a/anttasks/src/com/android/ant/AaptExecTask.java
+++ b/anttasks/src/com/android/ant/AaptExecTask.java
@@ -323,32 +323,40 @@ public final class AaptExecTask extends BaseTask {
// Get whether we have libraries
Object libResRef = taskProject.getReference(mProjectLibrariesResName);
- // Set up our folders to check for changed files
- ArrayList<File> watchPaths = new ArrayList<File>();
- // We need to watch for changes in the main project res folder
+ // Set up our input paths that matter for dependency checks
+ ArrayList<File> inputPaths = new ArrayList<File>();
+
+ // the project res folder is an input path of course
for (Path pathList : mResources) {
for (String path : pathList.list()) {
- watchPaths.add(new File(path));
+ inputPaths.add(new File(path));
}
}
- // and if libraries exist, in their res folders
+
+ // as is its AndroidManifest.xml
+ if (mManifest != null) {
+ inputPaths.add(new File(mManifest));
+ }
+
+ // and if libraries exist, their res folders folders too.
if (libResRef instanceof Path) {
for (String path : ((Path)libResRef).list()) {
- watchPaths.add(new File(path));
+ inputPaths.add(new File(path));
}
}
- // If we're here to generate a .ap_ file we need to watch assets as well
+
+ // If we're here to generate a .ap_ file we need to use assets as an input path as well.
if (!generateRClass) {
File assetsDir = new File(mAssets);
if (mAssets != null && assetsDir.isDirectory()) {
- watchPaths.add(assetsDir);
+ inputPaths.add(assetsDir);
}
}
// Now we figure out what we need to do
if (generateRClass) {
// Check to see if our dependencies have changed. If not, then skip
- if (initDependencies(mRFolder + File.separator + "R.java.d", watchPaths)
+ if (initDependencies(mRFolder + File.separator + "R.java.d", inputPaths)
&& dependenciesHaveChanged() == false) {
System.out.println("No changed resources. R.java and Manifest.java untouched.");
return;
@@ -362,7 +370,7 @@ public final class AaptExecTask extends BaseTask {
dependencyFilePath += ".d";
// Check to see if our dependencies have changed
- if (initDependencies(dependencyFilePath , watchPaths)
+ if (initDependencies(dependencyFilePath, inputPaths)
&& dependenciesHaveChanged() == false) {
System.out.println("No changed resources or assets. " + mApkName
+ " remains untouched");
diff --git a/anttasks/src/com/android/ant/AidlExecTask.java b/anttasks/src/com/android/ant/AidlExecTask.java
index 98cac9b..1fd5a61 100644
--- a/anttasks/src/com/android/ant/AidlExecTask.java
+++ b/anttasks/src/com/android/ant/AidlExecTask.java
@@ -114,8 +114,7 @@ public class AidlExecTask extends Task {
DependencyGraph graph = new DependencyGraph(depFile, null /*watchPaths*/);
// get the source file. it's the first item in the pre-reqs
- List<File> preReqs = graph.getPrereqs();
- File sourceFile = preReqs.get(0);
+ File sourceFile = graph.getFirstPrereq();
String sourceFilePath = sourceFile.getAbsolutePath();
// The gen folder may contain other dependency files not generated by aidl.
@@ -126,7 +125,7 @@ public class AidlExecTask extends Task {
if (sourceFiles.remove(sourceFilePath) == false) {
// looks like the source file does not exist anymore!
// we'll have to remove the output!
- List<File> outputFiles = graph.getTargets();
+ Set<File> outputFiles = graph.getTargets();
toRemove.addAll(outputFiles);
// also need to remove the dep file.
diff --git a/anttasks/src/com/android/ant/BaseTask.java b/anttasks/src/com/android/ant/BaseTask.java
index 68dd6b5..4eb954b 100644
--- a/anttasks/src/com/android/ant/BaseTask.java
+++ b/anttasks/src/com/android/ant/BaseTask.java
@@ -20,8 +20,10 @@ import org.apache.tools.ant.BuildException;
import org.apache.tools.ant.Task;
import java.io.File;
-import java.util.ArrayList;
+import java.io.FileNotFoundException;
+import java.io.PrintStream;
import java.util.HashSet;
+import java.util.List;
import java.util.Set;
/**
@@ -59,18 +61,14 @@ public abstract class BaseTask extends Task {
}
}
- @Override
- public void execute() throws BuildException {
-
- }
-
/**
- * Set up the dependency graph by passing it the location of the ".d" file
+ * Set up the dependency graph by passing it the location of the ".d" file, and the new input
+ * paths.
* @param dependencyFile path to the dependency file to use
- * @param watchPaths a list of folders to watch for new files
+ * @param the new input paths for this new compilation.
* @return true if the dependency graph was successfully initialized
*/
- protected boolean initDependencies(String dependencyFile, ArrayList<File> watchPaths) {
+ protected boolean initDependencies(String dependencyFile, List<File> inputPaths) {
if (mBuildType != null && mBuildType.equals(mPreviousBuildType) == false) {
// we don't care about deps, we need to execute the task no matter what.
return true;
@@ -78,7 +76,7 @@ public abstract class BaseTask extends Task {
File depFile = new File(dependencyFile);
if (depFile.exists()) {
- mDependencies = new DependencyGraph(dependencyFile, watchPaths);
+ mDependencies = new DependencyGraph(dependencyFile, inputPaths);
return true;
} else {
return false;
@@ -94,9 +92,12 @@ public abstract class BaseTask extends Task {
if (mBuildType != null && mBuildType.equals(mPreviousBuildType) == false) {
String execName = getExecTaskName();
if (execName == null) {
- System.out.println("Current build type is different than previous build: forced task run.");
+ System.out.println(
+ "Current build type is different than previous build: forced task run.");
} else {
- System.out.println("Current build type is different than previous build: forced " + execName + " run.");
+ System.out.println(
+ "Current build type is different than previous build: forced " +
+ execName + " run.");
}
return true;
}
@@ -105,4 +106,47 @@ public abstract class BaseTask extends Task {
return mDependencies.dependenciesHaveChanged(mRestrictTouchedExtensionsTo,
true /*printStatus*/);
}
+
+ protected void generateDependencyFile(String depFilePath,
+ List<File> inputs, String outputFile) {
+ File file = new File(depFilePath);
+
+ try {
+ PrintStream ps = new PrintStream(file);
+
+ // write the output file.
+ ps.print(outputFile);
+ ps.println(" : \\");
+
+ //write the input files
+ int count = inputs.size();
+ for (int i = 0 ; i < count ; i++) {
+ File input = inputs.get(i);
+ if (input.isDirectory()) {
+ writeContent(ps, input);
+ } else {
+ ps.print(input.getAbsolutePath());
+ ps.println(" \\");
+ }
+ }
+
+ ps.close();
+ } catch (FileNotFoundException e) {
+ new BuildException(e);
+ }
+ }
+
+ private void writeContent(PrintStream ps, File input) {
+ File[] files = input.listFiles();
+ if (files != null) {
+ for (File f : files) {
+ if (f.isDirectory()) {
+ writeContent(ps, f);
+ } else {
+ ps.print(f.getAbsolutePath());
+ ps.println(" \\");
+ }
+ }
+ }
+ }
}
diff --git a/anttasks/src/com/android/ant/DependencyGraph.java b/anttasks/src/com/android/ant/DependencyGraph.java
index 11c09e4..7f9c65a 100644
--- a/anttasks/src/com/android/ant/DependencyGraph.java
+++ b/anttasks/src/com/android/ant/DependencyGraph.java
@@ -16,13 +16,15 @@
package com.android.ant;
+import org.apache.tools.ant.BuildException;
+
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
-import java.util.ArrayList;
import java.util.Collections;
+import java.util.HashSet;
import java.util.List;
import java.util.Set;
@@ -33,15 +35,20 @@ import java.util.Set;
*/
public class DependencyGraph {
+ private static enum DependencyStatus {
+ NONE, NEW_FILE, UPDATED_FILE, MISSING_FILE, ERROR;
+ }
+
// Files that we know about from the dependency file
- private List<File> mTargets = Collections.emptyList();
- private List<File> mPrereqs = mTargets;
+ private Set<File> mTargets = Collections.emptySet();
+ private Set<File> mPrereqs = mTargets;
+ private File mFirstPrereq = null;
private boolean mMissingDepFile = false;
private long mDepFileLastModified;
- private final ArrayList<File> mWatchPaths;
+ private final List<File> mNewInputs;
- public DependencyGraph(String dependencyFilePath, ArrayList<File> watchPaths) {
- mWatchPaths = watchPaths;
+ public DependencyGraph(String dependencyFilePath, List<File> newInputPaths) {
+ mNewInputs = newInputPaths;
parseDependencyFile(dependencyFilePath);
}
@@ -55,40 +62,70 @@ public class DependencyGraph {
* prerequisite files have been modified since the last target generation.
*/
public boolean dependenciesHaveChanged(Set<String> extensionsToCheck, boolean printStatus) {
- boolean missingPrereq = missingPrereqFile();
- boolean newPrereq = newPrereqFile();
- boolean missingTarget = missingTargetFile();
- boolean modPrereq = modifiedPrereq(extensionsToCheck);
-
- if (printStatus) {
- if (mMissingDepFile) {
- System.out.println("No Dependency File Found");
- }
- if (missingPrereq) {
- System.out.println("Found Deleted Prereq File");
- }
- if (newPrereq) {
- System.out.println("Found New Prereq File");
- }
- if (missingTarget) {
+ // If no dependency file has been set up, then we'll just return true
+ // if we have a dependency file, we'll check to see what's been changed
+ if (mMissingDepFile) {
+ System.out.println("No Dependency File Found");
+ return true;
+ }
+
+ // check for missing output first
+ if (missingTargetFile()) {
+ if (printStatus) {
System.out.println("Found Deleted Target File");
}
- if (modPrereq) {
- System.out.println("Found Modified Prereq File");
- }
+ return true;
}
- // If no dependency file has been set up, then we'll just return true
- // if we have a dependency file, we'll check to see what's been changed
- return mMissingDepFile || missingPrereq || newPrereq || missingTarget || modPrereq;
+ // get the timestamp of the oldest target.
+ long oldestTarget = getOutputLastModified();
+
+ // first look through the input folders and look for new files or modified files.
+ DependencyStatus status = checkInputs(extensionsToCheck, oldestTarget);
+
+ // this can't find missing files. This is done later.
+ switch (status) {
+ case ERROR:
+ throw new BuildException();
+ case NEW_FILE:
+ if (printStatus) {
+ System.out.println("Found new input file");
+ }
+ return true;
+ case UPDATED_FILE:
+ if (printStatus) {
+ System.out.println("Found modified input file");
+ }
+ return true;
+ }
+
+ // now do a full check on the remaining files.
+ status = checkPrereqFiles(extensionsToCheck, oldestTarget);
+ // this can't find new input files. This is done above.
+ switch (status) {
+ case ERROR:
+ throw new BuildException();
+ case MISSING_FILE:
+ if (printStatus) {
+ System.out.println("Found deleted input file");
+ }
+ return true;
+ case UPDATED_FILE:
+ if (printStatus) {
+ System.out.println("Found modified input file");
+ }
+ return true;
+ }
+
+ return false;
}
- public List<File> getTargets() {
- return mTargets;
+ public Set<File> getTargets() {
+ return Collections.unmodifiableSet(mTargets);
}
- public List<File> getPrereqs() {
- return mPrereqs;
+ public File getFirstPrereq() {
+ return mFirstPrereq;
}
/**
@@ -144,79 +181,157 @@ public class DependencyGraph {
prereqs = files[1].trim().split(" ");
}
- mTargets = new ArrayList<File>(targets.length);
+ mTargets = new HashSet<File>(targets.length);
for (String path : targets) {
if (path.length() > 0) {
mTargets.add(new File(path));
}
}
- mTargets = Collections.unmodifiableList(mTargets);
- mPrereqs = new ArrayList<File>(prereqs.length);
+
+ mPrereqs = new HashSet<File>(prereqs.length);
for (String path : prereqs) {
if (path.length() > 0) {
- mPrereqs.add(new File(path));
+ File f = new File(path);
+ if (mFirstPrereq == null) {
+ mFirstPrereq = f;
+ }
+ mPrereqs.add(f);
}
}
- mPrereqs = Collections.unmodifiableList(mPrereqs);
}
/**
- * Check all the folders we know about to see if there have been new
- * files added to them.
- * @return true if a new file is encountered in the dependency folders
+ * Check all the input files and folders to see if there have been new
+ * files added to them or if any of the existing files have been modified.
+ *
+ * This looks at the input paths, not at the list of known prereq. Therefore this
+ * will not find missing files. It will however remove processed files from the
+ * prereq file list so that we can process those in a 2nd step.
+ *
+ * This should be followed by a call to {@link #checkPrereqFiles(long)} which
+ * will process the remaining files in the prereq list.
+ *
+ * If a change is found, this will return immediatly with either
+ * {@link DependencyStatus#NEW_FILE} or {@link DependencyStatus#UPDATED_FILE}.
+ *
+ * @param extensionsToCheck a set of extensions. Only files with an extension in this set will
+ * be considered for a modification check. All deleted/created files will still be
+ * checked. If this is null, all files will be checked for modification date
+ * @param oldestTarget the timestamp of the oldest output file to compare against.
+ *
+ * @return the status of the file in the watched folders.
+ *
*/
- private boolean newPrereqFile() {
- if (mWatchPaths != null) {
- for (File dir : mWatchPaths) {
- if (newFileInTree(dir)) {
- return true;
+ private DependencyStatus checkInputs(Set<String> extensionsToCheck, long oldestTarget) {
+ if (mNewInputs != null) {
+ for (File input : mNewInputs) {
+ if (input.isDirectory()) {
+ DependencyStatus status = checkInputFolder(input, extensionsToCheck,
+ oldestTarget);
+ if (status != DependencyStatus.NONE) {
+ return status;
+ }
+ } else if (input.isFile()) {
+ DependencyStatus status = checkInputFile(input, extensionsToCheck,
+ oldestTarget);
+ if (status != DependencyStatus.NONE) {
+ return status;
+ }
}
}
}
+
// If we make it all the way through our directories we're good.
- return false;
+ return DependencyStatus.NONE;
}
/**
* Check all the files in the tree under root and check to see if the files are
- * listed under the dependencies. Recurses into subdirs.
- * @param root the root of the file tree to search through
- * @return true if a file is encountered in the tree that is not in our list of prereqs
+ * listed under the dependencies, or if they have been modified. Recurses into subdirs.
+ *
+ * @param rootFolder the folder to search through.
+ * @param extensionsToCheck a set of extensions. Only files with an extension in this set will
+ * be considered for a modification check. All deleted/created files will still be
+ * checked. If this is null, all files will be checked for modification date
+ * @param oldestTarget the timestamp of the oldest output file to compare against.
+ *
+ * @return the status of the file in the folder.
*/
- private boolean newFileInTree(File root) {
- File[] files = root.listFiles();
+ private DependencyStatus checkInputFolder(File rootFolder, Set<String> extensionsToCheck,
+ long oldestTarget) {
+ File[] files = rootFolder.listFiles();
if (files == null) {
- System.err.println("ERROR " + root.toString() + " is not a dir or can't be read");
- return false;
+ System.err.println("ERROR " + rootFolder.toString() + " is not a dir or can't be read");
+ return DependencyStatus.ERROR;
}
// Loop through files in this folder
for (File file : files) {
// If this is a directory, recurse into it
if (file.isDirectory()) {
- if (newFileInTree(file)) {
- return true;
+ DependencyStatus status = checkInputFolder(file, extensionsToCheck, oldestTarget);
+ if (status != DependencyStatus.NONE) {
+ return status;
+ }
+ } else if (file.isFile()) {
+ DependencyStatus status = checkInputFile(file, extensionsToCheck, oldestTarget);
+ if (status != DependencyStatus.NONE) {
+ return status;
}
- } else if (file.isFile() && mPrereqs.contains(file) == false) {
- return true;
}
}
// If we got to here then we didn't find anything interesting
- return false;
+ return DependencyStatus.NONE;
+ }
+
+ private DependencyStatus checkInputFile(File file, Set<String> extensionsToCheck,
+ long oldestTarget) {
+ // if it's a file, remove it from the list of prereqs.
+ // This way if files in this folder don't trigger a build we'll have less
+ // files to go through manually
+ if (mPrereqs.remove(file) == false) {
+ // turns out this is a new file!
+ return DependencyStatus.NEW_FILE;
+ } else {
+ // check the time stamp on this file if it's a file we care about based on the
+ // list of extensions to check.
+ if (extensionsToCheck == null || extensionsToCheck.contains(getExtension(file))) {
+ if (file.lastModified() > oldestTarget) {
+ return DependencyStatus.UPDATED_FILE;
+ }
+ }
+ }
+
+ return DependencyStatus.NONE;
}
/**
- * Check all the prereq files we know about to make sure they're still there
- * @return true if any of the prereq files are missing.
+ * Check all the prereq files we know about to make sure they're still there, or that they
+ * haven't been modified since the last build.
+ *
+ * @param extensionsToCheck a set of extensions. Only files with an extension in this set will
+ * be considered for a modification check. All deleted/created files will still be
+ * checked. If this is null, all files will be checked for modification date
+ *
+ * @return the status of the files
*/
- private boolean missingPrereqFile() {
+ private DependencyStatus checkPrereqFiles(Set<String> extensionsToCheck, long oldestTarget) {
// Loop through our prereq files and make sure they still exist
for (File prereq : mPrereqs) {
if (prereq.exists() == false) {
- return true;
+ return DependencyStatus.MISSING_FILE;
+ }
+
+ // check the time stamp on this file if it's a file we care about based on the
+ // list of extensions to check.
+ if (extensionsToCheck == null || extensionsToCheck.contains(getExtension(prereq))) {
+ if (prereq.lastModified() > oldestTarget) {
+ return DependencyStatus.UPDATED_FILE;
+ }
}
}
- // If we get this far, then all our targets are okay
- return false;
+
+ // If we get this far, then all our prereq are okay
+ return DependencyStatus.NONE;
}
/**
@@ -235,12 +350,10 @@ public class DependencyGraph {
}
/**
- * Check to see if any of the prerequisite files have been modified since
- * the targets were last updated.
- * @return true if the latest prerequisite modification is after the oldest
- * target modification.
+ * Returns the earliest modification time stamp from all the output targets. If there
+ * are no known target, the dependency file time stamp is returned.
*/
- private boolean modifiedPrereq(Set<String> extensionsToCheck) {
+ private long getOutputLastModified() {
// Find the oldest target
long oldestTarget = Long.MAX_VALUE;
// if there's no output, then compare to the time of the dependency file.
@@ -254,20 +367,7 @@ public class DependencyGraph {
}
}
- // Find the newest prerequisite
- long newestPrereq = 0;
- for (File prereq : mPrereqs) {
- // If we have a list of extensions that we need to restrict ourselves to, only
- // consider this file if it has that extension.
- if (extensionsToCheck == null || extensionsToCheck.contains(getExtension(prereq))) {
- if (prereq.lastModified() > newestPrereq) {
- newestPrereq = prereq.lastModified();
- }
- }
- }
-
- // And return the comparison
- return newestPrereq > oldestTarget;
+ return oldestTarget;
}
/**
@@ -296,11 +396,11 @@ public class DependencyGraph {
}
/**
- * Gets the extension (if present) on a file by looking at the filename
- * @param file the file to get the extension of
- * @return the extension if present, or the empty string if the filename doesn't have
- * and extension.
- */
+ * Gets the extension (if present) on a file by looking at the filename
+ * @param file the file to get the extension of
+ * @return the extension if present, or the empty string if the filename doesn't have
+ * and extension.
+ */
private static String getExtension(File file) {
String filename = file.getName();
if (filename.lastIndexOf('.') == -1) {
@@ -309,5 +409,4 @@ public class DependencyGraph {
// Don't include the leading '.' in the extension
return filename.substring(filename.lastIndexOf('.') + 1);
}
-
}
diff --git a/anttasks/src/com/android/ant/DexExecTask.java b/anttasks/src/com/android/ant/DexExecTask.java
new file mode 100644
index 0000000..182ef84
--- /dev/null
+++ b/anttasks/src/com/android/ant/DexExecTask.java
@@ -0,0 +1,176 @@
+/*
+ * Copyright (C) 2011 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.android.ant;
+
+import org.apache.tools.ant.BuildException;
+import org.apache.tools.ant.taskdefs.ExecTask;
+import org.apache.tools.ant.types.FileSet;
+import org.apache.tools.ant.types.Path;
+import org.apache.tools.ant.types.resources.FileResource;
+
+import java.io.File;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+
+/**
+ * Custom task to execute dx while handling dependencies.
+ */
+public class DexExecTask extends BaseTask {
+
+ private String mExecutable;
+ private String mOutput;
+ private boolean mVerbose = false;
+ private boolean mNoLocals = false;
+ private List<Path> mPathInputs;
+ private List<FileSet> mFileSetInputs;
+
+
+ /**
+ * Sets the value of the "executable" attribute.
+ * @param executable the value.
+ */
+ public void setExecutable(Path executable) {
+ mExecutable = TaskHelper.checkSinglePath("executable", executable);
+ }
+
+ /**
+ * Sets the value of the "verbose" attribute.
+ * @param verbose the value.
+ */
+ public void setVerbose(boolean verbose) {
+ mVerbose = verbose;
+ }
+
+ /**
+ * Sets the value of the "output" attribute.
+ * @param output the value.
+ */
+ public void setOutput(Path output) {
+ mOutput = TaskHelper.checkSinglePath("output", output);
+ }
+
+ /**
+ * Sets the value of the "nolocals" attribute.
+ * @param verbose the value.
+ */
+ public void setNoLocals(boolean nolocals) {
+ mNoLocals = nolocals;
+ }
+
+ /**
+ * Returns an object representing a nested <var>path</var> element.
+ */
+ public Object createPath() {
+ if (mPathInputs == null) {
+ mPathInputs = new ArrayList<Path>();
+ }
+
+ Path path = new Path(getProject());
+ mPathInputs.add(path);
+
+ return path;
+ }
+
+ /**
+ * Returns an object representing a nested <var>path</var> element.
+ */
+ public Object createFileSet() {
+ if (mFileSetInputs == null) {
+ mFileSetInputs = new ArrayList<FileSet>();
+ }
+
+ FileSet fs = new FileSet();
+ fs.setProject(getProject());
+ mFileSetInputs.add(fs);
+
+ return fs;
+ }
+
+
+ @Override
+ public void execute() throws BuildException {
+
+ // get all input paths
+ List<File> inputPaths = new ArrayList<File>();
+ if (mPathInputs != null) {
+ for (Path pathList : mPathInputs) {
+ for (String path : pathList.list()) {
+ inputPaths.add(new File(path));
+ }
+ }
+ }
+
+ if (mFileSetInputs != null) {
+ for (FileSet fs : mFileSetInputs) {
+ Iterator<?> iter = fs.iterator();
+ while (iter.hasNext()) {
+ FileResource fr = (FileResource) iter.next();
+ inputPaths.add(fr.getFile());
+ }
+ }
+ }
+
+ // figure out the path to the dependency file.
+ String depFile = mOutput + ".d";
+
+ if (initDependencies(depFile, inputPaths) && dependenciesHaveChanged() == false) {
+ System.out.println(
+ "No new compiled code. No need to convert bytecode to dalvik format.");
+ return;
+ }
+
+ System.out.println(String.format(
+ "Converting compiled files and external libraries into %1$s...", mOutput));
+
+ ExecTask task = new ExecTask();
+ task.setProject(getProject());
+ task.setOwningTarget(getOwningTarget());
+ task.setExecutable(mExecutable);
+ task.setTaskName(getExecTaskName());
+ task.setFailonerror(true);
+
+ task.createArg().setValue("--dex");
+
+ if (mNoLocals) {
+ task.createArg().setValue("--no-locals");
+ }
+
+ if (mVerbose) {
+ task.createArg().setValue("--verbose");
+ }
+
+ task.createArg().setValue("--output");
+ task.createArg().setValue(mOutput);
+
+
+ for (File f :inputPaths) {
+ task.createArg().setValue(f.getAbsolutePath());
+ }
+
+ // execute it.
+ task.execute();
+
+ // generate the dependency file.
+ generateDependencyFile(depFile, inputPaths, mOutput);
+ }
+
+ @Override
+ protected String getExecTaskName() {
+ return "dx";
+ }
+}