Merge "Merge cherrypicks of ['android-review.googlesource.com/3025746'] into androidx-main-release." into androidx-main-releaseandroidx-main-release

4 files changed, 131 insertions, 127 deletions

diff --git a/buildSrc-tests/lint-baseline.xml b/buildSrc-tests/lint-baseline.xml
index 935864f4eea..8f569f0ba03 100644
--- a/buildSrc-tests/lint-baseline.xml
+++ b/buildSrc-tests/lint-baseline.xml
@@ -371,33 +371,6 @@
     </issue>
 
     <issue
-        id="InternalAgpApiUsage"
-        message="Avoid using internal Android Gradle Plugin APIs"
-        errorLine1="import com.android.build.gradle.internal.attributes.VariantAttr"
-        errorLine2="~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~">
-        <location
-            file="${:buildSrc-tests*main*MAIN*sourceProvider*0*javaDir*4}/androidx/build/testConfiguration/TestSuiteConfiguration.kt"/>
-    </issue>
-
-    <issue
-        id="InternalAgpApiUsage"
-        message="Avoid using internal Android Gradle Plugin APIs"
-        errorLine1="import com.android.build.gradle.internal.publishing.AndroidArtifacts"
-        errorLine2="~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~">
-        <location
-            file="${:buildSrc-tests*main*MAIN*sourceProvider*0*javaDir*4}/androidx/build/testConfiguration/TestSuiteConfiguration.kt"/>
-    </issue>
-
-    <issue
-        id="InternalAgpApiUsage"
-        message="Avoid using internal Android Gradle Plugin APIs"
-        errorLine1="import com.android.build.gradle.internal.publishing.AndroidArtifacts.ArtifactType"
-        errorLine2="~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~">
-        <location
-            file="${:buildSrc-tests*main*MAIN*sourceProvider*0*javaDir*4}/androidx/build/testConfiguration/TestSuiteConfiguration.kt"/>
-    </issue>
-
-    <issue
         id="InternalGradleApiUsage"
         message="Avoid using internal Gradle APIs"
         errorLine1="import org.gradle.api.internal.artifacts.dependencies.DefaultExternalModuleDependency"
diff --git a/buildSrc/private/src/main/kotlin/androidx/build/AndroidXImplPlugin.kt b/buildSrc/private/src/main/kotlin/androidx/build/AndroidXImplPlugin.kt
index 3463812a762..155cdcb3f3c 100644
--- a/buildSrc/private/src/main/kotlin/androidx/build/AndroidXImplPlugin.kt
+++ b/buildSrc/private/src/main/kotlin/androidx/build/AndroidXImplPlugin.kt
@@ -577,6 +577,10 @@ constructor(private val componentFactory: SoftwareComponentFactory) : Plugin<Pro
             excludeVersionFiles(packagingOptions.resources)
         }
 
+        project.extensions.getByType<ApplicationExtension>().apply {
+            configureAndroidApplicationOptions(project, androidXExtension)
+        }
+
         project.extensions.getByType<ApplicationAndroidComponentsExtension>().apply {
             beforeVariants(selector().withBuildType("release")) { variant ->
                 // Cast is needed because ApplicationAndroidComponentsExtension implements both
@@ -589,10 +593,6 @@ constructor(private val componentFactory: SoftwareComponentFactory) : Plugin<Pro
                 it.configureTests()
                 it.configureLocalAsbSigning(project.getKeystore())
             }
-            finalizeDsl { appExtension ->
-                project.configureTestConfigGeneration(appExtension)
-                appExtension.configureAndroidApplicationOptions(project, androidXExtension)
-            }
         }
 
         project.buildOnServerDependsOnAssembleRelease()
@@ -646,8 +646,10 @@ constructor(private val componentFactory: SoftwareComponentFactory) : Plugin<Pro
         }
 
         project.configurePublicResourcesStub(project.multiplatformExtension!!)
-        kotlinMultiplatformAndroidComponentsExtension.onVariant {
-            project.configureMultiplatformSourcesForAndroid(it.name)
+        project.configureMultiplatformSourcesForAndroid { action ->
+            kotlinMultiplatformAndroidComponentsExtension.onVariant {
+                action(it.name)
+            }
         }
         project.configureVersionFileWriter(
             project.multiplatformExtension!!,
@@ -808,8 +810,53 @@ constructor(private val componentFactory: SoftwareComponentFactory) : Plugin<Pro
                 }
             }
 
