Merge pull request #181 from gradle/gh/roomMergeIssue

Fix issues with room schema merge

Author: ghale

Diff for: .github/workflows/ci-check.yml

@@ -76,7 +76,7 @@ jobs:
     -   name: Setup NDK
         run: sudo $ANDROID_HOME/tools/bin/sdkmanager 'ndk;20.0.5594570'
 
-    # Patch issue in platform-tools 31.0.3 where platform-tools/api/api-versions.xml is missing
+    # Patch issue in platform-tools 31.0.3 where platform-tools/api/api-versions.xml is missing (see https://issuetracker.google.com/issues/195445762)
     -   name: Patch api-versions
         run: sudo test -f $ANDROID_HOME/platform-tools/api/api-versions.xml || (sudo mkdir $ANDROID_HOME/platform-tools/api && sudo cp .github/api-versions.xml $ANDROID_HOME/platform-tools/api/api-versions.xml)
 

Diff for: src/main/groovy/org/gradle/android/workarounds/RoomSchemaLocationWorkaround.groovy

@@ -1,10 +1,10 @@
 package org.gradle.android.workarounds
 
-
 import org.gradle.android.AndroidIssue
 import org.gradle.api.DefaultTask
 import org.gradle.api.Project
 import org.gradle.api.Task
+import org.gradle.api.execution.TaskExecutionGraph
 import org.gradle.api.file.ConfigurableFileCollection
 import org.gradle.api.file.Directory
 import org.gradle.api.file.DirectoryProperty
@@ -13,6 +13,7 @@ import org.gradle.api.internal.file.FileOperations
 import org.gradle.api.model.ObjectFactory
 import org.gradle.api.provider.Provider
 import org.gradle.api.tasks.Internal
+import org.gradle.api.tasks.Optional
 import org.gradle.api.tasks.OutputDirectory
 import org.gradle.api.tasks.TaskAction
 import org.gradle.api.tasks.TaskProvider
@@ -22,6 +23,7 @@ import org.gradle.util.VersionNumber
 
 import javax.inject.Inject
 import java.lang.reflect.Field
