Optimizing Jetpack Compose Apps with R8 for Release Mode

In Android development, optimizing your application for release is crucial to ensure performance, security, and a smaller APK size. When using Jetpack Compose, these optimizations are even more important due to the increased amount of generated code and composable functions. R8, the code shrinker, optimizer, and obfuscator built into the Android Gradle Plugin, plays a significant role in this process. This blog post will delve into how to leverage R8 effectively with Jetpack Compose in release mode.

What is R8 and Why Is It Important?

R8 is a tool integrated into the Android build process that performs:

• Code Shrinking: Removes unused code, reducing the APK size.
• Optimization: Rewrites bytecode to improve performance.
• Obfuscation: Renames classes and methods to make reverse engineering more difficult.

These optimizations are essential for:

• Performance: Smaller and more efficient code executes faster.
• Security: Obfuscation protects your app from reverse engineering.
• APK Size: Reduced size leads to faster downloads and more installations.

Setting Up Your Project for R8 with Jetpack Compose

To effectively use R8, you need to ensure your project is correctly configured.

Step 1: Enable R8 in gradle.properties

R8 is enabled by default for release builds starting with Android Gradle Plugin 3.4.0. However, it’s good practice to explicitly enable it in your gradle.properties file:

# Enable R8 code shrinking, optimization, and obfuscation
android.enableR8=true

Step 2: Configure Proguard Rules

Proguard rules are directives that tell R8 which code to keep, discard, or modify. Compose-specific rules are important to avoid runtime crashes due to reflection or dynamic code loading.
Create a proguard-rules.pro file in your app/ directory if you don’t have one already. Common rules for Jetpack Compose include:

# Keep Compose classes and methods
-keep class androidx.compose.** { *; }
-keepnames class androidx.compose.** { *; }

# Keep Kotlin metadata
-keep class kotlin.Metadata { *; }

# Keep synthetic static methods used for default parameter values
-keepattributes Synthetic,Signature,InnerClasses,Deprecated,SourceFile,SourceDir,*Annotation*
-keep class * implements androidx.compose.runtime.Applier

-if class androidx.compose.runtime.Applier
-keep class * extends androidx.compose.runtime.Applier {
    (...);
}
-endif

-keep class androidx.compose.ui.util.fastRepeatableStateMultiplexer
-keep class androidx.compose.ui.graphics.vector.** {
    ;
    ;
}

Explaination for Proguard Rules:

• -keep class androidx.compose.** { *; } This keeps all classes, interfaces, enums, and annotations defined in the androidx.compose package and all its subpackages, along with their members (fields, constructors, methods). Prevents R8 from obfuscating or removing any part of the Compose library. This is crucial because Compose relies heavily on reflection and code generation, which R8 might misinterpret as unused if not explicitly told to keep it.
• -keepnames class androidx.compose.** { *; } This directive is similar to -keep, but it only prevents the classes from being renamed (obfuscated) but still allows R8 to optimize the classes (e.g., removing unused methods). It’s often used to prevent certain classes from being obfuscated when the names themselves are important for some form of runtime lookup or dependency injection.
• -keep class kotlin.Metadata { *; } When Kotlin code is compiled, the Kotlin compiler generates .class files and Kotlin metadata. This metadata contains information about Kotlin-specific language features like nullability, default parameters, and more. Prevents R8 from stripping out Kotlin-specific metadata, ensuring that Compose runtime correctly understands Kotlin features in your app.
• -keepattributes Directives like Synthetic,Signature,InnerClasses,Deprecated,SourceFile,SourceDir,*Annotation* preserve specific attributes of classes and members. For Compose, Synthetic and Signature are crucial because Compose code often relies on compiler-generated methods and generic type information to be preserved. These synthetic methods and generic signatures might be incorrectly removed or obfuscated if these attributes are not kept, causing runtime errors or incorrect behavior. Deprecated, SourceFile and *Annotation* keep annotation for the compose element.
• -keep class * implements androidx.compose.runtime.Applier This targets all classes that implement the Applier interface from the Compose runtime. In Compose, the Applier interface is part of how the UI is updated based on changes in the composable functions. Appliers update the actual underlying UI tree (such as Android Views) and removing them can cause app to crash.
• -keep class * extends androidx.compose.runtime.Applier { (…); } This extends the previous rule to keep the constructors of classes that extend androidx.compose.runtime.Applier. Prevents issue like injection issue in UI tree element.
• -keep class androidx.compose.ui.util.fastRepeatableStateMultiplexer Some internal optimized collection in compose used frequently is not touched during minification
• vectorDrawable keep safe side, keep vector drawables elements when obfuscating resources or dealing with vector graphics within your composable functions. This prevent missing icons in released apps.