+        val libraryAndroidComponentsExtension =
+            project.extensions.getByType<LibraryAndroidComponentsExtension>()
+
+        // Remove the android:targetSdkVersion element from the manifest used for AARs.
+        libraryAndroidComponentsExtension.onVariants { variant ->
+            project.createVariantAarManifestTransformerTask(variant.name, variant.artifacts)
+        }
+
+        project.extensions.getByType<com.android.build.api.dsl.LibraryExtension>().apply {
+            publishing { singleVariant(DEFAULT_PUBLISH_CONFIG) }
+            project.configureTestConfigGeneration(this)
+            project.addAppApkToTestConfigGeneration(androidXExtension)
+        }
+
+        libraryAndroidComponentsExtension.apply {
+            beforeVariants(selector().withBuildType("release")) { variant ->
+                variant.enableUnitTest = false
+            }
+            onVariants {
+                it.configureTests()
+                it.aotCompileMicrobenchmarks(project)
+            }
+        }
+
+        project.configureSourceJarForAndroid(libraryExtension)
+        project.configureVersionFileWriter(libraryAndroidComponentsExtension, androidXExtension)
+        project.configureJavaCompilationWarnings(androidXExtension)
+
+        project.configureDependencyVerification(androidXExtension) { taskProvider ->
+            libraryExtension.defaultPublishVariant { libraryVariant ->
+                taskProvider.configure { task ->
+                    task.dependsOn(libraryVariant.javaCompileProvider)
+                }
+            }
+        }
+
         val reportLibraryMetrics = project.configureReportLibraryMetricsTask()
         project.addToBuildOnServer(reportLibraryMetrics)
+        libraryExtension.defaultPublishVariant { libraryVariant ->
+            reportLibraryMetrics.configure {
+                it.jarFiles.from(
+                    libraryVariant.packageLibraryProvider.map { zip ->
+                        zip.inputs.files
+                    }
+                )
+            }
+        }
 
         val prebuiltLibraries = listOf("libtracing_perfetto.so", "libc++_shared.so")
         val copyPublicResourcesDirTask =
@@ -819,70 +866,33 @@ constructor(private val componentFactory: SoftwareComponentFactory) : Plugin<Pro
             ) { task ->
                 task.buildSrcResDir.set(File(project.getSupportRootFolder(), "buildSrc/res"))
             }
