R8 Analyzer

Android skills

View on GitHub

R8 Analyzer

Use the R8 Analyzer Android skill to analyze build files and identify redundant, broad, or subsumed keep rules. To install the skill from the Android CLI, run:

android skills add r8-analyzer

<br />

For the best user experience, you should optimize your app to make it as small and fast as possible. Our app optimizer, called R8, streamlines your app by removing unused code and resources, rewriting code to optimize runtime performance, and more. To your users, this means:

• Faster startup time

• Reduced memory usage

• Improved rendering and runtime performance

• Fewer ANRs

[!IMPORTANT] Important: You should always enable optimization for your app's release build; however, you probably don't want to enable it for tests or libraries. For more information about using R8 with tests, see Test and troubleshoot the optimization. For more information about enabling R8 from libraries, see Optimization for library authors.

R8 optimization overview

R8 uses a multi-phase process to optimize your app for size and speed. Key operations include the following:

• Code shrinking (also known as tree shaking) : R8 identifies and removes unreachable code from your application and its library dependencies. By analyzing the entry points of your app (such as Activities or Services defined in the manifest), R8 builds a graph of referenced code and removes anything that remains unreferenced.

• Logical optimizations: R8 rewrites your code to improve execution efficiency and reduce overhead. Key techniques include:

  • Method inlining: R8 replaces a method call site with the actual body of the called method. This eliminates the overhead of a function call and lets R8 conduct further optimizations.

  • Class merging: R8 combines sets of classes and interfaces into a single class. This reduces the number of classes in the app, lowering memory pressure and improving startup speed.

• Obfuscation (also known as minification) : To reduce the size of the DEX file, R8 shortens the names of classes, fields, and methods (for example, com.example.MyActivity could become a.b.a).

Since 8.12.0 version of Android Gradle Plugin (AGP), R8 also optimizes resources as part of its optimization phases. For more information, see Optimized resource shrinking.

Enable optimization

To enable app optimization for your app use the appropriate DSL based on your project's AGP version. We recommend enabling app optimization only in the final version of your app that you test before publishing---usually your release build---because the optimizations increase the build time of your project and can make debugging harder due to the way it modifies code.

For AGP versions 9.3 and higher

To enable app optimization for AGP 9.3 and higher:

• Set enable = true in the optimization block in your release build's app-level build script.

• Add your keep rules to a file with the suffix .keep in the src/<variant>/keepRules source set. For example, src/main/keepRules/custom-rules.keep.

[!NOTE] Note: The updated DSL enables both code and resource optimization. It also includes a set of default keep rules for the Android platform, equivalent to "proguard-android-optimize.txt". To omit the default rules, see Omit default rules.

Kotlin

android {
    buildTypes {
        release {
            optimization {
                enable = true // Enables code and resource optimizations.
            }
        }
    }
}

Groovy

android {
    buildTypes {
        release {
            optimization {
                enable = true // Enables code and resource optimizations.
            }
        }
    }
}

Legacy DSL for AGP versions lower than 9.3

To enable app optimization, set isMinifyEnabled = true (for code optimization) and isShrinkResources = true (for resource optimization) in your release build's app-level build script. We recommend that you always enable both settings.

Legacy DSL (Kotlin)

android {
    buildTypes {
        release {

            // Enables code optimizations.
            isMinifyEnabled = true

            // Enables resource shrinking.
            isShrinkResources = true

            proguardFiles(
                // Default file with automatically generated optimization rules.
                getDefaultProguardFile("proguard-android-optimize.txt"),

                ...
            )
            ...
        }
    }
    ...
}

Legacy DSL (Groovy)

android {
    buildTypes {
        release {

            // Enables code optimizations.
            minifyEnabled = true

            // Enables resource shrinking.
            shrinkResources = true

            // Default file with automatically generated optimization rules.
            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt')

            ...
        }
    }
}

Improve R8 optimization

The performance benefits of R8 are directly correlated to how much of your codebase R8 is able to optimize. To get the maximum benefits out of R8, follow best practices:

• Enable R8 in full mode

• Enable obfuscation, optimization, and shrinking

• Enable resource shrinking and optimized resource shrinking

• Refine keep rules to allow maximum optimization of classes, fields and methods.

To help you refine keep rules, use the R8 Configuration Analyzer.

The R8 Configuration Analyzer lets you do the following:

• Track and improve the overall R8 configuration quality by monitoring the metrics provided by the R8 Configuration Analyzer report.

• Find the broadest keep rules - those which prevent the most optimization

• and understand what optimization they prevent to refine them.

The R8 Configuration Analyzer is available in AGP version 9.3.0-alpha05 or from R8 version 9.3.7-dev. For more information, see Analyze R8 configuration.

Optimize resource shrinking for even smaller apps

The 8.12.0 version of AGP introduces optimized resource shrinking, which aims to integrate resource and code optimization to create even smaller and faster apps. Before optimized resource shrinking, Android Asset Packaging Tool (AAPT2) generated keep rules that effectively treating resource shrinking separately from code, often retaining inaccessible code or resources that referenced each other.

With optimized resource shrinking, resources are considered like a part of program code, forming the reference graph. When a collection of code or resources is not referenced, it is not protected by a keep rule, and can be removed.

Enable optimized resource shrinking

To enable the new optimized resource shrinking pipeline for AGP 8.12 or 8.13, add the following to your project's gradle.properties file:

android.r8.optimizedResourceShrinking=true

If you are using AGP 9.0.0 or a newer version, you don't need to set android.r8.optimizedResourceShrinking=true. Optimized resource shrinking is automatically applied when isShrinkResources = true is enabled in your build configuration.

Verify and configure R8 optimization settings

To enable R8 to use its full optimization capabilities, remove the following line from your project's gradle.properties file, if it exists:

android.enableR8.fullMode=false

Note that enabling app optimization makes stack traces difficult to understand, especially if R8 renames class or method names. To get stack traces that correctly correspond to your source code, see Recover the original stack trace.

If R8 is enabled, you should also create Startup Profiles for even better startup performance.

If you enable app optimization and it causes errors, here are some strategies to fix them:

• Add keep rules to keep some code untouched.

• Adopt optimizations incrementally.

• Update your code to use libraries that are better suited for optimization.

[!CAUTION] Caution: Tools that replace or modify R8's output can negatively impact runtime performance. R8 is careful about including and testing many optimizations at the code level, in DEX layout, and in correctly producing Baseline Profiles - other tools producing or modifying DEX files can break these optimizations, or otherwise regress performance.

If you are interested in optimizing your build speed, see Configure how R8 runs for information on how to configure R8 based on your environment.

AGP and R8 version behavior changes

The following table outlines the key features introduced in various versions of the Android Gradle Plugin (AGP) and the R8 compiler.

Use R8 with other build systems

While AGP is the recommended and officially supported build system for Android apps, you might use an alternative build system like Bazel. If you're using Bazel, you can integrate R8 into your build pipeline to shrink, obfuscate, and optimize your app.

For information about optimizing an Android app using Bazel, see Bazel's rules_android documentation. Note that Bazel isn't officially supported for Android app development.