You can enable ProGuard in your Android Gradle build process, by enabling
minification in the `build.gradle` file of your project:

    android {
        .....
        buildTypes {
            debug {
                minifyEnabled   false
                shrinkResources false
            }
            release {
                minifyEnabled   true
                shrinkResources true
                proguardFile getDefaultProguardFile('proguard-android-optimize.pro')
                proguardFile 'proguard-project.txt'
            }
        }
    }

You then need to make sure that you use ProGuard instead of R8, in the
`gradle.properties` file of your project:

    android.enableR8=false
    android.enableR8.libraries=false

You can find a complete sample project in `examples/android` in the ProGuard
distribution.

## ProGuard Gradle Plugin

Alternatively, you can enable ProGuard in the Android Gradle build process
using ProGuard's own tuned plugin, by changing the `build.gradle` file of your
project as follows:

    buildscript {
        repositories {
            google()
            jcenter()
        }
        dependencies {
            classpath 'com.android.tools.build:gradle:3.3.0'
            classpath 'net.sf.proguard:proguard-gradle:6.2.2'
        }
    }

    apply plugin: 'com.android.application'
    apply plugin: 'proguard'

Or if you want to use your local copy of the plugin:

    buildscript {
        repositories {
            flatDir dirs: '/usr/local/java/proguard/lib'
            google()
            jcenter()
        }
        dependencies {
            classpath 'com.android.tools.build:gradle:3.3.0'
            classpath ':proguard:'
        }
    }

    apply plugin: 'com.android.application'
    apply plugin: 'proguard'

Please make sure the repository path in the build script is set correctly for
your system.

Each build type that should be processed by ProGuard needs to have a set of
configuration files, as shown below:

    android {
        .....
        buildTypes {
            debug {
                minifyEnabled false
                proguardFile getTunedProGuardFile('proguard-android-debug.pro')
                proguardFile 'proguard-project.txt'
            }
            release {
                minifyEnabled false
                proguardFile getTunedProGuardFile('proguard-android-release.pro')
                proguardFile 'proguard-project.txt'
            }
        }
    }

The setting "`minifyEnabled=false`" is needed to disable the
obfuscation/shrinking capability of the standard gradle plugin to avoid that
the project is obfuscated multiple times.

The lines with "`proguardFile getTunedProGuardFile`" are important. They apply
optimized minimal settings for the Android platform. Your own configuration
files then only need to contain project-specific settings.

You can find a complete sample project in `examples/android-plugin` in the
ProGuard distribution.

## Settings {: #proguard}

The **ProGuard plugin** supports various settings that can be added to the
*build.gradle* file to control its behavior:

    proguard {
        incremental                false
        transformExternalLibraries true
        transformSubprojects       true
    }

`incremental:`
: Support incremental builds, default: `false`

`transformExternalLibraries:`
: Processing also all external libraries, default: `true`

`transformSubproject:`
: Processing also all subprojects, default: `true`

## Java 8 language support

ProGuard can backport Java 8 language features to Dalvik and to older versions
of Java, so you can use them in applications and libraries that work on all
versions of Android.

The following language features are supported:

- lambda expressions (closures)
- method references
- try-with-resources statements
- static interface methods
- default interface methods

Additions to the Java runtime library (like the stream API) can not be
backported without additional runtime dependencies; see the next section.

In order to enable Java 8 language support, a Java 8 Compiler must be
available when running gradle, i.e. by setting `JAVA\_HOME`. You need to
configure the *source* and *target* compatibility settings in your
`build.gradle` script:

    android {
        .....
        compileOptions {
            sourceCompatibility JavaVersion.VERSION_1_8
            targetCompatibility JavaVersion.VERSION_1_8
        }
    }

If you want to target a minimum API level less than 19, you should add the
following configuration to your `proguard-project.txt`:

    -target 1.6

## Java 8 stream API support

ProGuard can backport the Java 8 stream API to older versions of Android (<
API 24), so you can use it in applications that work on all versions of
Android.

The following additions to Java 8 can be backported and thus be used in an
application:

- classes added in `java.util.function` package
- classes added in `java.util.stream` package
- default and static methods added to interfaces in `java.lang` and
  `java.util` (e.g. Iterable, Collection)
  - static methods added to classes in `java.lang` (Integer, Long, Double) and
  `java.util` (Arrays)
- classes added in `java.util` package (e.g. Optional, StringJoiner)
- classes added/updated in `java.util.concurrent` package (e.g. ForkJoinPool)

The following methods can not be backported and using them will fail the
build:

- methods added to `java.util.Random` (e.g. ints, longs, doubles)
- default method `remove()` in `java.util.Iterator`: classes that rely on a
  default implementation will not work

In order to use the Java 8 stream API and enable backporting in ProGuard, you
have to specify a minimum `compileSdkVersion` of *24*:

    android {
        .....
        compileSdkVersion 24 // or a higher version
    }

Furthermore, you need to add the *streamsupport* library as dependency to your
project, e.g. like this:

    repositories {
        jcenter()
    }

    dependencies {
        ...
        compile 'net.sourceforge.streamsupport:streamsupport:1.6.3'
    }

If you use the Java 8 stream API in your project, but ProGuard can not
backport to the included *streamsupport* library (e.g. due to an incompatible
version), ProGuard issues warnings in the console log.

Note: ProGuard currently only supports the core streamsupport library.
Additional modules (cfuture, atomic, flow, literal) are not yet backported.
Please contact [Guardsquare](https://www.guardsquare.com/) if you want to use
them as well.

## Java 8 time API support (JSR310)

ProGuard can backport the **Java 8 time API** to older versions of Android
(< API 26), so you can use it in applications that work on all versions of
Android.

The following additions to Java 8 can be backported and thus be used in an
application:

- classes added in `java.time` package

The *java.time* API includes various interfaces with default / static methods.
ProGuard can backport the use of these methods can be backported, but in case
you implement these interfaces yourself (which would be unusual), the
resulting class can not be fully backported (due to missing default methods).
This includes the following interfaces:

- java.time.chrono.ChronoLocalDate
- java.time.chrono.ChronoLocalDateTime
- java.time.chrono.Chronology
- java.time.chrono.ChronoPeriod
- java.time.chrono.ChronoZonedDateTime
- java.time.chrono.Era
- java.time.temporal.Temporal
- java.time.temporal.TemporalAccessor
- java.time.temporal.TemporalField
- java.time.temporal.TemporalUnit

In order to use the Java 8 time API and enable backporting in ProGuard,
a minimum `compileSdkVersion` of *26* has to be used:

    android {
        .....
        compileSdkVersion 26 // or a higher version
    }

Furthermore, you need to add the *threetenbp* library as dependency to your
project, e.g. like this:

    repositories {
        jcenter()
    }

    dependencies {
        ...
        api group: 'org.threeten', name: 'threetenbp', version: '1.3.6'
    }

It is highly recommended to use the *threetenabp* library from Jake Wharton
instead, which is just as a wrapper around the *threetenbp* library and
provides an efficient way to initialize the timezone database:

    dependencies {
        ...
        compile 'com.jakewharton.threetenabp:threetenabp:1.0.5'
    }

Additionally, you have to initialize the timezone database in your application
class like this:

    public void onCreate()
    {
        super.onCreate();
        ...
        com.jakewharton.threetenabp.AndroidThreeTen.init(this);
    }

If you use the Java 8 stream API in your project, but ProGuard can not
backport to the included *threetenbp* library (e.g. due to an incompatible
version), ProGuard issues warnings in the console log.