如何通过R8混淆XML布局中引用的自定义View类名？

Great question—this is a common pain point when obfuscating custom Views referenced in XML, since Android relies on fully qualified class names to instantiate Views via reflection from layout files. Let’s break down what’s going on and your available options:

R8 (and ProGuard before it) automatically preserves the fully qualified class names of any custom View referenced in XML. Here’s why: when the system inflates a layout, it uses Class.forName() with the exact class string from your XML to create an instance of the View. If R8 obfuscated that class name, the runtime would throw a ClassNotFoundException because it couldn’t match the XML’s string to the obfuscated class.

Even with android.enableR8.fullMode=true, R8 won’t touch these class names—it detects the XML dependency and treats it as a critical reflection-based reference that must be preserved.

Technically, yes—but it’s not straightforward, and comes with significant tradeoffs. To pull this off, you’d need to:

• Manually maintain a mapping between your original class names and obfuscated ones
• Replace all references to the original class names in your XML files with the obfuscated names (or an alias you map at runtime)
• Implement a custom LayoutInflater.Factory to intercept View creation and resolve the alias/obfuscated name to the actual class

This approach is error-prone, requires ongoing maintenance (every time you change a custom View, you’d need to update the mapping), and is generally not worth the effort for most projects.

Instead of forcing class name obfuscation for XML-referenced Views, use these safer, more maintainable approaches:

1. Use View Binding (Best Option) #

View Binding eliminates the need for reflection-based View instantiation entirely. At compile time, it generates binding classes that directly reference your custom Views using their obfuscated class names. This lets R8 safely obfuscate the custom View class names without breaking layout inflation.

How to set it up: #

1. Enable View Binding in your app-level build.gradle:

   android {
       ...
       buildFeatures {
           viewBinding true
       }
   }
   

2. Replace your layout inflation code with the generated binding class. For example, in an Activity:

   // Instead of setContentView(R.layout.activity_main);
   ActivityMainBinding binding = ActivityMainBinding.inflate(getLayoutInflater());
   setContentView(binding.getRoot());
   

3. Access your custom Views directly via the binding object (e.g., binding.myCustomView) instead of using findViewById().

This approach not only enables full obfuscation of custom View class names but also improves app performance and reduces runtime errors.

2. Use a Custom View Factory (For Edge Cases) #

If you can’t use View Binding (e.g., legacy codebase constraints), you can create a custom LayoutInflater.Factory2 to map aliases from your XML to obfuscated View classes.

Example workflow: #

1. In your XML, use an alias instead of the real custom View class name:

   <com.example.MyAliasView
       android:layout_width="match_parent"
       android:layout_height="wrap_content" />
   

2. Create a custom factory that resolves the alias to the obfuscated class:

   public class CustomViewFactory implements LayoutInflater.Factory2 {
       private final LayoutInflater.Factory2 defaultFactory;
   
       public CustomViewFactory(LayoutInflater.Factory2 defaultFactory) {
           this.defaultFactory = defaultFactory;
       }
   
       @Override
       public View onCreateView(View parent, String name, Context context, AttributeSet attrs) {
           // Map alias to your obfuscated custom View class
           if ("com.example.MyAliasView".equals(name)) {
               return new ObfuscatedCustomViewClass(context, attrs);
           }
           // Fall back to the default factory for other Views
           return defaultFactory.onCreateView(parent, name, context, attrs);
       }
   
       @Override
       public View onCreateView(String name, Context context, AttributeSet attrs) {
           return onCreateView(null, name, context, attrs);
       }
   }
   

3. Set the factory in your Activity before inflating any layouts:

   @Override
   protected void onCreate(Bundle savedInstanceState) {
       LayoutInflater layoutInflater = getLayoutInflater();
       layoutInflater.setFactory2(new CustomViewFactory(layoutInflater.getFactory2()));
       super.onCreate(savedInstanceState);
       setContentView(R.layout.activity_main);
   }
   

Note: This requires manual maintenance of the alias-to-class mapping, so it’s less ideal than View Binding.

3. Keep Constructors, Allow Internal Obfuscation #

If you don’t need to obfuscate the class name itself but want to obfuscate the View’s internal code (methods, fields), you can add a ProGuard rule to preserve only the required constructors. This lets R8 obfuscate everything else while keeping the class name intact for XML references.

Add this to your proguard-rules.pro:

-keep public class com.yourpackage.yourviews.** extends android.view.View {
    public <init>(android.content.Context);
    public <init>(android.content.Context, android.util.AttributeSet);
    public <init>(android.content.Context, android.util.AttributeSet, int);
}

This rule ensures the system can still instantiate your Views from XML, while R8 obfuscates the rest of the class’s implementation.

For most projects, View Binding is the clear winner—it’s clean, maintainable, and fully enables obfuscation of custom View class names without extra work. The custom factory approach is a last resort for legacy codebases, and keeping constructors is a good middle ground if you don’t need full class name obfuscation.

内容的提问来源于stack exchange，提问作者Alex Newman