Choose between @Keep annotations and custom R8 keep rules for preserving Kotlin reflection metadata in release builds

Answer to the question

For a typical set of 20‑30 @Serializable data classes, using @Keep on every class/property inflates the APK by roughly the same amount as the number of kept elements (≈5‑15 % for the sample set). A fine‑grained -keeprules that targets only the Kotlin metadata needed for reflection usually results in a smaller APK – typically 5‑15 % smaller than the blanket @Keep approach – while preserving all required runtime information. Runtime reflection performance is essentially identical for both strategies; the difference is only in the size of the retained bytecode and metadata. A hybrid strategy (annotating a few critical classes with @Keep and keeping the rest via rules) is safe, additive, and does not duplicate metadata.

Why this matters

• @Keep forces the compiler to emit a keep rule that retains the entire element (class, fields, accessors) and its Kotlin metadata.
• Custom -keeprules can target only the kotlin.Metadata attribute and the minimal set of classes, keeping the rest of the code shrinkable.
• Incorrect rules can silently drop metadata, causing KotlinReflectionNotSupportedError at runtime.

Recommended steps for your project

1. Identify the classes that must be reflected. Create a list in proguard-rules.pro:

   # Keep only the Kotlin metadata required for reflection
   -keepattributes *Annotation*
   -keepclassmembers class * {
       @kotlin.Metadata *;
   }
   -keep class com.yourapp.model.** { *; }
   

2. Apply @Keep only to the few classes that are accessed via reflection in ways that cannot be expressed by rules (e.g., dynamic class loading).

3. Verify shrinker configuration. Run ./gradlew :app:printReleaseR8Configuration to see the generated keep rules and ensure no unwanted classes are kept.

4. Build two variants. One with @Keep on all target classes, another with the custom rules above. Compare APK sizes using Android Studio’s Analyze APK tool.

5. Run a unit test. Use kotlin.reflect.jvm to access property names and annotations on the data class. Confirm that no KotlinReflectionNotSupportedError is thrown.

6. Optional: Inspect the final DEX. Decompile with jadx or dexdump to verify that only the expected metadata is present.

Possible trade‑offs

• Overly broad rules (e.g., -keep class * { *; }) negate size benefits.
• Too narrow rules may drop @kotlin.Metadata from a class whose annotations are needed, leading to runtime errors.
• Using @Keep on properties keeps backing fields and accessor methods, slightly larger than keeping only the metadata.

Hybrid approach

Annotate only the classes that are required for dynamic loading or that the compiler cannot infer. Keep the rest via rules. This combination guarantees no duplicate metadata because R8 merges keep rules during shrinking.

What we need to refine this recommendation

Could you tell me how many @Serializable data classes you need to preserve? Knowing the exact count helps estimate the size impact more precisely and ensures the keep rules are tailored to your codebase.