ProGuard and R8 optimization in Android Kotlin - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

What is the primary purpose of ProGuard in Android development?

Choose the main reason developers use ProGuard when building Android apps.

A To generate app screenshots for the Play Store listing

B To add new UI components automatically during build

C To increase the app's runtime speed by changing the CPU architecture

D To shrink and obfuscate the app code to reduce APK size and protect code

💡 Hint

Think about what happens to your app code before publishing it.

ProGuard shrinks the app by removing unused code and obfuscates it to make reverse engineering harder, reducing APK size and improving security.

❓ ui_behavior

intermediate

What happens to your app UI if R8 removes a class used only in layout XML?

If R8 optimization removes a class that is only referenced in your layout XML files but not directly in Kotlin code, what is the likely result when you run the app?

A The app UI shows a blank screen but no crash

B The app crashes at runtime with a ClassNotFoundException

C The app runs normally without any UI changes

D The app shows a compile-time error and does not build

💡 Hint

Consider how R8 detects code usage and what happens if a needed class is missing at runtime.

R8 removes unused classes based on code references. If a class is only referenced in XML and not kept, it will be removed, causing a runtime crash when the UI tries to inflate it.

❓ lifecycle

advanced

How does enabling R8 affect app build lifecycle and debugging?

When you enable R8 in your Android project, which of the following is true about the build lifecycle and debugging experience?

A Build time increases slightly and debugging obfuscated code requires mapping files

B Build time decreases and debugging is easier because code is simplified

C Build time is unaffected and debugging works normally without changes

D Build time increases drastically and debugging is impossible

💡 Hint

Think about what happens when code is obfuscated and how developers debug crashes.

R8 adds optimization steps increasing build time slightly. Obfuscated code changes names, so debugging requires mapping files to translate stack traces back to original code.

❓ navigation

advanced

Which ProGuard rule prevents removal of classes used in Android Navigation XML?

You use Android Navigation component with fragments declared only in navigation XML. Which ProGuard rule keeps these fragment classes from being removed by R8?

A -keep class * extends android.app.Activity { <init>(); }

B -keep class ** { *; }

C -keep class * extends androidx.fragment.app.Fragment { <init>(); }

D -keep class * implements android.os.Parcelable { <init>(); }

💡 Hint

Fragments used only in XML need to be kept by their class inheritance.

Fragments used in navigation XML are instantiated by class name at runtime. The rule keeping all classes extending Fragment with a constructor prevents R8 from removing them.

📝 Syntax

expert

What is the output of this ProGuard keep rule effect on R8 optimization?

Given this ProGuard rule: -keepclassmembers class com.example.MyClass { public void myMethod(); } What effect does this have on R8 optimization?

Android Kotlin

-keepclassmembers class com.example.MyClass { public void myMethod(); }

A Keeps only the method 'myMethod' in MyClass from being removed or renamed

B Keeps the entire MyClass and all its members from removal or renaming

C Removes 'myMethod' but keeps the rest of MyClass intact

D Has no effect; R8 ignores this rule

💡 Hint

Focus on what 'keepclassmembers' means compared to 'keep'.

'-keepclassmembers' keeps only the specified members (methods/fields) from removal or renaming but allows the class itself to be removed if unused.