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.
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.
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
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:
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
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:
java.util.function packagejava.util.stream packagejava.lang and java.util (e.g. Iterable, Collection)java.lang (Integer, Long, Double) and java.util (Arrays)java.util package (e.g. Optional, StringJoiner)java.util.concurrent package (e.g. ForkJoinPool)The following methods can not be backported and using them will fail the build:
java.util.Random (e.g. ints, longs, doubles)remove() in java.util.Iterator: classes that rely on a default implementation will not workIn 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 if you want to use them as well.
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:
java.time packageThe 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:
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.