antlib.xml

<?xml version="1.0"?>
<!-- =========================================================================
  Copyright 2013-2016 Rectangular Software Ltd.
  Copyright 2008-2013 Daniel W. Dyer

  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.
========================================================================== -->
<antlib xmlns:current="ant:current" xmlns:if="ant:if" xmlns:unless="ant:unless">

  <taskdef name="once" classname="com.rectangularsoftware.antlib.tasks.Once" />
  <taskdef name="installapk" classname="com.rectangularsoftware.antlib.tasks.InstallAPK" />

  <macrodef name="defaults">
    <sequential>
      <current:once property="rectangular-antlib.defaults">
        <property file="local.properties" />

        <antversion property="required.version" atleast="1.9.1"/>
        <fail unless="required.version"
              message="Rectangular Antlib requires Apache Ant 1.9.1 or later. Current version: ${ant.version}."/>
        <fail unless="sdk.dir"
              message="Rectangular Antlib requires the sdk.dir property to be to set to the location of the Android SDK." />
        <fail unless="target"
              message="Rectangular Antlib requires the target property to be to set to the required Android platform version (e.g. android-18)." />

        <!-- Find the most recent version of the Android build tools to use. -->
        <pathconvert property="build.tools.dir">
          <last count="1">
            <sort>
              <dirset dir="${sdk.dir}/build-tools" includes="*"/>
            </sort>
          </last>
        </pathconvert>

        <!-- By default, src, res, assets and other Android directories/files are assumed to
             be in the project root.  Setting this property overrides that.  This is useful, for
             example, if you have some preliminary step that assembles the app files from
             multiple locations (e.g. for an app with two versions, the preliminary step could
             combine common files and version-specific files in a single tree rooted at this
             location). -->
        <property name="app.root" value="." />

        <property name="src.dir" value="${app.root}/src" />
        <property name="java.dir" value="${src.dir}/java" />
        <property name="build.dir" value="./build"/>
        <property name="classes.dir" value="${build.dir}/classes" />
        <property name="generated.dir" value="${build.dir}/generated" />
        <property name="lib.compiletime" value="./lib/compiletime" />
        <property name="lib.runtime" value="${app.root}/lib/runtime" />
        <property name="docs.dir" value="./docs"/>
        <property name="api.dir" value="${docs.dir}/api"/>
        <property name="coverage.dir" value="${docs.dir}/coverage" />
        <property name="test-results.dir" value="${docs.dir}/test-results" />
        <property name="cobertura.dir" value="${build.dir}/cobertura" />
        <property name="encoding" value="utf-8" />

        <property name="resource.dir" value="${app.root}/res" />
        <property name="asset.dir" value="${app.root}/assets" />
        <property name="target.dir" value="${sdk.dir}/platforms/${target}" />
        <path id="android.antlibs">
          <pathelement path="${sdk.dir}/tools/lib/ant-tasks.jar" />
          <pathelement path="${sdk.dir}/tools/lib/sdklib.jar" />
          <pathelement path="${sdk.dir}/tools/lib/androidprefs.jar" />
        </path>
        <condition property="dx.executable" value="dx.bat" else="dx">
          <os family="windows" />
        </condition>
        <taskdef name="apkbuilder" classname="com.android.ant.ApkBuilderTask" classpathref="android.antlibs" />
        <taskdef name="aidl" classname="com.android.ant.AidlExecTask" classpathref="android.antlibs" />
      </current:once>
    </sequential>
  </macrodef>


  <!-- This macro deletes all build artifacts from a project. -->
  <macrodef name="clean">
    <sequential>
      <current:defaults />
      <delete dir="${docs.dir}" />
      <delete dir="${build.dir}"/>
    </sequential>
  </macrodef>

  
  <!-- This macro compiles one source tree (i.e. the main source tree
       or the unit test source tree) of a project. -->
  <macrodef name="compile.tree">
    <attribute name="tree"/>
    <attribute name="source"/>
    <attribute name="target"/>
    <attribute name="bootclasspath"/>
    <element name="treeclasspath" optional="true"/>
    <sequential>
      <current:defaults />
      <mkdir dir="${classes.dir}/@{tree}" />
      <!-- If there is no generated code to compile, we still need the directory to look at. -->
      <mkdir dir="${generated.dir}/@{tree}" />
      <javac destdir="${classes.dir}/@{tree}"
             debug="on"
             deprecation="on"
             optimize="on"
             source="@{source}"
             target="@{target}"
             bootclasspath="@{bootclasspath}"
             srcdir="${java.dir}/@{tree}:${generated.dir}/@{tree}"
             encoding="${encoding}"
             includeantruntime="false">
        <classpath>
          <treeclasspath/>
          <fileset dir="${lib.runtime}" includes="**/*.jar" erroronmissingdir="false" />
          <fileset dir="${lib.compiletime}" includes="**/*.jar" erroronmissingdir="false" />
        </classpath>
        <compilerarg value="-Xlint:unchecked" />
      </javac>
    </sequential>
  </macrodef>


  <!-- This macro compiles all source (including unit tests) for a project.  -->
  <macrodef name="compile">
    <attribute name="source" default="1.6"/>
    <attribute name="target" default="1.6"/>
    <sequential>
      <current:defaults />

      <current:compile.tree tree="main"
                            source="@{source}"
                            target="@{target}"
                            bootclasspath="${target.dir}/android.jar" />
      <condition property="has.tests">
        <available file="${java.dir}/test" />
      </condition>
      <sequential if:true="${has.tests}">
        <current:compile.tree tree="test"
                              source="@{source}"
                              target="@{target}"
                              bootclasspath="${target.dir}/android.jar">
          <treeclasspath>
            <!-- Add the main classes to the classpath for unit test compilation. -->
            <path location="${classes.dir}/main" />
          </treeclasspath>
        </current:compile.tree>
      </sequential>
    </sequential>
  </macrodef>


  <!-- Shrink and obfuscate the project class files. -->
  <macrodef name="obfuscate">
    <attribute name="defaultpackage" default=""/>
    <attribute name="printmapping" default="${build.dir}/mapping.txt"/>
    <attribute name="config" default=""/>
    <element name="additionalclasspath" optional="true"/>
    <sequential>
      <taskdef resource="proguard/ant/task.properties" classpath="${lib.compiletime}/proguard/proguard.jar" />
      <proguard shrink="true"
                obfuscate="true"
                optimize="true"
                usemixedcaseclassnames="true"
                allowaccessmodification="true"
                skipnonpubliclibraryclassmembers="false"
                overloadaggressively="false"
                printmapping="@{printmapping}"
                defaultpackage="@{defaultpackage}">
        <libraryjar path="${target.dir}/android.jar" />
        <libraryjar>
          <fileset dir="${lib.runtime}" includes="**/*.jar" erroronmissingdir="false"/>
        </libraryjar>
        <libraryjar>
          <additionalclasspath />
        </libraryjar>
        <injar location="${build.dir}/${ant.project.name}.jar" />
        <outjar location="${build.dir}/${ant.project.name}-obfuscated.jar" />

        <configuration file="@{config}" unless:blank="@{config}"/>
        <keep extends="java.lang.Enum">
          <method name="values" />
        </keep>
        <!-- Don't rename activities or other components otherwise the Android manifest will be wrong. -->
        <keep extends="android.app.Activity" />
        <keep extends="android.app.Application" />
        <keep extends="android.app.Service" />
        <keep extends="android.content.BroadcastReceiver" />
        <keep extends="android.content.ContentProvider" />
        <keep extends="android.app.Fragment" />
        <keep extends="android.support.v4.app.Fragment" />
        <dontnote filter="android.support.v4.app.Fragment" /> <!-- Support library might not be present. -->
        <keepclassmembers>
          <field type="android.os.Parcelable$Creator" name="CREATOR" />
        </keepclassmembers>
        <!-- Preserve names and constructors needed to instantiate views from XML. -->
        <keepclasseswithmembers extends="android.view.View">
          <constructor access="public" parameters="android.content.Context,android.util.AttributeSet"/>
        </keepclasseswithmembers>
        <!-- Preserve names and constructors needed to instantiate preferences from XML. -->
        <keepclasseswithmembers extends="android.preference.Preference">
          <constructor access="public" parameters="android.content.Context,android.util.AttributeSet"/>
        </keepclasseswithmembers>

      </proguard>
    </sequential>
  </macrodef>

  
  <!-- This macro builds a JAR file for a project, containing all of
       the classes in the main source group (i.e. unit test classes
       are excluded).  The JAR file name is derived from the project
       name (unless over-ridden). -->
  <macrodef name="jar">
    <attribute name="jarfile" default="${ant.project.name}.jar" description="JAR file name"/>
    <attribute name="classpath" default="" description="Manifest class path"/>
    <attribute name="mainclass" default="" description="Manifest main class"/>
    <element name="additionalcontents" optional="true"/>
    <sequential>
      <current:defaults />
      <jar destfile="${build.dir}/@{jarfile}">
        <fileset dir="${classes.dir}/main"/>
        <fileset dir="${java.dir}/resources" erroronmissingdir="false" />
        <manifest>
          <attribute name="Class-Path" value="@{classpath}"/>
          <attribute name="Main-Class" value="@{mainclass}"/>
        </manifest>
        <additionalcontents/>
      </jar>
    </sequential>
  </macrodef>


  <!-- This macro builds a JAR file containing a project's source code
       (excluding tests).  The JAR file name is derived from the project name
       (unless over-ridden). -->
  <macrodef name="source">
    <attribute name="tree" default="main" description="Source tree (e.g. 'main' or 'test') to package." />
    <attribute name="jarfile" default="${ant.project.name}-src.jar" description="Source JAR file name"/>
    <sequential>
      <current:defaults />
      <mkdir dir="${build.dir}" />
      <jar destfile="${build.dir}/@{jarfile}">
        <fileset dir="${java.dir}/@{tree}"/>
      </jar>
    </sequential>
  </macrodef>


  <!-- Runs TestNG unit tests, generates a report using ReportNG and measures
       coverage with Cobertura. -->
  <macrodef name="test">
    <attribute name="reportdir" default="${test-results.dir}" />
    <attribute name="headless" default="false" />
    <attribute name="mincoverage" default="60" />
    <attribute name="coverageExcludeRegex" default="" />

    <sequential>
      <current:defaults />

      <delete dir="${cobertura.dir}" />
      <mkdir dir="${cobertura.dir}" />
      
      <path id="test.path">
        <pathelement path="${classes.dir}/test"/>
        <pathelement path="${java.dir}/test-resources"/>
        <fileset dir="${cobertura.dir}" includes="*.jar"/>
        <fileset dir="${lib.compiletime}" includes="**/*.jar"/>
        <fileset dir="${lib.runtime}" includes="**/*.jar" erroronmissingdir="false"/>
        <pathelement path="${target.dir}/android.jar" />
      </path>

      <taskdef resource="tasks.properties" classpathref="test.path" />

      <!-- Bytecode instrumentation to enable collection of test coverage data. -->
      <cobertura-instrument todir="${cobertura.dir}"
                            datafile="${cobertura.dir}/cobertura.ser"
                            ignoreTrivial="true">
        <includeClasses regex=".*" />
        <excludeClasses regex="@{coverageExcludeRegex}" />
        <fileset dir="${build.dir}" includes="*.jar" excludes="*-src.jar" />
        <auxClasspath path="${build.dir}/${ant.project.name}.jar" />
      </cobertura-instrument>

      <mkdir dir="@{reportdir}/xml" />
      <mkdir dir="@{reportdir}/html" />

      <!-- Run the unit tests on the instrumented classes. -->
      <junit haltonfailure="false"
             fork="true">
        <classpath refid="test.path" />
        <sysproperty key="java.awt.headless" value="@{headless}" />
        <sysproperty key="net.sourceforge.cobertura.datafile"
                     file="${cobertura.dir}/cobertura.ser" />
        <formatter type="xml"/>
        <batchtest todir="@{reportdir}/xml">
          <fileset dir="${classes.dir}/test" includes="**/*Test.class"/>
        </batchtest>
      </junit>

      <!-- Generate the HTML test report. -->
      <junitreport todir="@{reportdir}/html">
        <fileset dir="@{reportdir}/xml">
          <include name="*.xml"/>
        </fileset>
        <report format="frames" todir="@{reportdir}/html"/>
      </junitreport>

      <!-- Generate the HTML coverage report. -->
      <mkdir dir="${coverage.dir}" />
      <cobertura-report format="html"
                        destdir="${coverage.dir}"
                        datafile="${cobertura.dir}/cobertura.ser">
        <fileset dir="${java.dir}/main" />
      </cobertura-report>
      <!-- Generate an XML coverage report so that Hudson can graph trends. -->
      <cobertura-report format="xml"
                        destdir="${coverage.dir}"
                        datafile="${cobertura.dir}/cobertura.ser">
        <fileset dir="${java.dir}/main" />
      </cobertura-report>

      <!-- If the coverage is poor, fail. -->
      <cobertura-check totallinerate="@{mincoverage}"
                       totalbranchrate="@{mincoverage}"
                       datafile="${cobertura.dir}/cobertura.ser"/>

    </sequential>
  </macrodef>


  <!-- Generates API documentation for the project. -->
  <macrodef name="javadoc">
    <attribute name="dir" default="${api.dir}"/>
    <attribute name="title"/>
    <attribute name="version" default=""/>
    <attribute name="excludes" default=""/>
    <element name="additionalconfig" optional="true"/>
    <sequential>
      <current:defaults />
      <mkdir dir="@{dir}"/>
      <javadoc destdir="@{dir}"
               bootclasspath="${target.dir}/android.jar"
               doctitle="@{title} @{version}"
               windowtitle="@{title}"
               encoding="${encoding}">
        <classpath>
          <fileset dir="${lib.runtime}" includes="**/*.jar" />
        </classpath>
        <fileset dir="${java.dir}/main" defaultexcludes="yes" excludes="@{excludes}" />
        <fileset dir="${generated.dir}/main" defaultexcludes="yes" excludes="@{excludes}" />
        <header unless:blank="@{version}"><![CDATA[@{title}<br><small>(Version @{version})</small>]]></header>
        <header if:blank="@{version}"><![CDATA[@{title}]]></header>
        <link href="https://developer.android.com/reference/"
              offline="true"
              packagelistLoc="${sdk.dir}/docs/reference/"/>
        <additionalconfig />
      </javadoc>
    </sequential>
  </macrodef>


  <!-- Combine two or more sets of Android files to make a single tree for building an app from. -->
  <macrodef name="merge-trees">
    <attribute name="todir" default="${app.root}" />
    <element name="trees" optional="false" implicit="true" />
    <sequential>
      <current:defaults />
      <mkdir dir="@{todir}" />
      <copy todir="@{todir}" overwrite="true">
        <trees />
      </copy>
    </sequential>
  </macrodef>


  <!-- Generate the Android R.java source file from the resources directory. -->
  <macrodef name="resources">
    <attribute name="manifest" default="${app.root}/AndroidManifest.xml" />
    <sequential>
      <current:defaults />

      <!-- Git does not store empty directories, so we have to make sure the asset directory exists. -->
      <mkdir dir="${asset.dir}" />
      <mkdir dir="${generated.dir}/main" />

      <local name="r.java" />
      <pathconvert property="r.java">
        <first count="1">
          <fileset dir="${generated.dir}/main" includes="**/R.java"/>
        </first>
      </pathconvert>
      <local name="skip.resources" />
      <uptodate property="skip.resources" targetfile="${r.java}" unless:blank="${r.java}">
        <srcresources>
          <fileset dir="${asset.dir}" />
          <fileset dir="${resource.dir}" />
          <fileset file="@{manifest}" />
        </srcresources>
      </uptodate>
      <exec executable="${build.tools.dir}/aapt" failonerror="true" unless:set="skip.resources">
        <arg value="package" />
        <arg value="-m" />
        <arg value="-M" />
        <arg path="@{manifest}" />
        <arg value="-S" />
        <arg path="${resource.dir}" />
        <arg value="-A" />
        <arg path="${asset.dir}" />
        <arg value="-J" />
        <arg path="${generated.dir}/main" />
        <arg value="-I" />
        <arg path="${target.dir}/android.jar" />
      </exec>
    </sequential>
  </macrodef>


  <macrodef name="aidl">
    <sequential>
      <current:defaults />
      <aidl executable="${build.tools.dir}/aidl"
            framework="${target.dir}/framework.aidl"
            genFolder="${generated.dir}/main"
            aidlOutFolder="${build.dir}">
        <source path="${java.dir}/main"/>
      </aidl>
    </sequential>
  </macrodef>


  <macrodef name="package">
    <attribute name="debug" />
    <attribute name="manifest" />
    <attribute name="name"/>
    <attribute name="package" default=""/>
    <sequential>
      <current:defaults />

      <local name="classes.jar" />
      <condition property="classes.jar" value="${ant.project.name}-obfuscated.jar" else="${ant.project.name}.jar">
        <available file="${ant.project.name}-obfuscated.jar" />
      </condition>
      <local name="skip.dex" />
      <uptodate property="skip.dex" targetfile="${build.dir}/classes.dex" srcfile="${build.dir}/${classes.jar}" />
      <apply executable="${build.tools.dir}/${dx.executable}" parallel="true" failonerror="true" unless:set="skip.dex">
        <arg value="--dex" />
        <arg value="--output=${basedir}/${build.dir}/classes.dex" />
        <arg path="${build.dir}/${classes.jar}" />
        <fileset dir="${lib.runtime}" includes="*.jar" erroronmissingdir="false" />
      </apply>

      <local name="skip.aapt" />
      <uptodate property="skip.aapt" targetfile="${build.dir}/@{name}.ap_">
        <srcresources>
          <fileset dir="${asset.dir}" />
          <fileset dir="${resource.dir}" />
          <fileset file="@{manifest}" />
        </srcresources>
      </uptodate>
      <exec executable="${build.tools.dir}/aapt" failonerror="true" unless:set="skip.aapt">
        <arg value="package" />
        <arg value="-M" />
        <arg path="@{manifest}" />
        <arg value="-S" />
        <arg path="${resource.dir}" />
        <arg value="-A" />
        <arg path="${asset.dir}" />
        <arg value="-I" />
        <arg path="${target.dir}/android.jar" />
        <arg value="-F" />
        <arg path="${build.dir}/@{name}.ap_" />
        <arg line="--rename-manifest-package @{package}" unless:blank="@{package}"/>
        <arg line="--debug-mode" if:true="@{debug}" />
        <arg line="-f" />
      </exec>

      <local name="skip.apk"/>
      <uptodate property="skip.apk" targetfile="${build.dir}/@{name}.apk">
        <srcresources>
          <fileset dir="${build.dir}" includes="classes.dex" />
          <fileset dir="${build.dir}" includes="@{name}.ap_" />
          <fileset dir="${lib.runtime}" includes="*.jar" erroronmissingdir="false" />
        </srcresources>
      </uptodate>
      <apkbuilder outfolder="${build.dir}"
                  apkfilepath="${build.dir}/@{name}.apk"
                  resourcefile="@{name}.ap_"
                  debugpackaging="@{debug}"
                  debugsigning="@{debug}"
                  unless:set="skip.apk">
        <dex path="${build.dir}/classes.dex" />
        <sourcefolder path="${java.dir}/main" />
        <jarfolder path="${lib.runtime}" />
      </apkbuilder>

    </sequential>
  </macrodef>


  <macrodef name="package-debug">
    <attribute name="manifest" default="${app.root}/AndroidManifest.xml" />
    <attribute name="name" default="${ant.project.name}-debug"/>
    <attribute name="package" default=""/>
    <sequential>
      <current:defaults />

      <!-- This property has to be set for 1.5 projects because apkbuilder is expecting it. -->
      <property name="out.debug.unaligned.package" value="${build.dir}/@{name}-unaligned.apk" />
      <current:package debug="true"
                       manifest="@{manifest}"
                       name="@{name}-unaligned"
                       package="@{package}"/>

      <local name="skip.align"/>
      <uptodate property="skip.align"
                targetfile="${build.dir}/@{name}.apk"
                srcfile="${out.debug.unaligned.package}" />
      <exec executable="${build.tools.dir}/zipalign" failonerror="true" unless:set="skip.align">
        <arg value="-f" />
        <arg value="4" />
        <arg path="${out.debug.unaligned.package}" />
        <arg path="${build.dir}/@{name}.apk" />
      </exec>
    </sequential>
  </macrodef>


  <macrodef name="package-release">
    <attribute name="manifest" default="${app.root}/AndroidManifest.xml" />
    <attribute name="name" default="${ant.project.name}"/>
    <attribute name="package" default=""/>
    <sequential>
      <current:defaults />

      <!-- This property has to be set for 1.5 projects because apkbuilder is expecting it. -->
      <property name="out.release.unaligned.package" value="${build.dir}/@{name}-unaligned.apk" />
      <current:package debug="false"
                       manifest="@{manifest}"
                       name="@{name}-unsigned"
                       package="@{package}"/>

      <local name="skip.signing"/>
      <uptodate property="skip.signing"
                targetfile="${out.release.unaligned.package}"
                srcfile="${build.dir}/@{name}-unsigned.apk" />
      <!-- Gets passwords -->
      <input message="Please enter keystore password (store:${key.store}):"
             addproperty="key.password"
             unless:set="skip.signing">
        <handler type="secure" />
      </input>
      <!-- Signs the APK -->
      <signjar jar="${build.dir}/@{name}-unsigned.apk"
               signedjar="${out.release.unaligned.package}"
               keystore="${key.store}"
               storepass="${key.password}"
               alias="${key.alias}"
               keypass="${key.password}"
               verbose="${verbose}"
               sigalg="MD5withRSA"
               digestalg="SHA1"
               unless:set="skip.signing"/>

      <local name="skip.align"/>
      <uptodate property="skip.align"
                targetfile="${build.dir}/@{name}.apk"
                srcfile="${out.release.unaligned.package}" />
      <exec executable="${build.tools.dir}/zipalign" failonerror="true" unless:set="skip.align">
        <arg value="-f"/>
        <arg value="4"/>
        <arg path="${out.release.unaligned.package}"/>
        <arg path="${build.dir}/@{name}.apk"/>
      </exec>
    </sequential>
  </macrodef>


  <!-- Install an APK on a single device or emulator. -->
  <macrodef name="install">
    <attribute name="device" default=""/>
    <attribute name="apk" default=""/>
    <sequential>
      <current:defaults />

      <!-- If APK attribute is not specified, default to newest APK found in the build directory. -->
      <pathconvert property="apk" unless:true="@{apk}">
        <first count="1">
          <sort>
            <fileset dir="${build.dir}" includes="*.apk" excludes="*unaligned.apk"/>
            <reverse><date /></reverse>
          </sort>
        </first>
      </pathconvert>
      <property name="apk" value="@{apk}" />

      <current:installapk apk="${apk}" />
    </sequential>
  </macrodef>

</antlib>