+import java.util.function.Supplier
 
 /**
  * Changes annotation processor arguments to set the room.schemaLocation via a CommandLineArgsProcessor
@@ -72,13 +74,18 @@ class RoomSchemaLocationWorkaround implements Workaround {
         // Grab fileOperations so we can do copy/sync operations
         def fileOperations = project.fileOperations
 
+        // An undefined directory property for use when providers are disabled
+        def nullDirectory = project.objects.directoryProperty()
+
         // Create a task that will be used to merge the task-specific schema locations to the directory (or directories)
         // originally specified.  This allows us to fan out the generated output and keep good cacheability for the
         // compile/kapt tasks but still join everything later in the location the user expects.
         TaskProvider<RoomSchemaLocationMergeTask> mergeTask = project.tasks.register("mergeRoomSchemaLocations", RoomSchemaLocationMergeTask) {
             roomSchemaMergeLocations = roomExtension.roomSchemaMergeLocations
         }
 
+        boolean javaCompileSchemaGenerationEnabled = true
+
         def configureVariant = { variant ->
             // Make sure that the annotation processor argument has not been explicitly configured in the Android
             // configuration (i.e. we only want this configured through the room extension
@@ -98,15 +105,21 @@ class RoomSchemaLocationWorkaround implements Workaround {
 
                 // Add a command line argument provider to the task-specific list of providers
                 task.options.compilerArgumentProviders.add(
-                    new JavaCompilerRoomSchemaLocationArgumentProvider(roomExtension.schemaLocationDir, taskSpecificSchemaDir)
+                    new JavaCompilerRoomSchemaLocationArgumentProvider(roomExtension.schemaLocationDir, taskSpecificSchemaDir, nullDirectory, { javaCompileSchemaGenerationEnabled } as Supplier)
                 )
 
                 // Register the generated schemas to be merged back to the original specified schema directory
-                roomExtension.registerOutputDirectory(taskSpecificSchemaDir)
+                task.project.gradle.taskGraph.whenReady { TaskExecutionGraph graph ->
+                    if (graph.hasTask(task)) {
+                        roomExtension.registerOutputDirectory(taskSpecificSchemaDir)
+                    }
+                }
 
                 // Seed the task-specific generated schema dir with the existing schemas
                 task.doFirst {
-                    copyExistingSchemasToTaskSpecificTmpDir(fileOperations, roomExtension.schemaLocationDir, taskSpecificSchemaDir)
+                    if (javaCompileSchemaGenerationEnabled) {
+                        copyExistingSchemasToTaskSpecificTmpDir(fileOperations, roomExtension.schemaLocationDir, taskSpecificSchemaDir)
+                    }
                 }
 
                 task.finalizedBy { roomExtension.schemaLocationDir.isPresent() ? mergeTask : null }
@@ -122,10 +135,7 @@ class RoomSchemaLocationWorkaround implements Workaround {
             applyToAllAndroidVariants(project) { variant ->
                 def variantSpecificSchemaDir = project.objects.directoryProperty()
                 variantSpecificSchemaDir.set(getVariantSpecificSchemaDir(project, "kapt${variant.name.capitalize()}Kotlin"))
-                variant.javaCompileOptions.annotationProcessorOptions.compilerArgumentProviders.add(new KaptRoomSchemaLocationArgumentProvider(roomExtension.schemaLocationDir, variantSpecificSchemaDir))
-
-                // Register the variant-specific directory with the merge task
-                roomExtension.registerOutputDirectory(variantSpecificSchemaDir)
+                variant.javaCompileOptions.annotationProcessorOptions.compilerArgumentProviders.add(new KaptRoomSchemaLocationArgumentProvider(roomExtension.schemaLocationDir, variantSpecificSchemaDir, nullDirectory))
             }
 
             // Kapt tasks will remove the contents of any output directories, which will interfere with any additional
@@ -148,27 +158,24 @@ class RoomSchemaLocationWorkaround implements Workaround {
                 }
 
                 task.finalizedBy onlyIfAnnotationProcessorConfiguredForKapt(annotationProcessorOptionProviders) { roomExtension.schemaLocationDir.isPresent() ? mergeTask : null }
+
+                TaskExecutionGraph taskGraph = task.project.gradle.taskGraph
+                taskGraph.whenReady onlyIfAnnotationProcessorConfiguredForKapt(annotationProcessorOptionProviders) { KaptRoomSchemaLocationArgumentProvider provider ->
+                    if (taskGraph.hasTask(task)) {
+                        // Register the variant-specific directory with the merge task
+                        roomExtension.registerOutputDirectory(provider.schemaLocationDir)
+                    }
+                }
             }
 
             project.tasks.withType(kaptWithoutKotlincTaskClass).configureEach(configureKaptTask)
             project.tasks.withType(kaptWithKotlincTaskClass).configureEach(configureKaptTask)
 
-            // Since we've added a new kapt-specific provider to the variant, go through the
-            // JavaCompile tasks and remove this provider from its task-specific list so that
-            // it only has its JavaCompile-specific provider.  This is not great, but there
+            // Since we've added a new kapt-specific provider to the variant, disable the provider
+            // used for the JavaCompile task.  This is not great, but there
             // does not seem to be a way around this with the way the kotlin android plugin
             // maps annotation processor providers from the variant directly onto kapt tasks.
-            project.afterEvaluate {
-                project.tasks.withType(JavaCompile).configureEach { JavaCompile task ->
-                    def itr = task.options.compilerArgumentProviders.iterator()
-                    while (itr.hasNext()) {
-                        def provider = itr.next()
-                        if (provider instanceof KaptRoomSchemaLocationArgumentProvider) {
-                            itr.remove()
-                        }
-                    }
-                }
-            }
+            javaCompileSchemaGenerationEnabled = false
         }
     }
 
@@ -295,12 +302,20 @@ class RoomSchemaLocationWorkaround implements Workaround {
         @Internal
         final Provider<Directory> configuredSchemaLocationDir
 
-        @OutputDirectory
+        @Internal
         final Provider<Directory> schemaLocationDir
 
-        RoomSchemaLocationArgumentProvider(Provider<Directory> configuredSchemaLocationDir, Provider<Directory> schemaLocationDir) {
+        @Internal
+        final Supplier<Boolean> enabled
+
+        @Internal
+        final Provider<Directory> nullDirectory
+
+        RoomSchemaLocationArgumentProvider(Provider<Directory> configuredSchemaLocationDir, Provider<Directory> schemaLocationDir, Provider<Directory> nullDirectory, Supplier<Boolean> enabled) {
             this.configuredSchemaLocationDir = configuredSchemaLocationDir
+            this.enabled = enabled
             this.schemaLocationDir = schemaLocationDir
+            this.nullDirectory = nullDirectory
         }
 
         @Internal
@@ -310,25 +325,31 @@ class RoomSchemaLocationWorkaround implements Workaround {
 
         @Override
         Iterable<String> asArguments() {
-            if (configuredSchemaLocationDir.isPresent()) {
+            if (configuredSchemaLocationDir.isPresent() && enabled.get()) {
                 return ["-A${ROOM_SCHEMA_LOCATION}=${schemaLocationPath}" as String]
             } else {
                 return []
             }
         }
+
+        @OutputDirectory
+        @Optional
+        Provider<Directory> getEffectiveSchemaLocationDir() {
+            return enabled.get() ? schemaLocationDir : nullDirectory
+        }
     }
 
     static class JavaCompilerRoomSchemaLocationArgumentProvider extends RoomSchemaLocationArgumentProvider {
-        JavaCompilerRoomSchemaLocationArgumentProvider(Provider<Directory> configuredSchemaLocationDir, Provider<Directory> schemaLocationDir) {
-            super(configuredSchemaLocationDir, schemaLocationDir)
+        JavaCompilerRoomSchemaLocationArgumentProvider(Provider<Directory> configuredSchemaLocationDir, Provider<Directory> schemaLocationDir, Provider<Directory> nullDirectory, Supplier<Boolean> enabled) {
+            super(configuredSchemaLocationDir, schemaLocationDir, nullDirectory, enabled)
         }
     }
 
     static class KaptRoomSchemaLocationArgumentProvider extends RoomSchemaLocationArgumentProvider {
         private Provider<Directory> temporarySchemaLocationDir
 
-        KaptRoomSchemaLocationArgumentProvider(Provider<Directory> configuredSchemaLocationDir, Provider<Directory> schemaLocationDir) {
-            super(configuredSchemaLocationDir, schemaLocationDir)
+        KaptRoomSchemaLocationArgumentProvider(Provider<Directory> configuredSchemaLocationDir, Provider<Directory> schemaLocationDir, Provider<Directory> nullDirectory) {
+            super(configuredSchemaLocationDir, schemaLocationDir, nullDirectory, { true } as Supplier<Boolean>)
             this.temporarySchemaLocationDir = schemaLocationDir.map {it.dir("../${it.asFile.name}Temp") }
         }