Simplify ant targets

build/android/ant/apk-build.xml

 <?xml version="1.0" encoding="UTF-8"?>
 <!--
     Copyright (C) 2005-2008 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
 
@@ skipping 120 matching lines @@
 
     <!-- Custom tasks -->
     <taskdef resource="anttasks.properties" classpathref="android.antlibs" />
 
     <!-- ******************************************************* -->
     <!-- ******************* Other Properties ****************** -->
     <!-- ******************************************************* -->
     <!-- overriding these properties may break the build
          unless the whole file is updated -->
 
+    <target name="-set-release-mode">
+        <!-- record the current build target -->
+        <property name="build.target" value="release" />
+
+        <!-- release mode is only valid if the manifest does not explicitly
+             set debuggable to true. default is false. -->
+        <xpath input="${manifest.abs.file}" expression="/manifest/application/@android:debuggable"
+                output="build.is.packaging.debug" default="false"/>
+
+        <if condition="${build.is.packaging.debug}">
+            <then>
+                <echo>*************************************************</echo>
+                <echo>****  Android Manifest has debuggable=true   ****</echo>
+                <echo>**** Doing DEBUG packaging with RELEASE keys ****</echo>
+                <echo>*************************************************</echo>
+            </then>
+            <else>
+                <!-- property only set in release mode.
+                     Useful for if/unless attributes in target node
+                     when using Ant before 1.8 -->
+                <property name="build.is.mode.release" value="true"/>
+            </else>
+        </if>
+
+        <echo level="info">proguard.config is ${proguard.config}</echo>
+        <condition property="proguard.enabled" value="true" else="false">
+            <and>
+                <isset property="build.is.mode.release" />
+                <isset property="proguard.config" />
+            </and>
+        </condition>
+        <if condition="${proguard.enabled}">
+            <then>
+                <echo level="info">Proguard.config is enabled</echo>
+                <!-- Secondary dx input (jar files) is empty since all the
+                     jar files will be in the obfuscated jar -->
+                <path id="out.dex.jar.input.ref" />
+            </then>
+        </if>
+    </target>
+
+    <target name="-set-debug-mode">
+        <!-- record the current build target -->
+        <property name="build.target" value="debug" />
+
+        <!-- whether the build is a debug build. always set. -->
+        <property name="build.is.packaging.debug" value="true" />
+
+        <!-- proguard is never enabled in debug mode -->
+        <property name="proguard.enabled" value="false"/>
+    </target>
+
+
     <!-- Input directories -->
     <property name="source.dir" value="src" />
     <property name="source.absolute.dir" location="${source.dir}" />
     <property-value name="gen.absolute.dir" value="${out.dir}/gen"/>
     <property name="resource.absolute.dir" value="${RESOURCE_DIR}"/>
     <property name="asset.dir" value="assets" />
     <condition property="asset.absolute.dir"
         value="${out.dir}/assets"
         else="${ASSET_DIR}">
       <equals arg1="${ASSET_DIR}" arg2=""/>
     </condition>
 
-    <property name="jar.libs.dir" value="libs" />
-    <property name="jar.libs.absolute.dir" location="${jar.libs.dir}" />
     <property-location name="native.libs.absolute.dir" location="${out.dir}/libs"
         check-exists="false"/>
 
     <property name="manifest.file" value="AndroidManifest.xml" />
     <property name="manifest.abs.file" location="${manifest.file}" />
 
     <!-- Output directories -->
     <property name="out.dir" value="bin" />
     <property name="out.absolute.dir" location="${out.dir}" />
     <property name="out.classes.absolute.dir" location="${out.dir}/classes" />
@@ skipping 33 matching lines @@
 
     <!-- properties for packaging -->
     <property name="build.packaging.nocrunch" value="true" />
 
     <property name="need.javac.fork" value="false" />
 
     <!-- ******************************************************* -->
     <!-- ******************** Build Targets ******************** -->
     <!-- ******************************************************* -->
 
-    <!-- Basic Ant + SDK check -->
-    <target name="-check-env">
+    <!-- generic setup -->
+    <target name="-setup">
         <checkenv />
-    </target>
-
-    <!-- generic setup -->
-    <target name="-setup" depends="-check-env">
         <echo level="info">Project Name: ${ant.project.name}</echo>
         <gettype projectTypeOut="project.type" />
 
         <!-- sets a few boolean based on project.type
              to make the if task easier -->
         <condition property="project.is.testapp" value="true" else="false">
             <equals arg1="${project.type}" arg2="test-app" />
         </condition>
 
         <!-- get the project manifest package -->
         <xpath input="${manifest.abs.file}"
                 expression="/manifest/@package" output="project.app.package" />
