Migrate deeplink json creation to public AGP api (flutter#173794)

Reviewers please pay special attention to the tests that were added and
tests that were removed. If you see a set of functionality that is not
covered and should be please say something.

I read every test (and TBH also had to edit most of them) but I had
gemini's agent mode help and I dont trust there is something I missed.

Related to flutter#173651

Newly added tests can be run from `packages/flutter_tools/gradle` with
`./gradlew test --tests
com.flutter.gradle.tasks.DeepLinkJsonFromManifestTaskTest`

## Pre-launch Checklist

- [x] I read the [Contributor Guide] and followed the process outlined
there for submitting PRs.
- [x] I read the [Tree Hygiene] wiki page, which explains my
responsibilities.
- [x] I read and followed the [Flutter Style Guide], including [Features
we expect every widget to implement].
- [x] I signed the [CLA].
- [x] I listed at least one issue that this PR fixes in the description
above.
- [x] I updated/added relevant documentation (doc comments with `///`).
- [x] I added new tests to check the change I am making, or this PR is
[test-exempt].
- [x] I followed the [breaking change policy] and added [Data Driven
Fixes] where supported.
- [x] All existing and new tests are passing.

Author: reidbaker

packages/flutter_tools/gradle/src/main/kotlin/FlutterPlugin.kt

@@ -704,7 +704,7 @@ class FlutterPlugin : Plugin<Project> {
                     validateDeferredComponents = validateDeferredComponentsValue
                     flavor = flavorValue
                 }
-            val compileTask: FlutterTask = compileTaskProvider.get()
+            val flutterCompileTask: FlutterTask = compileTaskProvider.get()
             val libJar: File =
                 project.file(
                     project.layout.buildDirectory.dir("${FlutterPluginConstants.INTERMEDIATES_DIR}/flutter/${variant.name}/libs.jar")
@@ -716,10 +716,10 @@ class FlutterPlugin : Plugin<Project> {
                 ) {
                     destinationDirectory.set(libJar.parentFile)
                     archiveFileName.set(libJar.name)
-                    dependsOn(compileTask)
+                    dependsOn(flutterCompileTask)
                     targetPlatforms.forEach { targetPlatform ->
                         val abi: String? = FlutterPluginConstants.PLATFORM_ARCH_MAP[targetPlatform]
-                        from("${compileTask.intermediateDir}/$abi") {
+                        from("${flutterCompileTask.intermediateDir}/$abi") {
                             include("*.so")
                             // Move `app.so` to `lib/<abi>/libapp.so`
                             rename { filename: String -> "lib/$abi/lib$filename" }
@@ -749,8 +749,8 @@ class FlutterPlugin : Plugin<Project> {
                     "copyFlutterAssets${FlutterPluginUtils.capitalize(variant.name)}",
                     Copy::class.java
                 ) {
-                    dependsOn(compileTask)
-                    with(compileTask.assets)
+                    dependsOn(flutterCompileTask)
+                    with(flutterCompileTask.assets)
                     filePermissions {
                         user {
                             read = true

packages/flutter_tools/gradle/src/main/kotlin/FlutterPluginUtils.kt

@@ -4,13 +4,15 @@
 
 package com.flutter.gradle
 
+import com.android.build.api.artifact.SingleArtifact
+import com.android.build.api.variant.AndroidComponentsExtension
 import com.android.build.gradle.AbstractAppExtension
 import com.android.build.gradle.BaseExtension
 import com.android.build.gradle.tasks.ProcessAndroidResources
 import com.android.builder.model.BuildType
 import com.flutter.gradle.plugins.PluginHandler
+import com.flutter.gradle.tasks.DeepLinkJsonFromManifestTask
 import groovy.lang.Closure
-import groovy.util.Node
 import org.gradle.api.GradleException
 import org.gradle.api.Project
 import org.gradle.api.Task
@@ -24,10 +26,6 @@ import java.util.Properties
  * A collection of static utility functions used by the Flutter Gradle Plugin.
  */
 object FlutterPluginUtils {
-    private const val MANIFEST_NAME_KEY = "android:name"
-    private const val MANIFEST_VALUE_KEY = "android:value"
-    private const val MANIFEST_VALUE_TRUE = "true"
-
     // Gradle properties. These must correspond to the values used in
     // flutter/packages/flutter_tools/lib/src/android/gradle.dart, and therefore it is not
     // recommended to use these const values in tests.
@@ -399,6 +397,7 @@ object FlutterPluginUtils {
         return project.extensions.findByType(BaseExtension::class.java)!!
     }
 
+    // Avoid new usages this class is not part of the public AGP DSL.
     private fun getAndroidAppExtensionOrNull(project: Project): AbstractAppExtension? =
         project.extensions.findByType(AbstractAppExtension::class.java)
 
@@ -783,199 +782,43 @@ object FlutterPluginUtils {
      * Add a task that can be called on Flutter projects that outputs app link related project
      * settings into a json file.
      * See https://developer.android.com/training/app-links/ for more information about app link.
-     * The json will be saved in path stored in outputPath parameter.
+     * The json will be saved in path stored in "outputPath" parameter or in the projects build
+     * directory with the file deeplink.json if not specified.
+     *
+     * See DeepLinkJsonFromManifestTask for the structure of the json.
      *
-     * An example json:
-     *  {
-     *      applicationId: "com.example.app",
-     *          deeplinks: [
-     *              {"scheme":"http", "host":"example.com", "path":".*"},
-     *              {"scheme":"https","host":"example.com","path":".*"}
-     *          ]
-     *  }
      * The output file is parsed and used by devtool.
      */
     @JvmStatic
     @JvmName("addTasksForOutputsAppLinkSettings")
     internal fun addTasksForOutputsAppLinkSettings(project: Project) {
         // Integration test for AppLinkSettings task defined in
         // flutter/flutter/packages/flutter_tools/test/integration.shard/android_gradle_outputs_app_link_settings_test.dart
-        val android = getAndroidAppExtensionOrNull(project)
-        if (android == null) {
-            project.logger.info("addTasksForOutputsAppLinkSettings called on project without android extension.")
-            return
-        }
-        android.applicationVariants.configureEach {
-            val variant = this
-            project.tasks.register("output${capitalize(variant.name)}AppLinkSettings") {
-                val task: Task = this
-                task.description =
-                    "stores app links settings for the given build variant of this Android project into a json file."
-                variant.outputs.configureEach {
-                    // TODO(gmackall): Migrate to AGPs variant api.
-                    //    https://github.com/flutter/flutter/issues/166550
-                    @Suppress("DEPRECATION")
-                    val baseVariantOutput: com.android.build.gradle.api.BaseVariantOutput = this
-                    // Deeplinks are defined in AndroidManifest.xml and is only available after
-                    // processResourcesProvider.
-                    dependsOn(findProcessResources(baseVariantOutput))
-                }
-                doLast {
-                    // We are configuring the same object before a doLast and in a doLast.
-                    // without a clear reason why. That is not good.
-                    variant.outputs.configureEach {
-                        val appLinkSettings = createAppLinkSettings(variant, this)
-                        File(project.property("outputPath").toString()).writeText(
-                            appLinkSettings.toJson().toString()
+        val androidComponents = project.extensions.getByType(AndroidComponentsExtension::class.java)
+        androidComponents.onVariants { variant ->
+            val manifestUpdater =
+                project.tasks.register("output${capitalize(variant.name)}AppLinkSettings", DeepLinkJsonFromManifestTask::class.java) {
+                    namespace.set(variant.namespace)
+                    // Flutter should always use project.layout.buildDirectory.file("deeplink.json")
+                    // instead of relying on passing in a path.
+                    if (project.hasProperty("outputPath")) {
+                        deepLinkJson.set(
+                            File(project.property("outputPath").toString())
                         )
+                    } else {
+                        deepLinkJson.set(project.layout.buildDirectory.file("deeplink.json"))
                     }
                 }
-            }
-        }
-    }
-
-    /**
-     * Extracts app deeplink information from the Android manifest file of a variant then returns
-     * an AppLinkSettings object.
-     *
-     * @param BaseVariantOutput The output of a specific build variant (e.g., debug, release).
-     * @param variant The application variant being processed.
-     */
-    @Suppress("KDocUnresolvedReference")
-    private fun createAppLinkSettings(
-        // TODO(gmackall): Migrate to AGPs variant api.
-        //    https://github.com/flutter/flutter/issues/166550
-        @Suppress("DEPRECATION") variant: com.android.build.gradle.api.ApplicationVariant,
-        @Suppress("DEPRECATION") baseVariantOutput: com.android.build.gradle.api.BaseVariantOutput
-    ): AppLinkSettings {
-        val appLinkSettings = AppLinkSettings(variant.applicationId)
-
-        // XmlParser is not namespace aware because it makes querying nodes cumbersome.
-        // TODO(gmackall): Migrate to AGPs variant api.
-        //    https://github.com/flutter/flutter/issues/166550
-        @Suppress("DEPRECATION")
-        val manifest: Node =
-            groovy.xml
-                .XmlParser(false, false)
-                .parse(findProcessResources(baseVariantOutput).manifestFile)
-        val applicationNode: Node? =
-            manifest.children().find { node ->
-                node is Node && node.name() == "application"
-            } as Node?
-        if (applicationNode == null) {
-            return appLinkSettings
-        }
-        val activities: List<Node> =
-            applicationNode.children().filterIsInstance<Node>().filter { item ->
-                item.name() == "activity"
-            }
-
-        activities.forEach { activity ->
-            val metaDataItems: List<Node> =
-                activity.children().filterIsInstance<Node>().filter { metaItem ->
-                    metaItem.name() == "meta-data"
-                }
-            metaDataItems.forEach { metaDataItem ->
-                val nameAttribute: Boolean =
-                    metaDataItem.attribute(MANIFEST_NAME_KEY) == "flutter_deeplinking_enabled"
-                val valueAttribute: Boolean =
-                    metaDataItem.attribute(MANIFEST_VALUE_KEY) == MANIFEST_VALUE_TRUE
-                if (nameAttribute && valueAttribute) {
-                    appLinkSettings.deeplinkingFlagEnabled = true
-                }
-            }
-            val intentFilterItems: List<Node> =
-                activity.children().filterIsInstance<Node>().filter { filterItem ->
-                    filterItem.name() == "intent-filter"
-                }
-            intentFilterItems.forEach { appLinkIntent ->
-                // Print out the host attributes in data tags.
-                val schemes: MutableSet<String?> = mutableSetOf()
-                val hosts: MutableSet<String?> = mutableSetOf()
-                val paths: MutableSet<String?> = mutableSetOf()
-                val intentFilterCheck = IntentFilterCheck()
-                if (appLinkIntent.attribute("android:autoVerify") == MANIFEST_VALUE_TRUE) {
-                    intentFilterCheck.hasAutoVerify = true
-                }
-
-                val actionItems: List<Node> =
-                    appLinkIntent.children().filterIsInstance<Node>().filter { item ->
-                        item.name() == "action"
-                    }
-                // Any action item causes intentFilterCheck to always be true
-                // and we keep looping instead of exiting out early.
-                // TODO: Exit out early per intent filter action view.
-                actionItems.forEach { action ->
-                    if (action.attribute(MANIFEST_NAME_KEY) == "android.intent.action.VIEW") {
-                        intentFilterCheck.hasActionView = true
-                    }
-                }
-                val categoryItems: List<Node> =
-                    appLinkIntent.children().filterIsInstance<Node>().filter { item ->
-                        item.name() == "category"
-                    }
-                categoryItems.forEach { category ->
-                    // TODO: Exit out early per intent filter default category.
-                    if (category.attribute(MANIFEST_NAME_KEY) == "android.intent.category.DEFAULT") {
-                        intentFilterCheck.hasDefaultCategory = true
-                    }
-                    // TODO: Exit out early per intent filter browsable category.
-                    if (category.attribute(MANIFEST_NAME_KEY) == "android.intent.category.BROWSABLE") {
-                        intentFilterCheck.hasBrowsableCategory =
-                            true
-                    }
-                }
-                val dataItems: List<Node> =
-                    appLinkIntent.children().filterIsInstance<Node>().filter { item ->
-                        item.name() == "data"
-                    }
-                dataItems.forEach { data ->
-                    data.attributes().forEach { entry ->
-                        when (entry.key) {
-                            "android:scheme" -> schemes.add(entry.value.toString())
-                            "android:host" -> hosts.add(entry.value.toString())
-                            // All path patterns add to paths.
-                            "android:pathAdvancedPattern" ->
-                                paths.add(
-                                    entry.value.toString()
-                                )
-
-                            "android:pathPattern" -> paths.add(entry.value.toString())
-                            "android:path" -> paths.add(entry.value.toString())
-                            "android:pathPrefix" -> paths.add(entry.value.toString() + ".*")
-                            "android:pathSuffix" -> paths.add(".*" + entry.value.toString())
-                        }
-                    }
-                }
-                if (hosts.isNotEmpty() || paths.isNotEmpty()) {
-                    if (schemes.isEmpty()) {
-                        schemes.add(null)
-                    }
-                    if (hosts.isEmpty()) {
-                        hosts.add(null)
-                    }
-                    if (paths.isEmpty()) {
-                        paths.add(".*")
-                    }
-                    // Sets are not ordered this could produce a bug.
-                    schemes.forEach { scheme ->
-                        hosts.forEach { host ->
-                            paths.forEach { path ->
-                                appLinkSettings.deeplinks.add(
-                                    Deeplink(
-                                        scheme,
-                                        host,
-                                        path,
-                                        intentFilterCheck
-                                    )
-                                )
-                            }
-                        }
-                    }
-                }
-            }
+            // This task does not modify the manifest despite using an api
+            // designed for modification. The task is responsible for an exact copy of the input
+            // manifest being used for the output manifest.
+            variant.artifacts
+                .use(manifestUpdater)
+                .wiredWithFiles(
+                    DeepLinkJsonFromManifestTask::manifestFile,
+                    DeepLinkJsonFromManifestTask::updatedManifest
+                ).toTransform(SingleArtifact.MERGED_MANIFEST) // (3) Indicate the artifact and operation type.
         }
-        return appLinkSettings
     }
 }
 

packages/flutter_tools/gradle/src/main/kotlin/tasks/DeepLinkJsonFromManifestTask.kt

@@ -0,0 +1,47 @@
+// Copyright 2014 The Flutter Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package com.flutter.gradle.tasks
+
+import org.gradle.api.DefaultTask
+import org.gradle.api.file.RegularFileProperty
+import org.gradle.api.provider.Property
+import org.gradle.api.tasks.Input
+import org.gradle.api.tasks.InputFile
+import org.gradle.api.tasks.OutputFile
+import org.gradle.api.tasks.TaskAction
+
+/**
+ * Create a json file of deeplink settings from an AndroidManifest.
+ *
+ * This task does not modify the manifest despite using an api
+ * designed for modification. The task is responsible for an exact copy of the input
+ * manifest being used for the output manifest.
+*/
+abstract class DeepLinkJsonFromManifestTask : DefaultTask() {
+    // Input property to receive the manifest file
+    @get:InputFile
+    abstract val manifestFile: RegularFileProperty
+
+    // In the past for this task namespace was the ApplicationId.
+    @get:Input
+    abstract val namespace: Property<String>
+
+    // Does not need to transform manifest at all but there does not appear to be another dsl
+    // supported way to depend on the merged manifest.
+    @get:OutputFile
+    abstract val updatedManifest: RegularFileProperty
+
+    @get:OutputFile
+    abstract val deepLinkJson: RegularFileProperty
+
+    @TaskAction
+    fun processManifest() {
+        manifestFile.get().asFile.copyTo(updatedManifest.get().asFile, overwrite = true)
+        logger.debug("DeepLinkJsonFromManifestTask: Unmodified manifest written.")
+
+        DeepLinkJsonFromManifestTaskHelper.createAppLinkSettingsFile(namespace.get(), manifestFile, deepLinkJson)
+        logger.debug("DeepLinkJsonFromManifestTask: appLinkSettings written to ${deepLinkJson.get().asFile.absolutePath}.")
+    }
+}