Support configuration caching

gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +1,5 @@
-#Mon Jul 06 17:13:48 BST 2020
-distributionUrl=https\://services.gradle.org/distributions/gradle-6.5.1-all.zip
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-zipStorePath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-6.6-rc-6-all.zip
 zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists

gradlew.bat

@@ -40,7 +40,7 @@ if defined JAVA_HOME goto findJavaFromJavaHome
 
 set JAVA_EXE=java.exe
 %JAVA_EXE% -version >NUL 2>&1
-if "%ERRORLEVEL%" == "0" goto init
+if "%ERRORLEVEL%" == "0" goto execute
 
 echo.
 echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
@@ -54,7 +54,7 @@ goto fail
 set JAVA_HOME=%JAVA_HOME:"=%
 set JAVA_EXE=%JAVA_HOME%/bin/java.exe
 
-if exist "%JAVA_EXE%" goto init
+if exist "%JAVA_EXE%" goto execute
 
 echo.
 echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
@@ -64,29 +64,14 @@ echo location of your Java installation.
 
 goto fail
 
-:init
-@rem Get command-line arguments, handling Windows variants
-
-if not "%OS%" == "Windows_NT" goto win9xME_args
-
-:win9xME_args
-@rem Slurp the command line arguments.
-set CMD_LINE_ARGS=
-set _SKIP=2
-
-:win9xME_args_slurp
-if "x%~1" == "x" goto execute
-
-set CMD_LINE_ARGS=%*
-
 :execute
 @rem Setup the command line
 
 set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
 
 
 @rem Execute Gradle
-"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
 
 :end
 @rem End local scope for the variables with windows NT shell

src/main/kotlin/com.bugsnag.android.gradle/AndroidManifestInfo.kt