-    </target>
-
-    <!-- Pre build setup -->
-    <target name="-build-setup" depends="-setup">
 
         <!-- read the previous build mode -->
         <property file="${out.build.prop.file}" />
 
         <echo level="info">Resolving Build Target for ${ant.project.name}...</echo>
         <!-- load project properties, resolve Android target, library dependencies
              and set some properties with the results.
              All property names are passed as parameters ending in -Out -->
         <gettarget
                 androidJarFileOut="project.target.android.jar"
                 androidAidlFileOut="project.target.framework.aidl"
                 bootClassPathOut="project.target.class.path"
                 targetApiOut="project.target.apilevel"
                 minSdkVersionOut="project.minSdkVersion" />
 
         <property name="manifest.hasCode" value="true" />
 
-
         <echo level="info">----------</echo>
         <echo level="info">Creating output directories if needed...</echo>
-        <mkdir dir="${resource.absolute.dir}" />
-        <mkdir dir="${jar.libs.absolute.dir}" />
         <mkdir dir="${out.absolute.dir}" />
         <mkdir dir="${out.res.absolute.dir}" />
         <mkdir dir="${gen.absolute.dir}" />
         <mkdir dir="${out.classes.absolute.dir}" />
         <mkdir dir="${out.dexed.absolute.dir}" />
     </target>
 
-    <!-- empty default pre-build target. Create a similar target in
-         your build.xml and it'll be called instead of this one. -->
-    <target name="-pre-build"/>
-
     <!-- Code Generation: compile resources (aapt -> R.java), aidl -->
-    <target name="-code-gen">
+    <target name="-code-gen" depends="-setup">
         <!-- always merge manifest -->
         <mergemanifest
                 appManifest="${manifest.abs.file}"
                 outManifest="${out.manifest.abs.file}"
                 enabled="${manifestmerger.enabled}">
         </mergemanifest>
 
         <echo level="info">----------</echo>
         <echo level="info">Handling Resources...</echo>
         <aapt executable="${aapt}"
                 command="package"
                 verbose="${verbose}"
                 manifest="${out.manifest.abs.file}"
                 androidjar="${project.target.android.jar}"
                 rfolder="${gen.absolute.dir}"
                 nonConstantId="${android.library}"
                 libraryResFolderPathRefid="project.library.res.folder.path"
                 libraryPackagesRefid="project.library.packages"
                 libraryRFileRefid="project.library.bin.r.file.path"
                 ignoreAssets="${aapt.ignore.assets}"
                 binFolder="${out.absolute.dir}"
                 proguardFile="${out.absolute.dir}/proguard.txt">
             <res path="${out.res.absolute.dir}" />
             <res path="${resource.absolute.dir}" />
         </aapt>
 
-        <echo level="info">----------</echo>
-        <echo level="info">Handling BuildConfig class...</echo>
-        <buildconfig
-                genFolder="${gen.absolute.dir}"
-                package="${project.app.package}"
-                buildType="${build.is.packaging.debug}"
-                previousBuildType=""/>
-    </target>
-
-    <!-- empty default pre-compile target. Create a similar target in
-         your build.xml and it'll be called instead of this one. -->
-    <target name="-pre-compile">
-      <!--
-        Remove all .class files from the output directory. This prevents inclusion of incorrect .class
-        files in the final apk. For example, if a .java file was deleted, the apk should not contain
-        the .class files for that .java from previous builds.
-      -->
-      <delete>
-        <fileset dir="${out.classes.absolute.dir}" includes="**/*.class"/>
-      </delete>
     </target>
 
     <!--
       Override the -compile target.
       This target requires 'javac.custom.classpath' to be set to reference
       of classpath to be used for javac. Also accepts custom path for
       sources: 'javac.custom.sourcepath'.
     -->
     <!-- Compiles this project's .java files into .class files. -->
-    <target
-        name="-compile"
-        depends="-build-setup, -pre-build, -code-gen, -pre-compile">
+    <target name="-compile" depends="-code-gen">
+      <delete>
+        <fileset dir="${out.classes.absolute.dir}" includes="**/*.class"/>
+      </delete>
+
       <javac
           bootclasspathref="project.target.class.path"
           classpathref="javac.custom.classpath"
           debug="true"
           destdir="${out.classes.absolute.dir}"
           encoding="${java.encoding}"
           extdirs=""
           fork="${need.javac.fork}"
           includeantruntime="false"
           source="${java.source}"
@@ skipping 13 matching lines @@
         project.is.testapp is set by Android's ant build system based on the
         target's manifest. It is true only for instrumentation apks.
       -->
       <if condition="${project.is.testapp}">
         <then>
           <property-location name="create.test.jar.file"
               location="${CHROMIUM_SRC}/build/android/ant/create-test-jar.js"/>
           <script language="javascript" src="${create.test.jar.file}"/>
         </then>
       </if>
