kezong · kezong · Sep 10, 2020 · Sep 8, 2020 · Sep 8, 2020 · Sep 8, 2020
diff --git a/source/src/main/groovy/com/kezong/fataar/FlavorArtifact.groovy b/source/src/main/groovy/com/kezong/fataar/FlavorArtifact.groovy
@@ -3,6 +3,7 @@ package com.kezong.fataar
 import com.android.build.gradle.api.LibraryVariant
 import org.gradle.api.Project
 import org.gradle.api.Task
+import org.gradle.api.UnknownTaskException
 import org.gradle.api.artifacts.ModuleVersionIdentifier
 import org.gradle.api.artifacts.ResolvedDependency
 import org.gradle.api.artifacts.component.ComponentArtifactIdentifier
@@ -12,6 +13,7 @@ import org.gradle.api.internal.artifacts.DefaultResolvedArtifact
 import org.gradle.api.internal.tasks.TaskDependencyContainer
 import org.gradle.api.internal.tasks.TaskDependencyResolveContext
 import org.gradle.api.tasks.TaskDependency
+import org.gradle.api.tasks.TaskProvider
 import org.gradle.internal.Factory
 import org.gradle.internal.component.model.DefaultIvyArtifactName
 
@@ -95,22 +97,26 @@ class FlavorArtifact {
         return new File(outputName)
     }
 
