gradle plugin works (TM)

Author: dconeybe

dataconnect/buildSrc/src/main/kotlin/com/google/firebase/example/dataconnect/gradle/DataConnectGradlePlugin.kt

@@ -18,35 +18,51 @@ package com.google.firebase.example.dataconnect.gradle
 
 import com.android.build.api.variant.ApplicationAndroidComponentsExtension
 import com.android.build.api.variant.ApplicationVariant
+import java.util.Locale
 import org.gradle.api.Plugin
 import org.gradle.api.Project
+import org.gradle.api.file.Directory
+import org.gradle.api.file.RegularFile
+import org.gradle.api.provider.Provider
 import org.gradle.kotlin.dsl.getByType
 import org.gradle.kotlin.dsl.register
-import java.util.Locale
 
 @Suppress("unused")
 abstract class DataConnectGradlePlugin : Plugin<Project> {
 
     override fun apply(project: Project) {
+        val buildDirectory = project.layout.buildDirectory.dir("dataconnect")
+
+        val setupFirebaseToolsTask = project.tasks.register<SetupFirebaseToolsTask>("setupFirebaseToolsForDataConnect") {
+            version.set("13.23.0")
+            outputDirectory.set(buildDirectory.map { it.dir("firebase-tools") })
+        }
+        val firebaseExecutable = setupFirebaseToolsTask.flatMap { it.firebaseExecutable }
+
         val androidComponents = project.extensions.getByType<ApplicationAndroidComponentsExtension>()
-        androidComponents.onVariants {
-            this@DataConnectGradlePlugin.registerTasks(project, it)
+        androidComponents.onVariants { variant ->
+            val variantBuildDirectory = buildDirectory.map { it.dir("variants/${variant.name}") }
+            this@DataConnectGradlePlugin.registerVariantTasks(
+                project=project,
+                variant=variant,
+                buildDirectoryProvider=variantBuildDirectory,
+                firebaseExecutableProvider=firebaseExecutable,
+            )
         }
     }
 
-    private fun registerTasks(project: Project, variant: ApplicationVariant) {
+    private fun registerVariantTasks(
+        project: Project,
+        variant: ApplicationVariant,
+        buildDirectoryProvider: Provider<Directory>,
+        firebaseExecutableProvider: Provider<RegularFile>,
+    ) {
         val variantNameTitleCase = variant.name.replaceFirstChar { it.titlecase(Locale.US) }
-        val buildDirectory = project.layout.buildDirectory.dir("dataconnect/${variant.name}")
-
-        val setupFirebaseToolsTask = project.tasks.register<SetupFirebaseToolsTask>("setupFirebaseTools$variantNameTitleCase") {
-            version.set("13.23.0")
-            outputDirectory.set(buildDirectory.map { it.dir("firebase-tools") })
-        }
 
-        val generateCodeTask = project.tasks.register<GenerateCodeTask>("generateDataConnectSources${variantNameTitleCase}") {
+        val generateCodeTask = project.tasks.register<GenerateCodeTask>("generate${variantNameTitleCase}DataConnectSources") {
             inputDirectory.set(project.layout.projectDirectory.dir("../dataconnect"))
-            firebaseExecutable.set(setupFirebaseToolsTask.flatMap { it.firebaseExecutable })
-            workDirectory.set(buildDirectory.map { it.dir("generateCodeTaskWorkDir") })
+            firebaseExecutable.set(firebaseExecutableProvider)
+            tweakedConnectorsDirectory.set(buildDirectoryProvider.map { it.dir("tweakedConnectors") })
         }
 
         variant.sources.java!!.addGeneratedSourceDirectory(

dataconnect/buildSrc/src/main/kotlin/com/google/firebase/example/dataconnect/gradle/GenerateCodeTask.kt

@@ -20,47 +20,48 @@ import java.io.File
 import org.gradle.api.DefaultTask
 import org.gradle.api.file.DirectoryProperty
 import org.gradle.api.file.RegularFileProperty
-import org.gradle.api.tasks.InputFiles
+import org.gradle.api.tasks.InputDirectory
+import org.gradle.api.tasks.InputFile
 import org.gradle.api.tasks.Internal
 import org.gradle.api.tasks.OutputDirectory
 import org.gradle.api.tasks.TaskAction
 
 abstract class GenerateCodeTask : DefaultTask() {
 
-    @get:InputFiles
+    @get:InputDirectory
     abstract val inputDirectory: DirectoryProperty
 
-    @get:InputFiles
+    @get:InputFile
     abstract val firebaseExecutable: RegularFileProperty
 
     @get:OutputDirectory
     abstract val outputDirectory: DirectoryProperty
 
     @get:Internal
-    abstract val workDirectory: DirectoryProperty
+    abstract val tweakedConnectorsDirectory: DirectoryProperty
 
     @TaskAction
     fun run() {
         val inputDirectory = inputDirectory.get().asFile
         val firebaseExecutable = firebaseExecutable.get().asFile
         val outputDirectory = outputDirectory.get().asFile
-        val workDirectory = workDirectory.get().asFile
+        val tweakedConnectorsDirectory = tweakedConnectorsDirectory.get().asFile
 
         logger.info("inputDirectory: {}", inputDirectory)
         logger.info("firebaseExecutable: {}", firebaseExecutable)
         logger.info("outputDirectory: {}", outputDirectory)
-        logger.info("workDirectory: {}", workDirectory)
+        logger.info("tweakedConnectorsDirectory: {}", tweakedConnectorsDirectory)
 
         project.delete(outputDirectory)
-        project.delete(workDirectory)
-        project.mkdir(workDirectory)
+        project.delete(tweakedConnectorsDirectory)
+        project.mkdir(tweakedConnectorsDirectory)
 
         project.copy {
             from(inputDirectory)
-            into(workDirectory)
+            into(tweakedConnectorsDirectory)
         }
 
-        val connectorYamlFile = workDirectory.resolve("movie-connector/connector.yaml")
+        val connectorYamlFile = tweakedConnectorsDirectory.resolve("movie-connector/connector.yaml")
         val outputFileLineRegex = Regex("""(\s*outputDir:\s*).*""")
         val connectorYamlOriginalLines = connectorYamlFile.readLines(Charsets.UTF_8)
         val connectorYamlUpdatedLines = connectorYamlOriginalLines.map {
@@ -81,7 +82,7 @@ abstract class GenerateCodeTask : DefaultTask() {
                     // Specify a fake project because dataconnect:sdk:generate unnecessarily
                     // requires one. The actual value does not matter.
                     args("--project", "zzyzx")
-                    workingDir(workDirectory)
+                    workingDir(tweakedConnectorsDirectory)
                     isIgnoreExitValue = false
                     if (logStream !== null) {
                         standardOutput = logStream

dataconnect/buildSrc/src/main/kotlin/com/google/firebase/example/dataconnect/gradle/SetupFirebaseToolsTask.kt

@@ -23,8 +23,8 @@ import org.gradle.api.file.RegularFile
 import org.gradle.api.provider.Property
 import org.gradle.api.provider.Provider
 import org.gradle.api.tasks.Input
+import org.gradle.api.tasks.Internal
 import org.gradle.api.tasks.OutputDirectory
-import org.gradle.api.tasks.OutputFile
 import org.gradle.api.tasks.TaskAction
 
 abstract class SetupFirebaseToolsTask : DefaultTask() {
@@ -35,20 +35,17 @@ abstract class SetupFirebaseToolsTask : DefaultTask() {
     @get:OutputDirectory
     abstract val outputDirectory: DirectoryProperty
 
-    @get:OutputFile
-    val firebaseExecutable: Provider<RegularFile> = project.providers.provider {
-        outputDirectory.file("node_modules/.bin/firebase").get()
-    }
+    @get:Internal
+    val firebaseExecutable: Provider<RegularFile> get() =
+        outputDirectory.map { it.file("node_modules/.bin/firebase") }
 
     @TaskAction
     fun run() {
         val version: String = version.get()
         val outputDirectory: File = outputDirectory.get().asFile
-        val firebaseExecutable: File = firebaseExecutable.get().asFile
 
         logger.info("version: {}", version)
         logger.info("outputDirectory: {}", outputDirectory.absolutePath)
-        logger.info("firebaseExecutable: {}", firebaseExecutable.absolutePath)
 
         project.delete(outputDirectory)
         project.mkdir(outputDirectory)
@@ -74,13 +71,5 @@ abstract class SetupFirebaseToolsTask : DefaultTask() {
             npmInstallLogFile?.let { logger.warn("{}", it.readText()) }
             throw exception
         }
-
-        if (!firebaseExecutable.exists()) {
-            throw SetupFirebaseToolsTaskException("npm install was expected to create the file " +
-            "${firebaseExecutable.absolutePath}, but it does not exist " +
-            "(error code mr7dwmhwtv)")
-        }
     }
-
-    class SetupFirebaseToolsTaskException(message: String): Exception(message)
 }