-    </target>
-
-    <!-- empty default post-compile target. Create a similar target in
-         your build.xml and it'll be called instead of this one. -->
-    <target name="-post-compile">
       <!--
         Copy gdbserver to main libs directory if building a non-instrumentation debug apk.
       -->
       <if>
         <condition>
           <and>
             <equals arg1="${build.target}" arg2="debug"/>
             <isfalse value="${project.is.testapp}"/>
           </and>
         </condition>
@@ skipping 14 matching lines @@
 
     <!-- Obfuscate target
         This is only active in release builds when proguard.config is defined
         in default.properties.
 
     -->
     <!--
       Override obfuscate target to pass javac.custom.classpath to Proguard. SDK tools do not provide
       any way to pass custom class paths to Proguard.
      -->
-    <target name="-obfuscate">
+    <target name="-obfuscate" depends="-compile">
       <if condition="${proguard.enabled}">
         <then>
           <property name="obfuscate.absolute.dir" location="${out.absolute.dir}/proguard"/>
           <property name="preobfuscate.jar.file" value="${obfuscate.absolute.dir}/original.jar"/>
           <property name="obfuscated.jar.file" value="${obfuscate.absolute.dir}/obfuscated.jar"/>
           <!-- input for dex will be proguard's output -->
           <property name="out.dex.input.absolute.dir" value="${obfuscated.jar.file}"/>
 
           <!-- Add Proguard Tasks -->
           <property name="proguard.jar" location="${android.tools.dir}/proguard/lib/proguard.jar"/>
@@ skipping 55 matching lines @@
             -dump         "${obfuscate.absolute.dir}/dump.txt"
             -printseeds   "${obfuscate.absolute.dir}/seeds.txt"
             -printusage   "${obfuscate.absolute.dir}/usage.txt"
             -printmapping "${obfuscate.absolute.dir}/mapping.txt"
           </proguard>
         </then>
       </if>
     </target>
 
     <!-- Converts this project's .class files into .dex files -->
-    <target name="-dex" depends="-compile, -post-compile, -obfuscate">
+    <target name="-dex" depends="-obfuscate">
         <sequential>
             <!-- sets the primary input for dex. If a pre-dex task sets it to
                  something else this has no effect -->
             <property name="out.dex.input.absolute.dir" value="${out.classes.absolute.dir}" />
             <property name="dex.force.jumbo" value="false" />
 
             <dex executable="${dx}"
                     output="${intermediate.dex.file}"
                     dexedlibs="${out.dexed.absolute.dir}"
                     nolocals="false"
                     forceJumbo="${dex.force.jumbo}"
                     verbose="${verbose}">
                 <path path="${out.dex.input.absolute.dir}"/>
                 <path refid="out.dex.jar.input.ref" />
             </dex>
         </sequential>
     </target>
 
-    <!-- Updates the pre-processed PNG cache -->
-    <target name="-crunch">
+    <!-- Puts the project's resources into the output package file
+         This actually can create multiple resource package in case
+         Some custom apk with specific configuration have been
+         declared in default.properties.
+         -->
+    <target name="-package-resources" depends="-setup">
+        <!-- Updates the pre-processed PNG cache -->
         <exec executable="${aapt}" taskName="crunch">
             <arg value="crunch" />
             <arg value="-v" />
             <arg value="-S" />
             <arg path="${resource.absolute.dir}" />
             <arg value="-C" />
             <arg path="${out.res.absolute.dir}" />
         </exec>
-    </target>
-
-    <!-- Puts the project's resources into the output package file
-         This actually can create multiple resource package in case
-         Some custom apk with specific configuration have been
-         declared in default.properties.
-         -->
-    <target name="-package-resources" depends="-crunch">
         <aapt executable="${aapt}"
                 command="package"
                 versioncode="${version.code}"
                 versionname="${version.name}"
                 debug="${build.is.packaging.debug}"
                 manifest="${out.manifest.abs.file}"
                 assets="${asset.absolute.dir}"
                 androidjar="${project.target.android.jar}"
                 apkfolder="${out.absolute.dir}"
                 nocrunch="${build.packaging.nocrunch}"
@@ skipping 23 matching lines @@
                 verbose="${verbose}"
                 hascode="${manifest.hasCode}"
                 previousBuildType="/"
                 buildType="${build.is.packaging.debug}/${build.is.signing.debug}">
             <dex path="${intermediate.dex.file}"/>
             <sourcefolder path="${source.absolute.dir}"/>
             <nativefolder path="${native.libs.absolute.dir}" />
         </apkbuilder>
     </target>
 