@@ -9,11 +9,11 @@ import java.io.File
 
 @JsonClass(generateAdapter = true)
 data class AndroidManifestInfo(
-    var apiKey: String,
-    var versionCode: String,
-    var buildUUID: String?,
-    var versionName: String,
-    var applicationId: String
+    val apiKey: String,
+    val versionCode: String,
+    val buildUUID: String?,
+    val versionName: String,
+    val applicationId: String
 ) {
     internal fun write(file: File) {
         file.sink().buffer().use {

src/main/kotlin/com.bugsnag.android.gradle/AndroidManifestParser.kt

@@ -13,11 +13,10 @@ import java.io.IOException
 import java.io.PrintWriter
 import javax.xml.parsers.ParserConfigurationException
 
-class AndroidManifestParser {
+internal class AndroidManifestParser {
 
     private val namespace = Namespace("http://schemas.android.com/apk/res/android", "android")
 
-    @Throws(ParserConfigurationException::class, SAXException::class, IOException::class)
     fun readManifest(manifestPath: File, logger: Logger): AndroidManifestInfo {
         logger.debug("Bugsnag: Reading manifest at: $manifestPath")
         val root = XmlParser().parse(manifestPath)
@@ -63,6 +62,7 @@ class AndroidManifestParser {
                     |versionCode=$versionCode
                     |versionName=$versionName
                     |applicationId=$applicationId
+                    |Manifest file = $manifestPath
                 """.trimMargin())
         }
         return AndroidManifestInfo(apiKey, versionCode, buildUUID, versionName, applicationId)

src/main/kotlin/com.bugsnag.android.gradle/BugsnagFileUploadTask.kt

@@ -1,5 +1,6 @@
 package com.bugsnag.android.gradle
 
+import com.bugsnag.android.gradle.internal.BugsnagHttpClientHelper
 import org.gradle.api.provider.Property
 
 interface BugsnagFileUploadTask {
@@ -8,6 +9,7 @@ interface BugsnagFileUploadTask {
     val endpoint: Property<String>
     val retryCount: Property<Int>
     val timeoutMillis: Property<Long>
+    val httpClientHelper: Property<BugsnagHttpClientHelper>
 
     fun configureWith(bugsnag: BugsnagPluginExtension) {
         failOnUploadError.set(bugsnag.failOnUploadError)

src/main/kotlin/com.bugsnag.android.gradle/BugsnagInstallJniLibsTask.kt

@@ -1,42 +1,56 @@
 package com.bugsnag.android.gradle
 
+import com.bugsnag.android.gradle.internal.GradleVersions
+import com.bugsnag.android.gradle.internal.register
+import com.bugsnag.android.gradle.internal.versionNumber
 import org.gradle.api.DefaultTask
 import org.gradle.api.Project
+import org.gradle.api.file.ArchiveOperations
 import org.gradle.api.file.ConfigurableFileCollection
+import org.gradle.api.file.CopySpec
+import org.gradle.api.file.DirectoryProperty
 import org.gradle.api.file.FileCollection
-import org.gradle.api.file.RegularFileProperty
+import org.gradle.api.file.FileSystemOperations
+import org.gradle.api.file.FileTree
+import org.gradle.api.file.ProjectLayout
 import org.gradle.api.model.ObjectFactory
-import org.gradle.api.provider.Property
 import org.gradle.api.tasks.InputFiles
 import org.gradle.api.tasks.OutputDirectory
 import org.gradle.api.tasks.TaskAction
+import org.gradle.api.tasks.TaskProvider
+import org.gradle.api.tasks.WorkResult
 import java.io.File
 import javax.inject.Inject
 
-open class BugsnagInstallJniLibsTask @Inject constructor(
-    objects: ObjectFactory
+sealed class BugsnagInstallJniLibsTask(
+    objects: ObjectFactory,
+    projectLayout: ProjectLayout
 ) : DefaultTask() {
-
     init {
         description = "Copies shared object files from the bugsnag-android AAR to the required build directory"
         group = BugsnagPlugin.GROUP_NAME
     }
 
     @get:OutputDirectory
-    val buildDirDestination: RegularFileProperty = objects.fileProperty()
+    val buildDirDestination: DirectoryProperty = objects.directoryProperty()
+        .convention(projectLayout.buildDirectory.dir("intermediates/bugsnag-libs"))
 
     @get:InputFiles
-    val bugsnagArtefacts: Property<FileCollection> = objects.property(FileCollection::class.java)
+    abstract val bugsnagArtifacts: ConfigurableFileCollection
+
+    internal abstract fun copy(action: (CopySpec) -> Unit): WorkResult
+    internal abstract fun zipTree(file: File): FileTree
 
     /**
      * Looks at all the dependencies and their dependencies and finds the `com.bugsnag` artifacts with SO files.
      */
     @TaskAction
     fun setupNdkProject() {
-        bugsnagArtefacts.get().forEach { file: File ->
-            project.copy {
-                it.from(project.zipTree(file))
-                it.into(project.file(buildDirDestination))
+        val destination = buildDirDestination.asFile.get()
+        bugsnagArtifacts.forEach { file: File ->
+            copy {
+                it.from(zipTree(file))
+                it.into(destination)
             }
         }
     }
@@ -45,7 +59,7 @@ open class BugsnagInstallJniLibsTask @Inject constructor(
         private val sharedObjectAarIds = listOf("bugsnag-android", "bugsnag-android-ndk",
             "bugsnag-plugin-android-anr", "bugsnag-plugin-android-ndk")
 
-        internal fun resolveBugsnagArtefacts(project: Project): FileCollection {
+        internal fun resolveBugsnagArtifacts(project: Project): FileCollection {
             val files = project.configurations
                 .filter { it.toString().contains("CompileClasspath") }
                 .map { it.resolvedConfiguration }
@@ -60,5 +74,93 @@ open class BugsnagInstallJniLibsTask @Inject constructor(
                 .toSet()
             return project.files(files)
         }
+
+        /**
+         * Registers the appropriate subtype to this [project] with the given [name] and
+         * [configurationAction]
+         */
+        internal fun register(
+            project: Project,
+            name: String,
+            configurationAction: BugsnagInstallJniLibsTask.() -> Unit
+        ): TaskProvider<out BugsnagInstallJniLibsTask> {
+            val gradleVersion = project.gradle.versionNumber()
+            return when {
+              gradleVersion >= GradleVersions.VERSION_6 -> {
+                  when {
+                    gradleVersion >= GradleVersions.VERSION_6_6 -> {
+                        project.tasks.register<BugsnagInstallJniLibsTaskGradle66Plus>(name, configurationAction)
+                    }
+                    else -> {
+                        project.tasks.register<BugsnagInstallJniLibsTaskGradle6Plus>(name, configurationAction)
+                    }
+                  }
+              }
+              gradleVersion >= GradleVersions.VERSION_5_3 -> {
+                  project.tasks.register<BugsnagInstallJniLibsTask53Plus>(name, configurationAction)
+              }
+              else -> {
+                  project.tasks.register<BugsnagInstallJniLibsTaskLegacy>(name, configurationAction)
+              }
+            }
+        }
     }
 }
+
+/**
+ * Legacy [BugsnagInstallJniLibsTask] task that requires using [getProject] and
+ * [ProjectLayout.configurableFiles].
+ */
+internal open class BugsnagInstallJniLibsTaskLegacy @Inject constructor(
+    objects: ObjectFactory,
+    projectLayout: ProjectLayout
+) : BugsnagInstallJniLibsTask(objects, projectLayout) {
+    @Suppress("DEPRECATION") // Here for backward compatibility
+    @get:InputFiles
+    override val bugsnagArtifacts: ConfigurableFileCollection = projectLayout.configurableFiles()
+
+    override fun copy(action: (CopySpec) -> Unit): WorkResult = project.copy(action)
+    override fun zipTree(file: File): FileTree = project.zipTree(file)
+}
+
+/** Legacy [BugsnagInstallJniLibsTask] task that requires using [getProject]. */
+internal open class BugsnagInstallJniLibsTask53Plus @Inject constructor(
+    objects: ObjectFactory,
+    projectLayout: ProjectLayout
+) : BugsnagInstallJniLibsTask(objects, projectLayout) {
+    @get:InputFiles
+    override val bugsnagArtifacts: ConfigurableFileCollection = objects.fileCollection()
+
+    override fun copy(action: (CopySpec) -> Unit): WorkResult = project.copy(action)
+    override fun zipTree(file: File): FileTree = project.zipTree(file)
+}
+
+/** A Gradle 6+ compatible [BugsnagInstallJniLibsTask], which uses [FileSystemOperations]. */
+internal open class BugsnagInstallJniLibsTaskGradle6Plus @Inject constructor(
+    objects: ObjectFactory,
+    projectLayout: ProjectLayout,
+    private val fsOperations: FileSystemOperations
+) : BugsnagInstallJniLibsTask(objects, projectLayout) {
+    @get:InputFiles
+    override val bugsnagArtifacts: ConfigurableFileCollection = objects.fileCollection()
+
+    override fun copy(action: (CopySpec) -> Unit): WorkResult = fsOperations.copy(action)
+    override fun zipTree(file: File): FileTree = project.zipTree(file)
+}
+
+/**
+ * A Gradle 6.6+ compatible [BugsnagInstallJniLibsTask], which uses [FileSystemOperations]
+ * and [ArchiveOperations] to support configuration caching.
+ */
+internal open class BugsnagInstallJniLibsTaskGradle66Plus @Inject constructor(
+    objects: ObjectFactory,
+    projectLayout: ProjectLayout,
+    private val fsOperations: FileSystemOperations,
+    private val archiveOperations: ArchiveOperations
+) : BugsnagInstallJniLibsTask(objects, projectLayout) {
+    @get:InputFiles
+    override val bugsnagArtifacts: ConfigurableFileCollection = objects.fileCollection()
+
+    override fun copy(action: (CopySpec) -> Unit): WorkResult = fsOperations.copy(action)
+    override fun zipTree(file: File): FileTree = archiveOperations.zipTree(file)
+}

src/main/kotlin/com.bugsnag.android.gradle/BugsnagManifestUuidTask.kt

@@ -3,6 +3,7 @@ package com.bugsnag.android.gradle
 import com.android.build.gradle.api.ApkVariant
 import com.android.build.gradle.api.ApkVariantOutput
 import com.android.build.gradle.tasks.ManifestProcessorTask
+import com.bugsnag.android.gradle.internal.property
 import org.gradle.api.DefaultTask
 import org.gradle.api.Project
 import org.gradle.api.file.Directory
@@ -27,7 +28,7 @@ abstract class BaseBugsnagManifestUuidTask(objects: ObjectFactory) : DefaultTask
     }
 
     @get:Input
-    val buildUuid: Property<String> = objects.property(String::class.java)
+    val buildUuid: Property<String> = objects.property()
 
     @get:OutputFile
     val manifestInfoProvider: RegularFileProperty = objects.fileProperty()
@@ -59,10 +60,10 @@ open class BugsnagManifestUuidTask @Inject constructor(objects: ObjectFactory) :
     fun updateManifest() {
         val manifestPath = getManifestPaths(project, variant, variantOutput)
         if (manifestPath == null) {
-            project.logger.warn("Bugsnag: Failed to find manifest at $manifestPath for $variantOutput")
+            logger.warn("Bugsnag: Failed to find manifest at $manifestPath for $variantOutput")
         }
 
-        project.logger.info("Bugsnag: Updating manifest with build UUID: $manifestPath")
+        logger.info("Bugsnag: Updating manifest with build UUID: $manifestPath")
 
         // read the manifest information and store it for subsequent tasks
         val manifestParser = AndroidManifestParser()
@@ -98,16 +99,16 @@ open class BugsnagManifestUuidTask @Inject constructor(objects: ObjectFactory) :
         }
         val processManifest = variantOutput.processManifestProvider.get()
         if (getMergedManifest) {
-            directoryMerged = getManifestOutputDir(processManifest, project)
+            directoryMerged = getManifestOutputDir(processManifest)
             if (directoryMerged != null) {
-                addManifestPath(manifestPaths, directoryMerged, project.logger, variantOutput)
+                addManifestPath(manifestPaths, directoryMerged, logger, variantOutput)
             }
         }
 
         // Attempt to get the bundle manifest directory if required
         if (getBundleManifest) {
             directoryBundle = resolveBundleManifestOutputDirectory(processManifest)
-            addManifestPath(manifestPaths, directoryBundle, project.logger, variantOutput)
+            addManifestPath(manifestPaths, directoryBundle, logger, variantOutput)
         }
         require(manifestPaths.size == 1) { "Unexpected number of manifest paths.$manifestPaths" }
         return manifestPaths[0]
@@ -116,31 +117,29 @@ open class BugsnagManifestUuidTask @Inject constructor(objects: ObjectFactory) :
     private fun addManifestPath(manifestPaths: MutableList<File?>, directory: File, logger: Logger, variantOutput: ApkVariantOutput) {
         val manifestFile = Paths.get(directory.toString(), variantOutput.dirName, "AndroidManifest.xml").toFile()
         if (manifestFile.exists()) {
-            logger.info("Bugsnag: Found manifest at ${manifestFile}")
+            logger.info("Bugsnag: Found manifest at $manifestFile")
             manifestPaths.add(manifestFile)
         } else {
-            logger.info("Bugsnag: Failed to find manifest at ${manifestFile}")
+            logger.info("Bugsnag: Failed to find manifest at $manifestFile")
         }
     }
 
-    private fun getManifestOutputDir(processManifest: ManifestProcessorTask, project: Project): File? {
-        try {
+    private fun getManifestOutputDir(processManifest: ManifestProcessorTask): File? {
+        return try {
             val outputDir = processManifest.javaClass.getMethod("getManifestOutputDirectory").invoke(processManifest)
             if (outputDir is File) {
-                return outputDir
+                outputDir
             } else {
                 // gradle 4.7 introduced a provider API for lazy evaluation of properties,
                 // AGP subsequently changed the API from File to Provider<File>
                 // see https://docs.gradle.org/4.7/userguide/lazy_configuration.html
                 @Suppress("UNCHECKED_CAST") val dir = (outputDir as Provider<Directory?>).orNull
-                if (dir != null) {
-                    return dir.asFile
-                }
+                dir?.asFile
             }
         } catch (exc: Throwable) {
-            project.logger.warn("Bugsnag: failed to find manifestOutputDir", exc)
+            logger.warn("Bugsnag: failed to find manifestOutputDir", exc)
+            null
         }
-        return null
     }
 
     private fun resolveBundleManifestOutputDirectory(processManifest: ManifestProcessorTask): File {