-    private static TaskDependency createTaskDependency(Project project, LibraryVariant variant) {
-        def taskPath = 'bundle' + variant.name.capitalize()
-        Task bundleTask = project.tasks.findByPath(taskPath)
-        if (bundleTask == null) {
-            taskPath = 'bundle' + variant.name.capitalize() + "Aar"
-            bundleTask = project.tasks.findByPath(taskPath)
-        }
-        if (bundleTask == null) {
-            throw new RuntimeException("Can not find task ${taskPath}!")
+    static TaskProvider<Task> getBundleTaskProvider(final Project project, final LibraryVariant variant) throws UnknownTaskException {
+        def taskPath = "bundle" + variant.name.capitalize()
+        TaskProvider bundleTask
+        try {
+            bundleTask = project.tasks.named(taskPath)
+        } catch (UnknownTaskException ignored) {
+            taskPath += "Aar"
+            bundleTask = project.tasks.named(taskPath)
         }
+        return bundleTask
+    }
+
+    private static TaskDependency createTaskDependency(Project project, LibraryVariant variant) {
+        def bundleTaskProvider = getBundleTaskProvider(project, variant)
 
         return new TaskDependency() {
             @Override
             Set<? extends Task> getDependencies(@Nullable Task task) {
                 def set = new HashSet()
-                set.add(bundleTask)
+                set.add(bundleTaskProvider.get())
                 return set
             }
         }

diff --git a/source/src/main/groovy/com/kezong/fataar/RProcessor.groovy b/source/src/main/groovy/com/kezong/fataar/RProcessor.groovy
@@ -1,14 +1,13 @@
 package com.kezong.fataar
 
 import com.android.build.gradle.api.LibraryVariant
-
 import org.gradle.api.Project
 import org.gradle.api.Task
+import org.gradle.api.tasks.TaskProvider
 import org.gradle.api.tasks.bundling.Zip
 import org.gradle.api.tasks.compile.JavaCompile
 import org.gradle.jvm.tasks.Jar
 
-
 /**
  * R file processor
  * @author kezong on 2019/7/16.
@@ -48,50 +47,50 @@ class RProcessor {
         mAarOutputPath = mVersionAdapter.getOutputPath()
     }
 
-    void inject(Task bundleTask) {
-        def RFileTask = createRFileTask(mJavaDir)
-        def RClassTask = createRClassTask(mJavaDir, mClassDir)
-        def RJarTask = createRJarTask(mClassDir, mJarDir)
+    void inject(TaskProvider<Task> bundleTask) {
         def reBundleAar = createBundleAarTask(mAarUnZipDir, mAarOutputDir, mAarOutputPath)
+        def RJarTask = createRJarTask(mClassDir, mJarDir, reBundleAar)
+        def RClassTask = createRClassTask(mJavaDir, mClassDir, RJarTask)
+        def RFileTask = createRFileTask(mJavaDir, RClassTask)
 
-        reBundleAar.doFirst {
-            mProject.copy {
-                from mProject.zipTree(mAarOutputPath)
-                into mAarUnZipDir
+        reBundleAar.configure {
+            doFirst {
+                mProject.copy {
+                    from mProject.zipTree(mAarOutputPath)
+                    into mAarUnZipDir
+                }
+                deleteEmptyDir(mAarUnZipDir)
+            }
+            doLast {
+                Utils.logAnytime("target: $mAarOutputPath")
             }
-            deleteEmptyDir(mAarUnZipDir)
         }
 
-        reBundleAar.doLast {
-            Utils.logAnytime("target: $mAarOutputPath")
-        }
+        bundleTask.configure {
+            finalizedBy(RFileTask)
 
-        bundleTask.doFirst {
-            File f = new File(mAarOutputPath)
-            if (f.exists()) {
-                f.delete()
+            doFirst {
+                File f = new File(mAarOutputPath)
+                if (f.exists()) {
+                    f.delete()
+                }
+                mJarDir.getParentFile().deleteDir()
+                mJarDir.mkdirs()
             }
-            mJarDir.getParentFile().deleteDir()
-            mJarDir.mkdirs()
-        }
 
-        bundleTask.doLast {
-            // support gradle 5.1 && gradle plugin 3.4 before, the outputName is changed
-            File file = new File(mAarOutputPath)
-            if (!file.exists()) {
-                mAarOutputPath = mAarOutputDir.absolutePath + "/" + mProject.name + ".aar"
-                if (Utils.compareVersion(mProject.gradle.gradleVersion, "6.0.1") >= 0) {
-                    reBundleAar.getArchiveFileName().set(new File(mAarOutputPath).name)
-                } else {
-                    reBundleAar.archiveName = new File(mAarOutputPath).name
+            doLast {
+                // support gradle 5.1 && gradle plugin 3.4 before, the outputName is changed
+                File file = new File(mAarOutputPath)
+                if (!file.exists()) {
+                    mAarOutputPath = mAarOutputDir.absolutePath + "/" + mProject.name + ".aar"
+                    if (Utils.compareVersion(mProject.gradle.gradleVersion, "6.0.1") >= 0) {
+                        reBundleAar.getArchiveFileName().set(new File(mAarOutputPath).name)
+                    } else {
+                        reBundleAar.archiveName = new File(mAarOutputPath).name
+                    }
                 }
             }
         }
-
-        bundleTask.finalizedBy(RFileTask)
-        RFileTask.finalizedBy(RClassTask)
-        RClassTask.finalizedBy(RJarTask)
-        RJarTask.finalizedBy(reBundleAar)
     }
 
     private def createRFile(AndroidArchiveLibrary library, def rFolder, ConfigObject symbolsMap) {
@@ -169,54 +168,60 @@ class RProcessor {
         return map
     }
 
-    private Task createRFileTask(final File destFolder) {
-        def task = mProject.tasks.create(name: 'createRsFile' + mVariant.name)
-        task.doLast {
-            if (destFolder.exists()) {
-                destFolder.deleteDir()
-            }
-            if (mLibraries != null && mLibraries.size() > 0) {
-                def symbolsMap = getSymbolsMap()
-                mLibraries.each {
-                    Utils.logInfo("Generate R File, Library:${it.name}")
-                    createRFile(it, destFolder, symbolsMap)
+    private TaskProvider createRFileTask(final File destFolder, final TaskProvider RClassTask) {
+        def task = mProject.tasks.register('createRsFile' + mVariant.name) {
+            finalizedBy(RClassTask)
+
+            doLast {
+                if (destFolder.exists()) {
+                    destFolder.deleteDir()
+                }
+                if (mLibraries != null && mLibraries.size() > 0) {
+                    def symbolsMap = getSymbolsMap()
+                    mLibraries.each {
+                        Utils.logInfo("Generate R File, Library:${it.name}")
+                        createRFile(it, destFolder, symbolsMap)
+                    }
                 }
             }
         }
-
         return task
     }
 
-    private Task createRClassTask(final def sourceDir, final def destinationDir) {
+    private TaskProvider createRClassTask(final File sourceDir, final File destinationDir, final TaskProvider RJarTask) {
         mProject.mkdir(destinationDir)
 
         def classpath = mVersionAdapter.getRClassPath()
         String taskName = "compileRs${mVariant.name.capitalize()}"
-        Task task = mProject.getTasks().create(taskName, JavaCompile.class, {
+        TaskProvider task = mProject.getTasks().register(taskName, JavaCompile.class) {
+            finalizedBy(RJarTask)
+
             it.source = sourceDir.path
             it.sourceCompatibility = mProject.android.compileOptions.sourceCompatibility
             it.targetCompatibility = mProject.android.compileOptions.targetCompatibility
             it.classpath = classpath
-            it.destinationDir destinationDir
-        })
+            it.destinationDir = destinationDir
 
-        task.doFirst {
-            Utils.logInfo("Compile R.class, Dir:${sourceDir.path}")
-            Utils.logInfo("Compile R.class, classpath:${classpath.first().absolutePath}")
+            doFirst {
+                Utils.logInfo("Compile R.class, Dir:${sourceDir.path}")
+                Utils.logInfo("Compile R.class, classpath:${classpath.first().absolutePath}")
 
-            if (mGradlePluginVersion != null && Utils.compareVersion(mGradlePluginVersion, "3.3.0") >= 0) {
-                mProject.copy {
-                    from mProject.zipTree(mVersionAdapter.getRClassPath().first().absolutePath + "/R.jar")
-                    into mVersionAdapter.getRClassPath().first().absolutePath
+                if (mGradlePluginVersion != null && Utils.compareVersion(mGradlePluginVersion, "3.3.0") >= 0) {
+                    mProject.copy {
+                        from mProject.zipTree(mVersionAdapter.getRClassPath().first().absolutePath + "/R.jar")
+                        into mVersionAdapter.getRClassPath().first().absolutePath
+                    }
                 }
             }
         }
         return task
     }
 
-    private Task createRJarTask(final def fromDir, final def desFile) {
+    private TaskProvider createRJarTask(final File fromDir, final File desFile, final TaskProvider reBundleAarTask) {
         String taskName = "createRsJar${mVariant.name.capitalize()}"
-        Task task = mProject.getTasks().create(taskName, Jar.class, {
+        TaskProvider task = mProject.getTasks().register(taskName, Jar) {
+            finalizedBy(reBundleAarTask)
+
             it.from fromDir.path
             // The destinationDir property has been deprecated.
             // This is scheduled to be removed in Gradle 7.0. Please use the destinationDirectory property instead.
@@ -225,33 +230,33 @@ class RProcessor {
                 it.getDestinationDirectory().set(desFile)
             } else {
                 it.archiveName = "r-classes.jar"
-                it.destinationDir desFile
+                it.destinationDir = desFile
+            }
+            doFirst {
+                Utils.logInfo("Generate R.jar, Dir：$fromDir")
             }
-        })
-        task.doFirst {
-            Utils.logInfo("Generate R.jar, Dir：$fromDir")
         }
         return task
     }
 
-    private Task createBundleAarTask(final File from, final File destDir, final String filePath) {
+    private TaskProvider createBundleAarTask(final File from, final File destDir, final String filePath) {
         String taskName = "reBundleAar${mVariant.name.capitalize()}"
-        Task task = mProject.getTasks().create(taskName, Zip.class, {
+        TaskProvider task = mProject.getTasks().register(taskName, Zip.class) {
             it.from from
             it.include "**"
             if (Utils.compareVersion(mProject.gradle.gradleVersion, "6.0.1") >= 0) {
                 it.getArchiveFileName().set(new File(filePath).name)
                 it.getDestinationDirectory().set(destDir)
             } else {
                 it.archiveName = new File(filePath).name
-                it.destinationDir(destDir)
+                it.destinationDir = destDir
             }
-        })
+        }
 
         return task
     }
 
-    def deleteEmptyDir = { file ->
+    private void deleteEmptyDir(final File file) {
         file.listFiles().each { x ->
             if (x.isDirectory()) {
                 if (x.listFiles().size() == 0) {