-    <target name="-post-package" />
-    <target name="-post-build" />
-
-    <target name="-set-mode-check">
-    </target>
-
-    <!-- ******************************************************* -->
-    <!-- **************** Debug specific targets *************** -->
-    <!-- ******************************************************* -->
-
-    <target name="-set-debug-files" depends="-set-mode-check">
-    </target>
-
-
-    <target name="-set-debug-mode" depends="-setup">
-        <!-- record the current build target -->
-        <property name="build.target" value="debug" />
-
-        <property name="build.is.instrumented" value="false" />
-
-        <!-- whether the build is a debug build. always set. -->
-        <property name="build.is.packaging.debug" value="true" />
-
-        <!-- signing mode: debug -->
-        <property name="build.is.signing.debug" value="true" />
-    </target>
-
-    <target name="-debug-obfuscation-check">
-        <!-- proguard is never enabled in debug mode -->
-        <property name="proguard.enabled" value="false"/>
-    </target>
-
     <!-- Signs and zipaligns the apk. -->
-    <target name="-do-sign"
-        depends="-package, -post-package">
+    <target name="-do-sign" depends="-package">
       <sequential>
         <echo level="info">Signing final apk...</echo>
         <signapk
                 input="${out.packaged.file}"
                 output="${out.unaligned.file}"
                 keystore="${key.store}"
                 storepass="${key.store.password}"
                 alias="${key.alias}"
                 keypass="${key.alias.password}"/>
 
         <zipalign
                 executable="${zipalign}"
                 input="${out.unaligned.file}"
                 output="${out.final.file}"
                 verbose="${verbose}" />
         <echo level="info">Release Package: ${out.final.file}</echo>
       </sequential>
     </target>
 
-    <target name="-do-debug"
-      depends="-set-debug-mode, -debug-obfuscation-check, -do-sign">
-    </target>
-
     <!-- Builds debug output package -->
-    <target name="debug" depends="-set-debug-files, -do-debug, -post-build"
-                description="Builds the application and signs it with a debug key.">
-    </target>
-
-    <!-- ******************************************************* -->
-    <!-- *************** Release specific targets ************** -->
-    <!-- ******************************************************* -->
-
-    <target name="-release-obfuscation-check">
-        <echo level="info">proguard.config is ${proguard.config}</echo>
-        <condition property="proguard.enabled" value="true" else="false">
-            <and>
-                <isset property="build.is.mode.release" />
-                <isset property="proguard.config" />
-            </and>
-        </condition>
-        <if condition="${proguard.enabled}">
-            <then>
-                <echo level="info">Proguard.config is enabled</echo>
-                <!-- Secondary dx input (jar files) is empty since all the
-                     jar files will be in the obfuscated jar -->
-                <path id="out.dex.jar.input.ref" />
-            </then>
-        </if>
-    </target>
-
-    <target name="-set-release-mode" depends="-set-mode-check">
-        <!-- record the current build target -->
-        <property name="build.target" value="release" />
-
-        <property name="build.is.instrumented" value="false" />
-
-        <!-- release mode is only valid if the manifest does not explicitly
-             set debuggable to true. default is false. -->
-        <xpath input="${manifest.abs.file}" expression="/manifest/application/@android:debuggable"
-                output="build.is.packaging.debug" default="false"/>
-
-        <!-- signing mode: release -->
-        <property name="build.is.signing.debug" value="false" />
-
-        <if condition="${build.is.packaging.debug}">
-            <then>
-                <echo>*************************************************</echo>
-                <echo>****  Android Manifest has debuggable=true   ****</echo>
-                <echo>**** Doing DEBUG packaging with RELEASE keys ****</echo>
-                <echo>*************************************************</echo>
-            </then>
-            <else>
-                <!-- property only set in release mode.
-                     Useful for if/unless attributes in target node
-                     when using Ant before 1.8 -->
-                <property name="build.is.mode.release" value="true"/>
-            </else>
-        </if>
-    </target>
-
-    <target name="-release-sign" depends="-do-sign" >
+    <target name="debug"
+            depends="-set-debug-mode, -do-sign"
+            description="Builds the application and signs it with a debug key.">
     </target>
 
     <!-- This runs -package-release first and then runs
          only if release-sign is true (set in -release-check,
          called by -release-no-sign)-->
     <target name="release"
-                depends="-set-release-mode, -release-obfuscation-check, -package, -post-package, -release-sign, -post-build"
-                description="Builds the application in release mode.">
+            depends="-set-release-mode, -do-sign"
+            description="Builds the application in release mode.">
     </target>
 
 </project>