Introduce separate task variants for Android projects (#101)

matejdro · web-flow · commit a88b2575b034 · 2026-01-24T12:08:24.000+09:00
* Add support for Android variants

* Fix Gradle Build Cache compatibility

* Simplify task list providers

* Reformat

* Document variant-specific tasks

* Add missing filter

* Fix optional parameters

* Always use projectName property

* Fix crash with the missing stability folder

* only add runtime dependency once

* update api

* reformat StabilityCheckTask
diff --git a/README.md b/README.md
@@ -541,6 +541,11 @@ Think of it like this:
 
 > **Note**: Keep in mind that, all these Gradle tasks should be done **after compile your project**.
 
+### Android
+
+For Android projects, variant-specific tasks will be created, such as `debugStabilityDump`.
+You can use those to only compile one variant of your module.
+
 ### Step 1: Create a Stability Baseline
 
 First, you need to generate a baseline—a snapshot of your current composables' stability.
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
@@ -28,6 +28,7 @@ androidx-compose-runtime-annotation = { module = "androidx.compose.runtime:runti
 androidx-compose-ui = { group = "androidx.compose.ui", name = "ui" }
 androidx-compose-material3 = { group = "androidx.compose.material3", name = "material3" }
 androidx-compose-ui-tooling-preview = { group = "androidx.compose.ui", name = "ui-tooling-preview" }
+android-gradleApi = { module = "com.android.tools.build:gradle-api", version.ref = "androidGradlePlugin" }
 junit = { module = "junit:junit", version.ref = "junit" }
 kotlin-compiler-embeddable = { module = "org.jetbrains.kotlin:kotlin-compiler-embeddable", version.ref = "kotlin" }
 kotlinx-collections-immutable = { module = "org.jetbrains.kotlinx:kotlinx-collections-immutable", version.ref = "kotlinxCollectionsImmutable" }
diff --git a/stability-gradle/api/stability-gradle.api b/stability-gradle/api/stability-gradle.api
@@ -28,8 +28,9 @@ public abstract class com/skydoves/compose/stability/gradle/StabilityCheckTask :
 	public abstract fun getIgnoredPackages ()Lorg/gradle/api/provider/ListProperty;
 	public abstract fun getProjectName ()Lorg/gradle/api/provider/Property;
 	public abstract fun getQuietCheck ()Lorg/gradle/api/provider/Property;
-	public abstract fun getStabilityDir ()Lorg/gradle/api/file/DirectoryProperty;
-	public abstract fun getStabilityInputFile ()Lorg/gradle/api/file/RegularFileProperty;
+	public abstract fun getStabilityFileSuffix ()Lorg/gradle/api/provider/Property;
+	public abstract fun getStabilityInputFiles ()Lorg/gradle/api/file/ConfigurableFileCollection;
+	public abstract fun getStabilityReferenceFiles ()Lorg/gradle/api/file/ConfigurableFileCollection;
 }
 
 public abstract class com/skydoves/compose/stability/gradle/StabilityDumpTask : org/gradle/api/DefaultTask {
@@ -39,6 +40,7 @@ public abstract class com/skydoves/compose/stability/gradle/StabilityDumpTask :
 	public abstract fun getIgnoredPackages ()Lorg/gradle/api/provider/ListProperty;
 	public abstract fun getOutputDir ()Lorg/gradle/api/file/DirectoryProperty;
 	public abstract fun getProjectName ()Lorg/gradle/api/provider/Property;
+	public abstract fun getStabilityFileSuffix ()Lorg/gradle/api/provider/Property;
 	public abstract fun getStabilityInputFiles ()Lorg/gradle/api/file/ConfigurableFileCollection;
 }
 
diff --git a/stability-gradle/build.gradle.kts b/stability-gradle/build.gradle.kts
@@ -30,6 +30,7 @@ kotlin {
 
 dependencies {
   compileOnly(kotlin("gradle-plugin", version = libs.versions.kotlin.get()))
+  implementation(libs.android.gradleApi)
 
   testImplementation(kotlin("test"))
   testImplementation(kotlin("test-junit"))
@@ -57,4 +58,4 @@ gradlePlugin {
 java {
   sourceCompatibility = JavaVersion.VERSION_11
   targetCompatibility = JavaVersion.VERSION_11
-}
+}
diff --git a/stability-gradle/src/main/kotlin/com/skydoves/compose/stability/gradle/StabilityAnalyzerGradlePlugin.kt b/stability-gradle/src/main/kotlin/com/skydoves/compose/stability/gradle/StabilityAnalyzerGradlePlugin.kt
@@ -15,6 +15,7 @@
  */
 package com.skydoves.compose.stability.gradle
 
+import com.android.build.api.variant.AndroidComponentsExtension
 import org.gradle.api.Project
 import org.gradle.api.provider.Provider
 import org.jetbrains.kotlin.gradle.plugin.KotlinCompilation
@@ -23,6 +24,7 @@ import org.jetbrains.kotlin.gradle.plugin.KotlinSourceSet.Companion.COMMON_MAIN_
 import org.jetbrains.kotlin.gradle.plugin.KotlinSourceSetContainer
 import org.jetbrains.kotlin.gradle.plugin.SubpluginArtifact
 import org.jetbrains.kotlin.gradle.plugin.SubpluginOption
+import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 
 /**
  * Gradle plugin for Compose Stability Analyzer.
@@ -64,6 +66,24 @@ public class StabilityAnalyzerGradlePlugin : KotlinCompilerPluginSupportPlugin {
     // Add runtime to compiler plugin classpath for all compilations
     addRuntimeToCompilerClasspath(target)
 
+    val androidComponents = target.extensions.findByType(AndroidComponentsExtension::class.java)
+    if (androidComponents == null) {
+      registerTasksNonAndroid(target, extension)
+    } else {
+      registerTasksAndroid(target, extension, androidComponents)
+    }
+
+    // Add output parameter to the Kotlin tasks to ensure it is compatible with the Build Cache
+    target.tasks.withType(KotlinCompile::class.java).configureEach {
+      val stabilityDir = target.layout.buildDirectory.dir("stability").get()
+      outputs.dir(stabilityDir).optional(true)
+    }
+  }
+
+  private fun registerTasksNonAndroid(
+    target: Project,
+    extension: StabilityAnalyzerExtension,
+  ) {
     // Register stability dump task
     val stabilityDumpTask = target.tasks.register(
       "stabilityDump",
@@ -84,10 +104,10 @@ public class StabilityAnalyzerGradlePlugin : KotlinCompilerPluginSupportPlugin {
       StabilityCheckTask::class.java,
     ) {
       projectName.set(target.name)
-      stabilityInputFile.set(
+      stabilityInputFiles.from(
         target.layout.buildDirectory.file("stability/stability-info.json"),
       )
-      stabilityDir.set(extension.stabilityValidation.outputDir)
+      stabilityReferenceFiles.from(extension.stabilityValidation.outputDir)
       ignoredPackages.set(extension.stabilityValidation.ignoredPackages)
       ignoredClasses.set(extension.stabilityValidation.ignoredClasses)
       failOnStabilityChange.set(extension.stabilityValidation.failOnStabilityChange)
@@ -103,7 +123,88 @@ public class StabilityAnalyzerGradlePlugin : KotlinCompilerPluginSupportPlugin {
 
     // Configure after project evaluation
     target.afterEvaluate {
-      configureTaskDependencies(target, extension, stabilityDumpTask, stabilityCheckTask)
+      configureTaskDependencies(target, extension, null, stabilityDumpTask, stabilityCheckTask)
+      addRuntimeDependency(target)
+    }
+  }
+
+  private fun registerTasksAndroid(
+    target: Project,
+    extension: StabilityAnalyzerExtension,
+    androidComponents: AndroidComponentsExtension<*, *, *>,
+  ) {
+    val aggregateDumpTask = target.tasks.register("stabilityDump") {
+      group = "verification"
+      description = "Dump composable stability information to stability file"
+    }
+    val aggregateCheckTask = target.tasks.register("stabilityCheck") {
+      group = "verification"
+      description = "Check composable stability against reference file"
+    }
+
+    androidComponents.onVariants { variant ->
+      val variantNameLowerCase = variant.name.replaceFirstChar { it.lowercaseChar() }
+      val variantNameUpperCase = variant.name.replaceFirstChar { it.uppercaseChar() }
+
+      // Register stability dump task
+      val stabilityDumpTask = target.tasks.register(
+        "${variantNameLowerCase}StabilityDump",
+        StabilityDumpTask::class.java,
+      ) {
+        projectName.set(target.name)
+        stabilityInputFiles.setFrom(
+          target.layout.buildDirectory.file("stability/stability-info.json"),
+        )
+        outputDir.set(extension.stabilityValidation.outputDir)
+        ignoredPackages.set(extension.stabilityValidation.ignoredPackages)
+        ignoredClasses.set(extension.stabilityValidation.ignoredClasses)
+        stabilityFileSuffix.set(variant.name)
+      }
+
+      // Register stability check task
+      val stabilityCheckTask = target.tasks.register(
+        "${variantNameLowerCase}StabilityCheck",
+        StabilityCheckTask::class.java,
+      ) {
+        projectName.set(target.name)
+        stabilityInputFiles.from(
+          target.layout.buildDirectory.file("stability/stability-info.json"),
+        )
+        stabilityReferenceFiles.from(extension.stabilityValidation.outputDir)
+        ignoredPackages.set(extension.stabilityValidation.ignoredPackages)
+        ignoredClasses.set(extension.stabilityValidation.ignoredClasses)
+        failOnStabilityChange.set(extension.stabilityValidation.failOnStabilityChange)
+        quietCheck.set(extension.stabilityValidation.quietCheck)
+        stabilityFileSuffix.set(variant.name)
+      }
+
+      aggregateDumpTask.configure {
+        dependsOn(stabilityDumpTask)
+      }
+      aggregateCheckTask.configure {
+        dependsOn(stabilityCheckTask)
+      }
+
+      // Make check task depend on stabilityCheck if enabled (only if check task exists)
+      target.plugins.withId("base") {
+        target.tasks.named("check") {
+          dependsOn(stabilityCheckTask)
+        }
+      }
+
+      // Configure after project evaluation
+      target.afterEvaluate {
+        configureTaskDependencies(
+          target,
+          extension,
+          variantNameUpperCase,
+          stabilityDumpTask,
+          stabilityCheckTask,
+        )
+      }
+    }
+
+    target.afterEvaluate {
       addRuntimeDependency(target)
     }
   }
@@ -235,8 +336,10 @@ public class StabilityAnalyzerGradlePlugin : KotlinCompilerPluginSupportPlugin {
   private fun configureTaskDependencies(
     project: Project,
     extension: StabilityAnalyzerExtension,
+    filter: String? = null,
     stabilityDumpTask: org.gradle.api.tasks.TaskProvider<StabilityDumpTask>,
     stabilityCheckTask: org.gradle.api.tasks.TaskProvider<StabilityCheckTask>,
+
   ) {
     // Get the includeTests provider for lazy evaluation
     val includeTestsProvider = extension.stabilityValidation.includeTests
@@ -245,68 +348,88 @@ public class StabilityAnalyzerGradlePlugin : KotlinCompilerPluginSupportPlugin {
     stabilityDumpTask.configure {
       // Use provider to lazily collect Kotlin compile task names
       dependsOn(
-        project.provider {
-          val includeTests = includeTestsProvider.get()
+        includeTestsProvider.map { includeTests ->
           project.tasks.matching { task ->
-            val taskName = task.name
-            val taskNameLower = taskName.lowercase()
-
-            // Match only actual Kotlin compilation tasks, excluding infrastructure tasks
-            val isKotlinCompile = taskName.startsWith("compile") &&
-              taskName.contains("Kotlin") &&
-              // Exclude wasm-specific sync/webpack/executable tasks
-              !taskNameLower.contains("sync") &&
-              !taskNameLower.contains("webpack") &&
-              !taskNameLower.contains("executable") &&
-              !taskNameLower.contains("link") &&
-              !taskNameLower.contains("assemble")
-
-            val isTestTask = taskNameLower.let {
-              it.contains("test") || it.contains("androidtest") || it.contains("unittest")
-            }
-
-            // Include task if it's a Kotlin compile task and either:
-            // 1. includeTests is true, OR
-            // 2. it's not a test task
-            isKotlinCompile && (includeTests || !isTestTask)
+            isKotlinTaskApplicable(task.name, includeTests) &&
+              (filter == null || task.name.contains(filter))
           }
         },
       )
+
+      if (filter != null) {
+        // For now, stability check compiler plugin still creates the same files
+        // for different variant tasks. That means that even though our variant task
+        // is not dependent on the other-variant kotlin tasks, it is still implicitly coupled
+        // with them as it reads the same files. To mitigate for this,
+        // we tell Gradle that this task must run after any kotlin tasks, even
+        // if their variant does not match ours
+        mustRunAfter(
+          includeTestsProvider.map { includeTests ->
+            project.tasks.matching { task ->
+              isKotlinTaskApplicable(task.name, includeTests) &&
+                !task.name.contains(filter)
+            }
+          },
+        )
+      }
     }
 
     stabilityCheckTask.configure {
       // Use provider to lazily collect Kotlin compile task names
       dependsOn(
-        project.provider {
-          val includeTests = includeTestsProvider.get()
+        includeTestsProvider.map { includeTests ->
           project.tasks.matching { task ->
-            val taskName = task.name
-            val taskNameLower = taskName.lowercase()
-
-            // Match only actual Kotlin compilation tasks, excluding infrastructure tasks
-            val isKotlinCompile = taskName.startsWith("compile") &&
-              taskName.contains("Kotlin") &&
-              // Exclude wasm-specific sync/webpack/executable tasks
-              !taskNameLower.contains("sync") &&
-              !taskNameLower.contains("webpack") &&
-              !taskNameLower.contains("executable") &&
-              !taskNameLower.contains("link") &&
-              !taskNameLower.contains("assemble")
-
-            val isTestTask = taskNameLower.let {
-              it.contains("test") || it.contains("androidtest") || it.contains("unittest")
-            }
-
-            // Include task if it's a Kotlin compile task and either:
-            // 1. includeTests is true, OR
-            // 2. it's not a test task
-            isKotlinCompile && (includeTests || !isTestTask)
+            isKotlinTaskApplicable(task.name, includeTests) &&
+              (filter == null || task.name.contains(filter))
           }
         },
       )
+
+      if (filter != null) {
+        // For now, stability check compiler plugin still creates the same files
+        // for different variant tasks. That means that even though our variant task
+        // is not dependent on the other-variant kotlin tasks, it is still implicitly coupled
+        // with them as it reads the same files. To mitigate for this,
+        // we tell Gradle that this task must run after any kotlin tasks, even
+        // if their variant does not match ours
+        mustRunAfter(
+          includeTestsProvider.map { includeTests ->
+            project.tasks.matching { task ->
+              isKotlinTaskApplicable(
+                task.name,
+                includeTests,
+              ) &&
+                !task.name.contains(filter)
+            }
+          },
+        )
+      }
     }
   }
 
+  private fun isKotlinTaskApplicable(taskName: String, includeTests: Boolean): Boolean {
+    val taskNameLower = taskName.lowercase()
+
+    // Match only actual Kotlin compilation tasks, excluding infrastructure tasks
+    val isKotlinCompile = taskName.startsWith("compile") &&
+      taskName.contains("Kotlin") &&
+      // Exclude wasm-specific sync/webpack/executable tasks
+      !taskNameLower.contains("sync") &&
+      !taskNameLower.contains("webpack") &&
+      !taskNameLower.contains("executable") &&
+      !taskNameLower.contains("link") &&
+      !taskNameLower.contains("assemble")
+
+    val isTestTask = taskNameLower.let {
+      it.contains("test") || it.contains("androidtest") || it.contains("unittest")
+    }
+
+    // Include task if it's a Kotlin compile task and either:
+    // 1. includeTests is true, OR
+    // 2. it's not a test task
+    return isKotlinCompile && (includeTests || !isTestTask)
+  }
+
   /**
    * Check if a compilation is a test compilation.
    */
diff --git a/stability-gradle/src/main/kotlin/com/skydoves/compose/stability/gradle/StabilityCheckTask.kt b/stability-gradle/src/main/kotlin/com/skydoves/compose/stability/gradle/StabilityCheckTask.kt
diff --git a/stability-gradle/src/main/kotlin/com/skydoves/compose/stability/gradle/StabilityDumpTask.kt b/stability-gradle/src/main/kotlin/com/skydoves/compose/stability/gradle/StabilityDumpTask.kt
