如何在APK构建流程中通过Gradle任务修改.class或.dex文件？

Hey there! Since you already have a solid base in Android's build and run mechanics, let's dive right into how to hook into the Gradle build pipeline to modify .class files post-compilation or .dex files before APK packaging—just like ProGuard does, but fully integrated into your build flow (no repackaging hacks needed!).

Android Gradle Plugin (AGP) exposes a clear task dependency chain, so we can target specific build stages to insert our custom logic. Let's break down both scenarios:

1. Modify .class Files After Java Compilation #

The Java compilation task in AGP is named compile<Variant>JavaWithJavac (e.g., compileDebugJavaWithJavac for debug builds). Once this task finishes, your module's source code is compiled into .class files stored in build/intermediates/javac/<variant>/classes.

How to insert your logic: #

• Step 1: Create a custom task to modify .class files
  Use a bytecode manipulation library like ASM or Byte Buddy to write a task that processes .class files. Here's a rough Groovy example:

  // Define a custom task type
  abstract class ModifyClassesTask extends DefaultTask {
      @InputDirectory
      Directory inputDir
  
      @OutputDirectory
      Directory outputDir
  
      @TaskAction
      void modifyClasses() {
          // Traverse inputDir, modify each .class file using ASM/Byte Buddy,
          // and write the modified files to outputDir
      }
  }
  
  // Register the task for debug variant
  tasks.register('modifyDebugClasses', ModifyClassesTask) {
      inputDir = file("${project.buildDir}/intermediates/javac/debug/classes")
      outputDir = file("${project.buildDir}/intermediates/modified_classes/debug")
  }
  

• Step 2: Wire the task into the build flow
  Use AGP's variant API to ensure your custom task runs after Java compilation, and that subsequent build steps use your modified .class files:

  android {
      applicationVariants.all { variant ->
          def compileTask = variant.javaCompileProvider.get()
          def modifyTask = tasks.named("modify${variant.name.capitalize()}Classes").get()
          def mergeClassesTask = variant.mergeClassesProvider.get()
  
          // Run modification after Java compilation
          modifyTask.dependsOn(compileTask)
          // Make class merge use modified files instead of original
          mergeClassesTask.dependsOn(modifyTask)
          mergeClassesTask.classesDir.from(modifyTask.outputDir)
      }
  }
  

  Now when you run assembleDebug, the flow becomes: Java Compile → Modify .class → Merge Classes → Dexing → ... → Package APK.

2. Modify .dex Files Before APK Packaging #

After dexing and merging, AGP produces the final .dex files in build/intermediates/merged_dex/<variant> via the merge<Variant>Dex task. The APK packaging task (package<Variant>Apk) uses these files right before creating the APK—this is our target point.

How to insert your logic: #

• Step 1: Create a custom task to modify .dex files
  Use a library like DexLib2 to manipulate .dex files. Example task setup:

  abstract class ModifyDexTask extends DefaultTask {
      @InputFile
      RegularFile inputDex
  
      @OutputFile
      RegularFile outputDex
  
      @TaskAction
      void modifyDex() {
          // Read inputDex, modify it with DexLib2, write to outputDex
      }
  }
  
  tasks.register('modifyDebugDex', ModifyDexTask) {
      inputDex = file("${project.buildDir}/intermediates/merged_dex/debug/classes.dex")
      outputDex = file("${project.buildDir}/intermediates/modified_dex/debug/classes.dex")
  }
  

• Step 2: Wire the task into the build flow
  Ensure your task runs after dex merging, and the packaging step uses your modified .dex files:

  android {
      applicationVariants.all { variant ->
          def mergeDexTask = variant.mergeDexProvider.get()
          def modifyDexTask = tasks.named("modify${variant.name.capitalize()}Dex").get()
          def packageApkTask = variant.packageApplicationProvider.get()
  
          modifyDexTask.dependsOn(mergeDexTask)
          // Replace original dex with modified one in packaging
          packageApkTask.inputs.files.remove(mergeDexTask.outputs.files)
          packageApkTask.inputs.files.add(modifyDexTask.outputDex)
      }
  }
  

3. Ready-Made Plugins to Avoid Reinventing the Wheel #

If you don't want to build custom tasks from scratch, these tools are perfect:

• ASM Gradle Plugin: A lightweight plugin that integrates ASM directly into the build pipeline, letting you inject bytecode modifications with minimal setup.
• Byte Buddy Gradle Plugin: Offers a more intuitive API for bytecode manipulation, with built-in support for AGP variants. It handles task wiring automatically.
• AGP Transform API: This is the official AGP extension mechanism used by ProGuard/R8. Create a custom Transform, and AGP will automatically insert it into the correct build stage to process .class files (including those from dependencies). It's the most robust approach for large-scale modifications.

Key Tips to Avoid Headaches #

• Variant Awareness: Always use applicationVariants.all (or libraryVariants for library modules) to handle all build variants (debug/release, product flavors) instead of hardcoding task names.
• Incremental Builds: Properly define @InputDirectory, @OutputDirectory, etc., in your custom tasks so Gradle can skip unnecessary work when files haven't changed.
• Compatibility: When modifying bytecode, ensure you're targeting compatible Java/Android versions—don't use Java 17 features if your app supports Android 11.

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