Merge pull request #143 from gradle/dd/config-cache

Make plugin compatible with configuration-cache

Author: bigdaz

src/main/groovy/org/gradle/android/workarounds/CompileLibraryResourcesWorkaround_4_2.groovy

@@ -22,10 +22,10 @@ class CompileLibraryResourcesWorkaround_4_2 implements Workaround {
         return Class.forName('com.android.build.gradle.tasks.CompileLibraryResourcesTask')
     }
 
-    String propertyName = "inputDirectories"
+    static final String PROPERTY_NAME = "inputDirectories"
 
-    public void setPropertyValue(Task task, ConfigurableFileCollection directoryProperty) {
-        Field field = task.class.getDeclaredFields().find { it.name == "__${propertyName}__" }
+    public static void setPropertyValue(Task task, ConfigurableFileCollection directoryProperty) {
+        Field field = task.class.getDeclaredFields().find { it.name == "__${PROPERTY_NAME}__" }
         field.setAccessible(true)
         field.set(task, directoryProperty)
     }
@@ -38,20 +38,20 @@ class CompileLibraryResourcesWorkaround_4_2 implements Workaround {
             // Create a synthetic input with the original property value and RELATIVE path sensitivity
             task.inputs.files(originalPropertyValue)
                 .withPathSensitivity(PathSensitivity.RELATIVE)
-                .withPropertyName("${propertyName}.workaround")
+                .withPropertyName("${PROPERTY_NAME}.workaround")
                 .optional()
-            project.gradle.taskGraph.beforeTask {
-                if (it == task) {
-                    originalPropertyValue.from(task.getProperty(propertyName))
-                    def dummyProperty = project.objects.fileCollection()
-                    // Non-existent file to give the ConfigurableFileCollection a value.
-                    dummyProperty.setFrom(project.file('/doesnt-exist'))
-                    setPropertyValue(task, dummyProperty)
+            project.gradle.taskGraph.whenReady {
+                originalPropertyValue.from(task.getProperty(PROPERTY_NAME))
+                def dummyProperty = project.objects.fileCollection()
+                // Non-existent file to give the ConfigurableFileCollection a value.
+                dummyProperty.setFrom(project.file('/doesnt-exist'))
+                setPropertyValue(task, dummyProperty)
+
+                // Set the task property back to its original value
+                task.doFirst {
+                    setPropertyValue(it, originalPropertyValue)
                 }
-            }
-            // Set the task property back to its original value
-            task.doFirst {
-                setPropertyValue(task, originalPropertyValue)
+
             }
         }
     }

src/main/groovy/org/gradle/android/workarounds/MergeResourcesWorkaround.groovy

@@ -3,6 +3,7 @@ package org.gradle.android.workarounds
 import org.gradle.android.AndroidIssue
 import org.gradle.api.Project
 import org.gradle.api.Task
+import org.gradle.api.execution.TaskExecutionGraph
 import org.gradle.api.file.FileCollection
 import org.gradle.api.provider.MapProperty
 import org.gradle.api.tasks.PathSensitivity
@@ -27,16 +28,14 @@ class MergeResourcesWorkaround implements Workaround {
             task.inputs.files(originalResources.map {it.values() })
                 .withPathSensitivity(PathSensitivity.RELATIVE)
                 .withPropertyName("rawLocalResources.workaround")
-            project.gradle.taskGraph.beforeTask {
-                if (it == task) {
-                    task.resourcesComputer.resources.each { key, value -> originalResources.put(key, value) }
-                    task.resourcesComputer.resources.clear()
+            project.gradle.taskGraph.whenReady { TaskExecutionGraph executionGraph ->
+                task.resourcesComputer.resources.each { key, value -> originalResources.put(key, value) }
+                task.resourcesComputer.resources.clear()
+                // Set the source back to its original value before we execute the main task action
+                task.doFirst {
+                    it.resourcesComputer.resources.putAll(originalResources.get())
                 }
             }
-            // Set the source back to its original value before we execute the main task action
-            task.doFirst {
-                task.resourcesComputer.resources.putAll(originalResources.get())
-            }
         }
     }
 

src/main/groovy/org/gradle/android/workarounds/RoomSchemaLocationWorkaround.groovy

@@ -9,6 +9,7 @@ import org.gradle.api.file.ConfigurableFileCollection
 import org.gradle.api.file.Directory
 import org.gradle.api.file.DirectoryProperty
 import org.gradle.api.file.DuplicatesStrategy
+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
@@ -92,6 +93,8 @@ class RoomSchemaLocationWorkaround implements Workaround {
                 def taskSpecificSchemaDir = project.objects.directoryProperty()
                 taskSpecificSchemaDir.set(getTaskSpecificSchemaDir(task))
 
+                def fileOperations = project.fileOperations
+
                 // Add a command line argument provider to the task-specific list of providers
                 task.options.compilerArgumentProviders.add(
                     new JavaCompilerRoomSchemaLocationArgumentProvider(roomExtension.schemaLocationDir, taskSpecificSchemaDir)
@@ -102,7 +105,7 @@ class RoomSchemaLocationWorkaround implements Workaround {
 
                 // Seed the task-specific generated schema dir with the existing schemas
                 task.doFirst {
-                    copyExistingSchemasToTaskSpecificTmpDir(task, roomExtension.schemaLocationDir, taskSpecificSchemaDir)
+                    copyExistingSchemasToTaskSpecificTmpDir(fileOperations, roomExtension.schemaLocationDir, taskSpecificSchemaDir)
                 }
 
                 task.finalizedBy { roomExtension.schemaLocationDir.isPresent() ? mergeTask : null }
@@ -133,7 +136,7 @@ class RoomSchemaLocationWorkaround implements Workaround {
             def configureKaptTask = { Task task ->
                 task.doFirst onlyIfAnnotationProcessorConfiguredForKapt(task) { KaptRoomSchemaLocationArgumentProvider provider ->
                     // Populate the variant-specific schemas dir with the existing schemas
-                    copyExistingSchemasToTaskSpecificTmpDirForKapt(task, roomExtension.schemaLocationDir, provider)
+                    copyExistingSchemasToTaskSpecificTmpDirForKapt(project.fileOperations, roomExtension.schemaLocationDir, provider)
                 }
 
                 task.doLast onlyIfAnnotationProcessorConfiguredForKapt(task) { KaptRoomSchemaLocationArgumentProvider provider ->
@@ -204,24 +207,25 @@ class RoomSchemaLocationWorkaround implements Workaround {
         return new File(schemaBaseDir, variantName)
     }
 
-    private static void copyExistingSchemasToTaskSpecificTmpDir(Task task, Provider<Directory> existingSchemaDir, Provider<Directory> taskSpecificTmpDir) {
+    private static void copyExistingSchemasToTaskSpecificTmpDir(FileOperations fileOperations, Provider<Directory> existingSchemaDir, Provider<Directory> taskSpecificTmpDir) {
         // populate the task-specific tmp dir with any existing (non-generated) schemas
         // this allows other annotation processors that might operate on these schemas
         // to find them via the schema location argument
         if (existingSchemaDir.isPresent()) {
-            task.project.sync {
-                from existingSchemaDir
-                into taskSpecificTmpDir
+
+            fileOperations.sync {
+                it.from(existingSchemaDir)
+                it.into(taskSpecificTmpDir)
             }
         }
     }
 
-    private static void copyExistingSchemasToTaskSpecificTmpDirForKapt(Task task, Provider<Directory> existingSchemaDir, KaptRoomSchemaLocationArgumentProvider provider) {
+    private static void copyExistingSchemasToTaskSpecificTmpDirForKapt(FileOperations fileOperations, Provider<Directory> existingSchemaDir, KaptRoomSchemaLocationArgumentProvider provider) {
         // Derive the variant directory from the command line provider it is configured with
         def temporaryVariantSpecificSchemaDir = provider.temporarySchemaLocationDir
 
         // Populate the variant-specific temporary schema dir with the existing schemas
-        copyExistingSchemasToTaskSpecificTmpDir(task, existingSchemaDir, temporaryVariantSpecificSchemaDir)
+        copyExistingSchemasToTaskSpecificTmpDir(fileOperations, existingSchemaDir, temporaryVariantSpecificSchemaDir)
     }
 
     private static void copyGeneratedSchemasToOutputDirForKapt(Task task, KaptRoomSchemaLocationArgumentProvider provider) {
@@ -362,18 +366,22 @@ class RoomSchemaLocationWorkaround implements Workaround {
      * We don't want to create task dependencies on the compile/kapt tasks because we don't want to force execution
      * of those tasks if only a single variant is being assembled.
      */
-    static class RoomSchemaLocationMergeTask extends DefaultTask {
+    static abstract class RoomSchemaLocationMergeTask extends DefaultTask {
+
+        // Using older internal API to maintain compatibility with Gradle 5.x
+        @Inject abstract FileOperations getFileOperations()
+
         @Internal
         MergeAssociations roomSchemaMergeLocations
 
         @TaskAction
         void mergeSourcesToDestinations() {
             roomSchemaMergeLocations.mergeAssociations.each { destination, source ->
                 println "Merging schemas to ${destination.get().asFile}"
-                project.copy {
-                    duplicatesStrategy(DuplicatesStrategy.INCLUDE)
-                    into(destination)
-                    from(source)
+                fileOperations.copy {
+                    it.duplicatesStrategy = DuplicatesStrategy.INCLUDE
+                    it.into(destination)
+                    it.from(source)
                 }
             }
         }

src/test/groovy/org/gradle/android/ConfigurationCachingTest.groovy

@@ -0,0 +1,21 @@
+package org.gradle.android
+
+class ConfigurationCachingTest extends AbstractTest {
+    def "Can run with configuration cache"() {
+        given:
+        SimpleAndroidApp.builder(temporaryFolder.root, cacheDir)
+                .withAndroidVersion(Versions.latestAndroidVersion())
+                .withKotlinDisabled()
+                .build()
+                .writeProject()
+
+        when:
+        def result = withGradleVersion(Versions.latestGradleVersion().version)
+                .withProjectDir(temporaryFolder.root)
+                .withArguments('--configuration-cache', 'assembleDebug')
+                .build()
+
+        then:
+        !result.output.contains("problems were found storing the configuration cache")
+    }
+}