Shrinking the Scala library code

Building Android applications written in Scala requires to bundle the Scala library code together with the generated .dex file. The Android platform namely forbids you to export a self-contained .jar file, as you would do for a true library. We present in this article two possible ways to deal with that constraint.

Note: Starting with API level 8 of the Android framework you can create library projects to share Android source code and resources. However, those are just build-time constructs that are compiled indirectly, by referencing them from a dependent application's build path, when building an Android application.

Let us consider the following three possibilities:

• We bundle the full library code together with our Android application;

  The size of the "scala-library.jar" library code is about 6 MB in Scala 2.8.0; thus the size of every Android application written in Scala would exceed 6 MB !

  Note: The dx tool of the Android SDK fails to generate Android bytecode for the Scala standard library. For instance the execution of the following shell command aborts with the error message "trouble writing output: format == null" :

  /tmp> dx -JXmx1024M -JXms1024M -JXss4M --no-optimize --debug --dex
      --output=/tmp/scala-library.jar /opt/scala/lib/scala-library.jar

  That issue is due to a size limit in the Dalvik VM and is not specific to Scala. It was reported by Maciek Makowski to the Android project hosted on Google Code on March 14, 2010 (issue #7147).

  Obviously we have to discard that possibility.
• We rely on a Java shrinker tool to reduce the library code size to be bundled with our Android application. This article compares two solutions based on the free tools ProGuard and YGuard. Other non-commercial tools exist but they have not be maintained for over two years.
• Finally we dive into the internals of the Android emulator and find a way to extend the boot class path of the Dalvik-VM with our library code. We will discuss that solution in our next month article "Tweaking the Android emulator".

Tools

Both shrinker tools can be run as a task in the Java-based build tool Ant (version 1.6.0 or higher).

• ProGuard is a free Java class file shrinker, optimizer, obfuscator, and preverifier written by Eric Lafortune. The shrinking step detects and removes unused classes, fields, methods, and attributes. The size reduction of the processed code is typically superior to 60% — Eric claims even ~90% size reduction for Apache Ant — when all steps are enabled.
• The YGuard tool is another software supporting name obfuscation and code shrinking.

Results

In this section we resume the results of measurements performed on 10 sample applications available from the Android SDK. We present processing times and shrunk code sizes obtained with the Java tools Proguard and YGuard and compare them with a runtime-based solution (see article "Tweaking the Android emulator").

In Table 1 we observe — and are badly suprised — that build times with YGuard are extremely long compared to Proguard. More generally we must acknowledge the additional time required to build Android applications written in Scala.

Table 1. Project build times for Android applications written in Scala and Java.

(1) Average system time measured with command "ant clean; time ant" (default target is debug).
(2) No code shrinking, no library code (see article "Tweaking the Android emulator").

In Table 2 we compare the code size of the generated .dex files for the 10 sample applications. We remind here that the shrinker tools actually process Java class files which are then compiled into Dalvik executables.

While build times with YGuard are much worse than ProGuard's ones both shrinker tools achieve similar code size reduction (results may vary slightly depending on the enabled tool options).

Table 2. Sizes of .dex files generated for Android applications written in Scala and Java.

(1) We give in parenthesis the number of remaining library classes (from initially 4151 classes).
(2) We use the same optimizations as in Android example from the Proguard online manual.
(3) No code shrinking, no library code (see article "Tweaking the Android emulator").

Before its installation on a device each Android application is packaged as a single .apk file which includes .dex files, resources, assets, and manifest file.

Table 3. Sizes of .apk files generated for Android applications written in Scala and Java.

(1) Package size includes bytecode and resources.
(2) No code shrinking, no library code (see article "Tweaking the Android emulator").

Note: The above results have been measured on a 2.0 GHz Pentium M laptop with 2 GB of memory; the machine is running either Linux Ubuntu 8.04 or Microsoft Windows XP Pro. The development environment includes the following software: Sun JDK 1.6.0_20, Eclipse 3.5.2 (with ADT 0.9.7 and Scala Plugin 2.8.0.X), Apache Ant 1.8.1 and Scala 2.8.0_RC6.

Based on the above results the winner is clearly ProGuard (assuming that a modified emulator environment is not an option); it is efficient both in time and space and adapts very well to the developer's needs.

-shrink-scala Target

In our article "Targeting Scala to the Android platform" we added the two targets "compile-scala" and "-shrink-scala" to the build.xml Ant script in order to include Scala source files in our build process.

We present here the two variants of the "-shrink-scala" target we implemented in order to evaluate the ProGuard and YGuard tools.

The "ProGuard" variant of the "-shrink-scala" target gets its settings from an external configuration file; its content is based on the template file proguard.conf and is determined dynamically during the build process.

<target name="-shrink-scala" depends="-shrink-if-test" unless="do.not.shrink"
        description="Shrink the Scala library code">
    <!-- ... (skipped) -->
    <proguard-helper property="injars" prefix="-injars"
        path="${out.classes.dir}${path.separator}${scala-library.jar}" />
    <!-- ... (skipped) -->
    <copy file="${basedir}/proguard.conf" tofile="${proguard.conf}">
        <filterchain>
            <replacetokens>
                <token key="INJARS" value="${injars}"/>
                <token key="OUTJARS" value="${outjars}"/>
                <token key="LIBRARYJARS" value="${libraryjars}"/>
                <token key="MYAPP_PACKAGE" value="${myapp.package}"/>
            </replacetokens>
        </filterchain>
    </copy>
    <proguard configuration="${proguard.conf}" />
    <touch file="${out.dir}/myapp.complete" verbose="no" />
</target>

Note: In our framework the external ProGuard configuration file is actually generated differently depending on the invoked target. Per default it is based on the template file configs/default-debug.pro respectively configs/default-release.pro for the targets "debug" and "install" respectively "release" and "install-release") and may be superseeded by a local configuration with project specific settings.

The Ant target "-shrink-scala" based on the YGuard Ant task looks as follows:

<target name="-shrink-scala" depends="-shrink-if-test" unless="do.not.shrink"
        description="Shrink the Scala library code">
    <!-- ... (skipped) -->
    <jar destfile="${myapp.jar}" basedir="${out.classes.dir}" />
    <yguard>
        <inoutpair in="${scala-library.jar}" out="${scala-library-shrinked.jar}" />
        <externalclasses>
            <pathelement location="${android.jar}" />
        </externalclasses>
        <shrink logfile="${out.dir}/yshrinklog.xml">
            <entrypointjar name="${myapp.jar}" />
        </shrink>
    </yguard>
    <unjar src="${scala-library-shrinked.jar}" dest="${out.classes.dir}" />
</target>

About the Author

Stéphane Micheloud is a senior software engineer. He holds a Ph.D in computer science from EPFL and a M.Sc in computer science from ETHZ. At EPFL he worked on distributed programming and advanced compiler techniques and participated for over six years to the Scala project. Previously he was professor in computer science at HES-SO // Valais in Sierre, Switzerland.

[Top]

---

Other Articles

• Targeting Scala to the Android platform (May 2010).
• Ant scripting in the Android SDK (June 2010).
• Tweaking the Android emulator (June 2010).
• Translating Java code to Scala (July 2010).
• Writing a Scala API for Android (July 2010).

[Top]

---

Last updated: June 29, 2010.

XHTML1.1 CSS2.1