Step 3: Integrate Proguard Rules into Your Build

Make sure the proguard-rules.pro file is included in your release build configuration in your build.gradle.kts:

android {
    buildTypes {
        release {
            minifyEnabled true
            shrinkResources true
            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
        }
    }
}

Dealing with Common Issues in Jetpack Compose and R8

While R8 does a great job of optimizing your code, you might encounter issues specific to Jetpack Compose.

Issue 1: Reflection and Dynamic Code Loading

Jetpack Compose relies heavily on reflection and dynamic code loading, which R8 might not handle well by default. Symptoms of this issue include runtime crashes or unexpected behavior.

Solution: Use the -keep directives mentioned above to prevent R8 from obfuscating or removing necessary classes and methods.

Issue 2: Inline Functions and Composables

R8 can sometimes incorrectly optimize inline functions and composables, leading to issues during runtime.

Solution: Use the @Keep annotation from the androidx.annotation library on composable functions or classes that are critical and should not be optimized or removed. Add the following dependency:

dependencies {
    implementation "androidx.annotation:annotation:1.6.0" // or newer
}

Then, use @Keep in your composables:

import androidx.annotation.Keep
import androidx.compose.runtime.Composable

@Keep
@Composable
fun MyComposable() {
    // Your composable code
}

Issue 3: Incorrect Resource Shrinking

Sometimes R8 might remove resources that are actually used by Compose, leading to missing images or other UI elements.

Solution: Use the shrinkResources option in your build.gradle.kts and create a keep.xml file in the res/raw/ directory to specify resources that should be kept.

<?xml version="1.0" encoding="utf-8"?>
<resources xmlns:tools="http://schemas.android.com/tools">
    <!-- Keep specific resources -->
    <keep name="my_image" />
    <keep name="my_string" />
</resources>

Step 4: Customizing Build for Environments.

Compose brings the option of environment aware variables:

buildTypes {
    release {
        val keystorePropertiesFile = rootProject.file("keystore.properties")
        val keystoreProperties = Properties()
        keystoreProperties.load(FileInputStream(keystorePropertiesFile))

        signingConfig {
            storeFile = file(keystoreProperties["storeFile"] as String)
            storePassword = keystoreProperties["storePassword"] as String
            keyAlias = keystoreProperties["keyAlias"] as String
            keyPassword = keystoreProperties["keyPassword"] as String
            enableV3Signing = true
            enableV4Signing = true
        }
        debuggable = false
        minifyEnabled = true
        shrinkResources = true
        proguardFiles(
            getDefaultProguardFile("proguard-android-optimize.txt"),
            "proguard-rules.pro"
        )
    }
}

Best Practices for R8 with Jetpack Compose

• Test Thoroughly: Always test your release builds on real devices to catch any R8-related issues.
• Incremental Builds: Use incremental builds to speed up the development process.
• Analyze APK: Use the APK Analyzer in Android Studio to inspect the size and contents of your APK and identify areas for further optimization.
• Keep Dependencies Up-to-Date: Ensure you are using the latest versions of Jetpack Compose and related libraries, as newer versions often include R8-related fixes and improvements.

Conclusion

R8 is a powerful tool that is essential for optimizing Jetpack Compose applications in release mode. By understanding how to configure R8, addressing common issues, and following best practices, you can ensure your Compose apps are performant, secure, and have a smaller APK size. Optimizing your applications can significantly improve user experience and adoption rates, leading to greater success in the competitive app market. Always test your release builds thoroughly and stay updated with the latest Jetpack Compose and Android Gradle Plugin features to take full advantage of R8’s capabilities.