-
-        project.extensions.getByType<LibraryAndroidComponentsExtension>().apply {
-            beforeVariants(selector().withBuildType("release")) { variant ->
-                variant.enableUnitTest = false
+        libraryAndroidComponentsExtension.onVariants { variant ->
+            if (variant.buildType == DEFAULT_PUBLISH_CONFIG) {
+                // Standard docs, resource API, and Metalava configuration for AndroidX projects.
+                project.configureProjectForApiTasks(
+                    LibraryApiTaskConfig(libraryExtension, variant),
+                    androidXExtension
+                )
             }
-            onVariants { variant ->
-                variant.configureTests()
-                variant.aotCompileMicrobenchmarks(project)
-                // Remove the android:targetSdkVersion element from the manifest used for AARs.
-                project.createVariantAarManifestTransformerTask(variant.name, variant.artifacts)
-
-                configurePublicResourcesStub(variant, copyPublicResourcesDirTask)
-                if (variant.buildType == DEFAULT_PUBLISH_CONFIG) {
-                    // Standard docs, resource API, and Metalava configuration for AndroidX projects.
-                    project.configureProjectForApiTasks(
-                        LibraryApiTaskConfig(libraryExtension, variant),
-                        androidXExtension
-                    )
-                }
-                if (variant.name == DEFAULT_PUBLISH_CONFIG) {
-                    project.configureSourceJarForAndroid(variant)
-                    project.configureDependencyVerification(androidXExtension) { taskProvider ->
-                        taskProvider.configure { task ->
-                            task.dependsOn("compileReleaseJavaWithJavac")
+            configurePublicResourcesStub(variant, copyPublicResourcesDirTask)
+            val verifyELFRegionAlignmentTaskProvider = project.tasks.register(
+                variant.name + "VerifyELFRegionAlignment",
+                VerifyELFRegionAlignmentTask::class.java
+            ) { task ->
+                task.files.from(
+                    variant.artifacts.get(SingleArtifact.MERGED_NATIVE_LIBS)
+                        .map { dir ->
+                            dir.asFileTree.files
+                                .filter { it.extension == "so" }
+                                .filter { it.path.contains("arm64-v8a") }
+                                .filterNot { prebuiltLibraries.contains(it.name) }
                         }
-                    }
-
-                    reportLibraryMetrics.configure {
-                        it.jarFiles.from(
-                            project.tasks.named("bundleReleaseAar").map {
-                                    zip -> zip.inputs.files
-                            }
-                        )
-                    }
-                }
-                val verifyELFRegionAlignmentTaskProvider = project.tasks.register(
-                    variant.name + "VerifyELFRegionAlignment",
-                    VerifyELFRegionAlignmentTask::class.java
-                ) { task ->
-                    task.files.from(
-                        variant.artifacts.get(SingleArtifact.MERGED_NATIVE_LIBS)
-                            .map { dir ->
-                                dir.asFileTree.files
-                                    .filter { it.extension == "so" }
-                                    .filter { it.path.contains("arm64-v8a") }
-                                    .filterNot { prebuiltLibraries.contains(it.name) }
-                            }
-                    )
-                    task.cacheEvenIfNoOutputs()
-                }
-                project.addToBuildOnServer(verifyELFRegionAlignmentTaskProvider)
-            }
-            finalizeDsl { libraryExtension ->
-                project.configureTestConfigGeneration(libraryExtension)
-                project.addAppApkToTestConfigGeneration(androidXExtension)
-                libraryExtension.apply {
-                    publishing { singleVariant(DEFAULT_PUBLISH_CONFIG) }
-                }
+                )
+                task.cacheEvenIfNoOutputs()
             }
-            project.configureVersionFileWriter(this, androidXExtension)
+            project.addToBuildOnServer(verifyELFRegionAlignmentTaskProvider)
         }
 
-        project.configureJavaCompilationWarnings(androidXExtension)
-
         project.setUpCheckDocsTask(androidXExtension)
 
         project.addToProjectMap(androidXExtension)
@@ -1261,6 +1271,7 @@ constructor(private val componentFactory: SoftwareComponentFactory) : Plugin<Pro
             versionName = "1.0"
         }
 
+        project.configureTestConfigGeneration(this)
         project.addAppApkToTestConfigGeneration(androidXExtension)
         project.addAppApkToFtlRunner()
     }
diff --git a/buildSrc/private/src/main/kotlin/androidx/build/Release.kt b/buildSrc/private/src/main/kotlin/androidx/build/Release.kt
index 02c56fe6cb3..2d09d332b24 100644
--- a/buildSrc/private/src/main/kotlin/androidx/build/Release.kt
+++ b/buildSrc/private/src/main/kotlin/androidx/build/Release.kt
@@ -16,6 +16,7 @@
 package androidx.build
 
 import androidx.build.uptodatedness.cacheEvenIfNoOutputs
+import com.android.build.gradle.LibraryExtension
 import java.io.File
 import java.io.FileNotFoundException
 import java.util.Locale
@@ -430,6 +431,18 @@ open class VerifyGMavenZipTask : DefaultTask() {
     }
 }
 
+/** Let you configure a library variant associated with [Release.DEFAULT_PUBLISH_CONFIG] */
+@Suppress("DEPRECATION") // LibraryVariant
+fun LibraryExtension.defaultPublishVariant(
+    config: (com.android.build.gradle.api.LibraryVariant) -> Unit
+) {
+    libraryVariants.all { variant ->
+        if (variant.name == Release.DEFAULT_PUBLISH_CONFIG) {
+            config(variant)
+        }
+    }
+}
+
 val AndroidXExtension.publishedArtifacts: List<Artifact>
     get() {
         val groupString = mavenGroup?.group!!
diff --git a/buildSrc/private/src/main/kotlin/androidx/build/SourceJarTaskHelper.kt b/buildSrc/private/src/main/kotlin/androidx/build/SourceJarTaskHelper.kt
index 762b9af8c1b..2841ad1d4ba 100644
--- a/buildSrc/private/src/main/kotlin/androidx/build/SourceJarTaskHelper.kt
+++ b/buildSrc/private/src/main/kotlin/androidx/build/SourceJarTaskHelper.kt
@@ -18,7 +18,7 @@ package androidx.build
 
 import androidx.build.dackka.DokkaAnalysisPlatform
 import androidx.build.dackka.docsPlatform
-import com.android.build.api.variant.LibraryVariant
+import com.android.build.gradle.LibraryExtension
 import com.google.gson.GsonBuilder
 import java.util.Locale
 import org.gradle.api.DefaultTask
@@ -45,34 +45,37 @@ import org.jetbrains.kotlin.gradle.plugin.KotlinCompilation.Companion.MAIN_COMPI
 import org.jetbrains.kotlin.gradle.plugin.KotlinTarget
 
 /** Sets up a source jar task for an Android library project. */
-fun Project.configureSourceJarForAndroid(libraryVariant: LibraryVariant) {
-    val sourceJar =
-        tasks.register(
-            "sourceJar${libraryVariant.name.capitalize()}",
-            Jar::class.java
-        ) { task ->
-            task.archiveClassifier.set("sources")
-            task.from(libraryVariant.sources.java!!.all)
-            task.exclude { it.file.path.contains("generated") }
-            // Do not allow source files with duplicate names, information would be lost
-            // otherwise.
-            task.duplicatesStrategy = DuplicatesStrategy.FAIL
-        }
-    registerSourcesVariant(sourceJar)
+fun Project.configureSourceJarForAndroid(libraryExtension: LibraryExtension) {
+    libraryExtension.defaultPublishVariant { variant ->
+        val sourceJar =
+            tasks.register(
+                "sourceJar${variant.name.capitalize()}",
+                Jar::class.java
+            ) {
+                it.archiveClassifier.set("sources")
+                it.from(libraryExtension.sourceSets.getByName("main").java.srcDirs)
+                // Do not allow source files with duplicate names, information would be lost
+                // otherwise.
+                it.duplicatesStrategy = DuplicatesStrategy.FAIL
+            }
+        registerSourcesVariant(sourceJar)
 
-    // b/272214715
-    configurations.whenObjectAdded {
-        if (it.name == "debugSourcesElements" || it.name == "releaseSourcesElements") {
-            it.artifacts.whenObjectAdded { _ ->
-                it.attributes.attribute(
-                    DocsType.DOCS_TYPE_ATTRIBUTE,
-                    project.objects.named(DocsType::class.java, "fake-sources")
-                )
+        // b/272214715
+        configurations.whenObjectAdded {
+            if (it.name == "debugSourcesElements" || it.name == "releaseSourcesElements") {
+                it.artifacts.whenObjectAdded { _ ->
+                    it.attributes.attribute(
+                        DocsType.DOCS_TYPE_ATTRIBUTE,
+                        project.objects.named(DocsType::class.java, "fake-sources")
+                    )
+                }
             }
         }
     }
     project.afterEvaluate {
-        project.configureMultiplatformSourcesForAndroid(libraryVariant.name)
+        project.configureMultiplatformSourcesForAndroid { action ->
+            libraryExtension.defaultPublishVariant { action(it.name) }
+        }
     }
     val disableNames =
         setOf(
@@ -81,19 +84,23 @@ fun Project.configureSourceJarForAndroid(libraryVariant: LibraryVariant) {
     disableUnusedSourceJarTasks(disableNames)
 }
 
-fun Project.configureMultiplatformSourcesForAndroid(variantName: String) {
+fun Project.configureMultiplatformSourcesForAndroid(
+    withVariant: (action: (variantName: String) -> Unit) -> Unit
+) {
     val mpExtension = multiplatformExtension
     if (mpExtension != null && extra.has("publish")) {
-        val sourceJar =
-            project.tasks.named(
-                "sourceJar${variantName.capitalize()}",
-                Jar::class.java
-            )
-        // multiplatform projects use different source sets, so we need to modify the task
-        sourceJar.configure { sourceJarTask ->
-            // use an inclusion list of source sets, because that is the preferred policy
-            sourceJarTask.from(mpExtension.sourceSets.getByName("commonMain").kotlin.srcDirs)
-            sourceJarTask.from(mpExtension.sourceSets.getByName("androidMain").kotlin.srcDirs)
+        withVariant { variantName ->
+            val sourceJar =
+                project.tasks.named(
+                    "sourceJar${variantName.capitalize()}",
+                    Jar::class.java
+                )
+            // multiplatform projects use different source sets, so we need to modify the task
+            sourceJar.configure { sourceJarTask ->
+                // use an inclusion list of source sets, because that is the preferred policy
+                sourceJarTask.from(mpExtension.sourceSets.getByName("commonMain").kotlin.srcDirs)
+                sourceJarTask.from(mpExtension.sourceSets.getByName("androidMain").kotlin.srcDirs)
+            }
         }
     }
 }