Android Gradle中如何通过父类排除所有子类的Jacoco覆盖率报告？

Great question! Manually listing every subclass of BaseActivity in your Gradle config is totally impractical when you've got dozens (or more) of them. Here are two reliable ways to auto-exclude all subclasses of your parent class without the repetitive work:

Option 1: Dynamically Scan for Subclasses in Gradle #

You can use Gradle's afterEvaluate hook to scan your compiled class files, identify all classes that inherit from BaseActivity, and add them to Jacoco's exclusion list automatically.

Add this to your app-level build.gradle (or build.gradle.kts if using Kotlin DSL):

Groovy DSL #

jacocoTestReport {
    afterEvaluate {
        // Define the full package path to your BaseActivity
        def baseActivityFQCN = "com.your.app.package.BaseActivity"
        
        // Set up classloader to load BaseActivity and compiled classes
        def classpath = project.android.compileClasspath + files("${project.buildDir}/intermediates/javac/debug/classes")
        def classLoader = new URLClassLoader(classpath.collect { it.toURI().toURL() } as URL[])
        
        // Load the BaseActivity class
        def baseActivityClass = classLoader.loadClass(baseActivityFQCN)
        
        // Scan all compiled class files to find subclasses
        def subclassNames = fileTree(dir: "${project.buildDir}/intermediates/javac/debug/classes") {
            include '**/*.class'
        }.collect { classFile ->
            // Convert file path to fully qualified class name
            def className = classFile.path
                .replace("${project.buildDir}/intermediates/javac/debug/classes/", "")
                .replace(".class", "")
                .replace(File.separator, ".")
            
            try {
                def currentClass = classLoader.loadClass(className)
                // Check if this class is a subclass (and not the parent itself)
                return baseActivityClass.isAssignableFrom(currentClass) && currentClass != baseActivityClass ? className : null
            } catch (ClassNotFoundException | NoClassDefFoundError e) {
                // Skip classes that can't be loaded (e.g., generated classes)
                return null
            }
        }.findAll() // Filter out null values
        
        // Update Jacoco's class directories to exclude the subclasses
        classDirectories.setFrom(files(classDirectories.files.collect {
            fileTree(dir: it, exclude: subclassNames)
        }))
    }
}

Kotlin DSL #

tasks.jacocoTestReport {
    afterEvaluate {
        val baseActivityFQCN = "com.your.app.package.BaseActivity"
        
        val classpath = project.android.compileClasspath + files("${project.buildDir}/intermediates/javac/debug/classes")
        val classLoader = URLClassLoader(classpath.map { it.toURI().toURL() }.toTypedArray())
        
        val baseActivityClass = classLoader.loadClass(baseActivityFQCN)
        
        val subclassNames = fileTree("${project.buildDir}/intermediates/javac/debug/classes") {
            include("**/*.class")
        }.mapNotNull { classFile ->
            val className = classFile.path
                .replace("${project.buildDir}/intermediates/javac/debug/classes/", "")
                .replace(".class", "")
                .replace(File.separator, ".")
            
            try {
                val currentClass = classLoader.loadClass(className)
                if (baseActivityClass.isAssignableFrom(currentClass) && currentClass != baseActivityClass) className else null
            } catch (e: ClassNotFoundException) {
                null
            } catch (e: NoClassDefFoundError) {
                null
            }
        }
        
        classDirectories.setFrom(files(classDirectories.files.map {
            fileTree(it) {
                exclude(subclassNames)
            }
        }))
    }
}

Key Notes:

• Replace com.your.app.package.BaseActivity with the actual fully qualified class name of your BaseActivity.
• Adjust the build variant path (e.g., debug to release) if you're generating reports for a different variant.
• This scans your compiled classes, so it will only pick up subclasses that are part of your project's source code.

Option 2: Use a Custom Jacoco Filter (Advanced) #

If you need more control, you can create a custom Jacoco filter that checks class inheritance at report generation time. This requires writing a small Java/Kotlin helper class, but it's more robust for complex projects:

1. Create a helper class that implements Jacoco's IReportVisitor to filter out subclasses.
2. Register this visitor in your Gradle task to modify the report before it's generated.

This approach is more involved, but it's useful if you need to apply the same exclusion logic across multiple modules or projects.

内容的提问来源于stack exchange，提问作者Virendra Pal Singh