Update HiltGradlePlugin to AGP 9.

This required a number of changes:

   * Update Gradle 8.14.3 -> 9.2.0
   * Update shadow plugin from `com.github.johnrengelman.shadow:8.1.1` to 'com.gradleup.shadow:9.2.2' (old artifact doesn't support Gradle 9).
   * Update HiltGradlePlugin to 9.0.0-beta02:
     * Migrate `BaseExtension` to `AndroidComponentsExtension`
     * Migrate `BaseVariant` to `Component`
     * Migrate `variant.javaCompileOutput.classpath` to `variant.compileClasspath`
     * Migrate `variant.javaCompileOutput.destinationDirectory` to `variant.artifacts.use(HiltCopyTask).toGet()`
     * Migrate `variant.javaCompileOutput.options.bootstrapClasspath` with `androidExtension.sdkComponents.bootClasspath`
     * Migrate `variant.javaCompileOutput.options.compilerArgumentProviders` with `variant.javaCompilation.annotationProcessor.argumentProviders`
     * `project.buildDir = ...` to `project.layout.buildDirectory.set(...)`
   * Update HiltGradlePlugin tests to use AGP 9.0.0-beta02:
     * Migrate to builtin kotlin
       * remove 'kotlin-android'
       * replace 'kotlin-kapt' with 'legacy-kapt'
     * Migrate javatests/artifacts/hilt-android/simple/app/build.gradle to kts and replace GradleVersion with custom AgpVersion.
       The GradleVersion does not work with APG versions like 9.0.0-beta02, so I had to do this with custom parsing.
     * remove `android.kotlinOptions` (removed in AGP 9)

RELNOTES=N/A
PiperOrigin-RevId: 837566667

Author: bcorso

.github/workflows/ci.yml

@@ -14,7 +14,7 @@ concurrency:
   cancel-in-progress: ${{ github.ref != 'refs/heads/master' }}
 
 env:
-  USE_AGP_VERSION: '8.13.0'
+  USE_AGP_VERSION: '9.0.0-beta02'
   USE_JAVA_DISTRIBUTION: 'zulu'
   USE_JAVA_VERSION_FOR_BAZEL: '21'
   USE_JAVA_VERSION_FOR_GRADLE: '21'

.github/workflows/release.yml

@@ -13,7 +13,7 @@ concurrency:
   cancel-in-progress: ${{ github.ref != 'refs/heads/master' }}
 
 env:
-  USE_AGP_VERSION: '8.13.0'
+  USE_AGP_VERSION: '9.0.0-beta02'
   USE_JAVA_DISTRIBUTION: 'zulu'
   USE_JAVA_VERSION_FOR_BAZEL: '21'
   USE_JAVA_VERSION_FOR_GRADLE: '21'

java/dagger/hilt/android/plugin/build.gradle

@@ -1,7 +1,7 @@
 buildscript {
   ext {
     kotlin_version = "2.2.0"
-    agp_version = System.getenv('AGP_VERSION')
+    agp_version = System.getenv('AGP_VERSION') ?: "9.0.0-beta02"
     ksp_version = "$kotlin_version-2.0.2"
     pluginArtifactId = 'hilt-android-gradle-plugin'
     pluginId = 'com.google.dagger.hilt.android'
@@ -12,7 +12,7 @@ plugins {
   id 'org.jetbrains.kotlin.jvm' version "$kotlin_version"
   id 'java-gradle-plugin'
   id 'maven-publish'
-  id 'com.github.johnrengelman.shadow' version '8.1.1'
+  id 'com.gradleup.shadow' version '9.2.2'
   id 'org.jetbrains.kotlin.android' version "$kotlin_version" apply false
 }
 
@@ -24,10 +24,10 @@ allprojects {
 }
 
 // Avoids conflict with BUILD file
-project.buildDir = 'buildOut'
+project.layout.buildDirectory.set(file('buildOut'))
 
-subprojects {
-    project.buildDir = 'buildOut'
+subprojects {subproject ->
+    subproject.layout.buildDirectory.set(file('buildOut'))
     afterEvaluate {
         dependencies {
             // This is needed to align older versions of kotlin-stdlib.

java/dagger/hilt/android/plugin/buildSrc/build.gradle.kts

@@ -0,0 +1,8 @@
+plugins {
+  `kotlin-dsl`
+}
+
+repositories {
+  google()
+  mavenCentral()
+}

java/dagger/hilt/android/plugin/buildSrc/src/main/kotlin/dagger/hilt/android/plugin/task/ImportSharedLibTask.kt

@@ -0,0 +1,77 @@
+/*
+ * Copyright (C) 2025 The Dagger Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dagger.hilt.android.plugin.task
+
+import java.io.ByteArrayOutputStream
+import java.io.File
+import javax.inject.Inject
+import org.gradle.api.DefaultTask
+import org.gradle.api.GradleException
+import org.gradle.api.file.DirectoryProperty
+import org.gradle.api.tasks.OutputDirectory
+import org.gradle.api.tasks.TaskAction
+import org.gradle.process.ExecOperations
+
+abstract class ImportSharedLibTask @Inject constructor(
+  private val execOperations: ExecOperations
+) : DefaultTask() {
+
+  @get:OutputDirectory
+  abstract val outputDir: DirectoryProperty
+
+  @TaskAction
+  fun execute() {
+    val bazelOutput = ByteArrayOutputStream()
+    val buildResult = execOperations.exec {
+      this.commandLine(BUILD_CMD, "build", "import-shared-lib")
+      this.standardOutput = bazelOutput
+      this.errorOutput = bazelOutput
+    }
+    buildResult.assertNormalExitValue()
+
+    val genFilesDir = project.buildFile.parentFile.findFileInPath(BUILD_DIR)
+      ?: throw GradleException("Couldn't find build folder '$BUILD_DIR'.")
+
+    val libPath = bazelOutput.toString().split('\n').find { it.contains("$BUILD_DIR/")}?.trim()
+      ?: throw GradleException("Couldn't find library path in $BUILD_CMD's output ($BUILD_DIR).")
+
+    val inputFile = project.file("$genFilesDir/$libPath")
+    val outputFile = outputDir.file(inputFile.name).get().asFile
+    inputFile.inputStream().use { input ->
+      outputFile.outputStream().use { output ->
+        input.copyTo(output)
+      }
+    }
+  }
+
+  companion object {
+    const val BUILD_CMD = "bazel"
+    const val BUILD_DIR = "bazel-bin"
+
+    /** Finds the file in the current directory, its parent directories, or returns null. */
+    private fun File?.findFileInPath(fileName: String): File? {
+      if (this == null || !isDirectory) {
+        return null
+      }
+      return if (File(this, fileName).exists()) {
+        this
+      } else {
+        parentFile.findFileInPath(fileName)
+      }
+    }
+  }
+}

java/dagger/hilt/android/plugin/gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.14.3-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-9.2.0-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

java/dagger/hilt/android/plugin/main/build.gradle

@@ -15,14 +15,14 @@
  */
 import java.util.zip.ZipEntry
 import java.util.zip.ZipFile
-import org.jetbrains.kotlin.gradle.dsl.JvmTarget
+import dagger.hilt.android.plugin.task.ImportSharedLibTask
 import org.jetbrains.kotlin.gradle.dsl.KotlinVersion
 
 plugins {
   id 'org.jetbrains.kotlin.jvm'
   id 'java-gradle-plugin'
   id 'maven-publish'
-  id 'com.github.johnrengelman.shadow'
+  id 'com.gradleup.shadow'
 }
 
 configurations {
@@ -67,6 +67,7 @@ dependencies {
   // Use compile-only for other plugin dependencies to avoid brining those
   // to projects that don't use them.
   compileOnly "com.android.tools.build:gradle:$agp_version"
+  compileOnly "com.android.legacy-kapt:com.android.legacy-kapt.gradle.plugin:$agp_version"
   compileOnly "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
   compileOnly "com.google.devtools.ksp:symbol-processing-gradle-plugin:$ksp_version"
 
@@ -79,6 +80,7 @@ dependencies {
   testImplementation 'com.google.truth:truth:1.0.1'
   testImplementation 'org.javassist:javassist:3.26.0-GA'
   testPluginCompile "com.android.tools.build:gradle:$agp_version"
+  testPluginCompile "com.android.legacy-kapt:com.android.legacy-kapt.gradle.plugin:$agp_version"
   testPluginCompile "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
   testPluginCompile "com.google.devtools.ksp:symbol-processing-gradle-plugin:$ksp_version"
 }
@@ -105,42 +107,8 @@ kotlin {
 
 // Imports a shared library from the main project. The library and its classes
 // will be shadowed in the plugin's artifact.
-tasks.register("importSharedLib").configure {
-  def outputDir = file("${project.projectDir}/libs")
-  outputs.dir(outputDir)
-  doLast {
-    def buildCmd = 'bazel'
-    def buildDir = 'bazel-bin'
-    def findGenFilesParent
-    findGenFilesParent = { File dir ->
-      if (dir == null || !dir.isDirectory()) {
-        return null
-      }
-      if (new File(dir, buildDir).exists()) {
-        return dir
-      } else {
-        return findGenFilesParent(dir.parentFile)
-      }
-    }
-    // Build shared lib
-    def bazelOutput = new ByteArrayOutputStream()
-    def buildResult = exec {
-      commandLine buildCmd, 'build', 'import-shared-lib'
-      standardOutput = bazelOutput
-      errorOutput = bazelOutput
-    }
-    buildResult.assertNormalExitValue()
-    // Find shared lib Jar in build directory.
-    def genFilesDir = findGenFilesParent(project.buildFile.parentFile)
-    if (genFilesDir == null) {
-      throw new GradleException("Couldn't find build folder '$buildDir'")
-    }
-    def libPath = bazelOutput.toString().split('\n')
-      .find { line -> line.contains("$buildDir/") }.trim()
-    def inputFile = file("$genFilesDir/$libPath")
-    def outputFile = file("$outputDir/${inputFile.name}")
-    outputFile << inputFile.newInputStream()
-  }
+tasks.register("importSharedLib", ImportSharedLibTask) {
+    outputDir.set(file("${project.projectDir}/libs"))
 }
 tasks.getByName('compileKotlin').dependsOn('importSharedLib')