=
+ project.providers.gradleProperty(ADD_GROUP_CONSTRAINTS).map { s -> s.toBoolean() }.orElse(true)
+
+/**
+ * Returns alternative project url that will be used as "url" property in publishing maven artifact
+ * metadata.
+ *
+ * Returns null if there is no alternative project url.
+ */
+fun Project.getAlternativeProjectUrl(): String? =
+ project.providers.gradleProperty(ALTERNATIVE_PROJECT_URL).getOrNull()
+
+/** Validate the project structure against Jetpack guidelines */
+fun Project.isValidateProjectStructureEnabled(): Boolean =
+ findBooleanProperty(VALIDATE_PROJECT_STRUCTURE) ?: true
+
+/**
+ * Validates that all properties passed by the user of the form "-Pandroidx.*" are not misspelled
+ */
+fun Project.validateAllAndroidxArgumentsAreRecognized() {
+ for (propertyName in project.properties.keys) {
+ if (propertyName.startsWith("androidx")) {
+ if (!ALL_ANDROIDX_PROPERTIES.contains(propertyName)) {
+ val message =
+ "Unrecognized Androidx property '$propertyName'.\n" +
+ "\n" +
+ "Is this a misspelling? All recognized Androidx properties:\n" +
+ ALL_ANDROIDX_PROPERTIES.joinToString("\n") +
+ "\n" +
+ "\n" +
+ "See AndroidXGradleProperties.kt if you need to add this property to " +
+ "the list of known properties."
+ throw GradleException(message)
+ }
+ }
+ }
+}
+
+/**
+ * Returns whether tests in the project should display output. Build server scripts generally set
+ * displayTestOutput to false so that their failing test results aren't considered build failures,
+ * and instead pass their test failures on via build artifacts to be tracked and displayed on test
+ * dashboards in a different format
+ */
+fun Project.isDisplayTestOutput(): Boolean = findBooleanProperty(DISPLAY_TEST_OUTPUT) ?: true
+
+/**
+ * Returns whether the project should write versioned API files, e.g. `1.1.0-alpha01.txt`.
+ *
+ *
+ * When set to `true`, the `updateApi` task will write the current API surface to both `current.txt`
+ * and `.txt`. When set to `false`, only `current.txt` will be written. The default value
+ * is `true`.
+ */
+fun Project.isWriteVersionedApiFilesEnabled(): Boolean =
+ findBooleanProperty(WRITE_VERSIONED_API_FILES) ?: true
+
+/** Returns whether the build is for checking forward compatibility across projects */
+fun Project.usingMaxDepVersions(): Provider {
+ return project.providers.gradleProperty(USE_MAX_DEP_VERSIONS).map { true }.orElse(false)
+}
+
+/** Returns whether we should use the offline mirror for dependencies */
+fun Project.useYarnOffline() = findBooleanProperty(YARN_OFFLINE_MODE) ?: false
+
+/**
+ * Returns whether this is an integration test that is allowing lint checks to be skipped to save
+ * configuration time.
+ */
+fun Project.allowMissingLintProject() =
+ findBooleanProperty(ALLOW_MISSING_LINT_CHECKS_PROJECT) ?: false
+
+fun Project.findBooleanProperty(propName: String): Boolean? =
+ project.providers.gradleProperty(propName).map { it.toBoolean() }.getOrNull()
diff --git a/buildSrc-fork/private/src/main/kotlin/androidx/build/AndroidXImplPlugin.kt b/buildSrc-fork/private/src/main/kotlin/androidx/build/AndroidXImplPlugin.kt
new file mode 100644
index 0000000000000..ccf69d5a98361
--- /dev/null
+++ b/buildSrc-fork/private/src/main/kotlin/androidx/build/AndroidXImplPlugin.kt
@@ -0,0 +1,1659 @@
+/*
+ * Copyright 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package androidx.build
+
+import androidx.build.AndroidXImplPlugin.Companion.TASK_TIMEOUT_MINUTES
+import androidx.build.ProjectLayoutType.Companion.isJetBrainsFork
+import androidx.build.Release.DEFAULT_PUBLISH_CONFIG
+import androidx.build.buildInfo.addCreateLibraryBuildInfoFileTasks
+import androidx.build.checkapi.AndroidMultiplatformApiTaskConfig
+import androidx.build.checkapi.JavaApiTaskConfig
+import androidx.build.checkapi.KmpApiTaskConfig
+import androidx.build.checkapi.LibraryApiTaskConfig
+import androidx.build.checkapi.configureProjectForApiTasks
+import androidx.build.dependencyTracker.AffectedModuleDetector
+import androidx.build.docs.CheckTipOfTreeDocsTask.Companion.setUpCheckDocsTask
+import androidx.build.gitclient.getHeadShaProvider
+import androidx.build.gradle.isRoot
+import androidx.build.kythe.configureProjectForKzipTasks
+import androidx.build.license.addLicensesToPublishedArtifacts
+import androidx.build.lint.ValidateLintChecks
+import androidx.build.resources.configurePublicResourcesStub
+import androidx.build.sbom.configureSbomPublishing
+import androidx.build.sbom.validateAllArchiveInputsRecognized
+import androidx.build.sources.configureMultiplatformSourcesForAndroid
+import androidx.build.sources.configureSourceJarForAndroid
+import androidx.build.sources.configureSourceJarForJava
+import androidx.build.sources.configureSourceJarForMultiplatform
+import androidx.build.sources.registerValidateMultiplatformSourceSetNamingTask
+import androidx.build.studio.StudioTask
+import androidx.build.testConfiguration.addAppApkToTestConfigGeneration
+import androidx.build.testConfiguration.addToModuleInfo
+import androidx.build.testConfiguration.configureTestConfigGeneration
+import androidx.build.uptodatedness.TaskUpToDateValidator
+import androidx.build.uptodatedness.cacheEvenIfNoOutputs
+import com.android.build.api.artifact.SingleArtifact
+import com.android.build.api.attributes.BuildTypeAttr
+import com.android.build.api.dsl.AarMetadata
+import com.android.build.api.dsl.ApplicationExtension
+import com.android.build.api.dsl.KotlinMultiplatformAndroidDeviceTestCompilation
+import com.android.build.api.dsl.KotlinMultiplatformAndroidHostTestCompilation
+import com.android.build.api.dsl.KotlinMultiplatformAndroidLibraryTarget
+import com.android.build.api.dsl.LibraryExtension
+import com.android.build.api.dsl.TestBuildType
+import com.android.build.api.dsl.TestExtension
+import com.android.build.api.variant.AndroidComponentsExtension
+import com.android.build.api.variant.ApplicationAndroidComponentsExtension
+import com.android.build.api.variant.HasDeviceTests
+import com.android.build.api.variant.HasUnitTestBuilder
+import com.android.build.api.variant.KotlinMultiplatformAndroidComponentsExtension
+import com.android.build.api.variant.LibraryAndroidComponentsExtension
+import com.android.build.api.variant.LibraryVariant
+import com.android.build.api.variant.LibraryVariantBuilder
+import com.android.build.gradle.AppPlugin
+import com.android.build.gradle.LibraryPlugin
+import com.android.build.gradle.TestPlugin
+import com.android.build.gradle.api.KotlinMultiplatformAndroidPlugin
+import com.google.devtools.ksp.gradle.KspExtension
+import com.google.devtools.ksp.gradle.KspGradleSubplugin
+import com.google.protobuf.gradle.ProtobufExtension
+import com.google.protobuf.gradle.ProtobufPlugin
+import java.io.File
+import java.time.Duration
+import java.util.Locale
+import javax.inject.Inject
+import org.gradle.api.DefaultTask
+import org.gradle.api.GradleException
+import org.gradle.api.JavaVersion
+import org.gradle.api.JavaVersion.VERSION_11
+import org.gradle.api.JavaVersion.VERSION_17
+import org.gradle.api.JavaVersion.VERSION_1_8
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.api.Task
+import org.gradle.api.artifacts.CacheableRule
+import org.gradle.api.artifacts.ComponentMetadataContext
+import org.gradle.api.artifacts.ComponentMetadataRule
+import org.gradle.api.artifacts.Configuration
+import org.gradle.api.artifacts.ExternalDependency
+import org.gradle.api.attributes.Category
+import org.gradle.api.attributes.Usage
+import org.gradle.api.configuration.BuildFeatures
+import org.gradle.api.file.DuplicatesStrategy
+import org.gradle.api.plugins.JavaPlugin
+import org.gradle.api.plugins.JavaPluginExtension
+import org.gradle.api.provider.Provider
+import org.gradle.api.tasks.Copy
+import org.gradle.api.tasks.TaskProvider
+import org.gradle.api.tasks.bundling.Zip
+import org.gradle.api.tasks.compile.JavaCompile
+import org.gradle.api.tasks.testing.AbstractTestTask
+import org.gradle.api.tasks.testing.logging.TestExceptionFormat
+import org.gradle.api.tasks.testing.logging.TestLogEvent
+import org.gradle.build.event.BuildEventsListenerRegistry
+import org.gradle.jvm.tasks.Jar
+import org.gradle.kotlin.dsl.create
+import org.gradle.kotlin.dsl.dependencies
+import org.gradle.kotlin.dsl.findByType
+import org.gradle.kotlin.dsl.getByType
+import org.gradle.kotlin.dsl.named
+import org.gradle.kotlin.dsl.withModule
+import org.gradle.kotlin.dsl.withType
+import org.gradle.plugin.devel.plugins.JavaGradlePluginPlugin
+import org.gradle.plugin.devel.tasks.ValidatePlugins
+import org.gradle.process.CommandLineArgumentProvider
+import org.jetbrains.androidx.build.jetBrainsGetDefaultAndroidBaseJavaVersion
+import org.jetbrains.androidx.build.jetBrainsGetDefaultTargetJavaVersion
+import org.jetbrains.kotlin.gradle.dsl.ExplicitApiMode
+import org.jetbrains.kotlin.gradle.dsl.JvmTarget
+import org.jetbrains.kotlin.gradle.dsl.KotlinAndroidProjectExtension
+import org.jetbrains.kotlin.gradle.dsl.KotlinMultiplatformExtension
+import org.jetbrains.kotlin.gradle.dsl.KotlinProjectExtension
+import org.jetbrains.kotlin.gradle.dsl.KotlinVersion
+import org.jetbrains.kotlin.gradle.plugin.KotlinBaseApiPlugin
+import org.jetbrains.kotlin.gradle.plugin.KotlinBasePluginWrapper
+import org.jetbrains.kotlin.gradle.plugin.KotlinMultiplatformPluginWrapper
+import org.jetbrains.kotlin.gradle.plugin.KotlinPlatformType
+import org.jetbrains.kotlin.gradle.plugin.KotlinSourceSet
+import org.jetbrains.kotlin.gradle.targets.jvm.KotlinJvmTarget
+import org.jetbrains.kotlin.gradle.tasks.KotlinCompilationTask
+import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
+import org.jetbrains.kotlin.gradle.tasks.KotlinJvmCompile
+
+/**
+ * A plugin which enables all of the Gradle customizations for AndroidX. This plugin reacts to other
+ * plugins being added and adds required and optional functionality.
+ */
+abstract class AndroidXImplPlugin @Inject constructor() : Plugin {
+ @get:Inject abstract val registry: BuildEventsListenerRegistry
+ @get:Inject abstract val buildFeatures: BuildFeatures
+
+ override fun apply(project: Project) {
+ if (project.isRoot)
+ throw Exception("Root project should use AndroidXRootImplPlugin instead")
+ val androidXExtension = initializeAndroidXExtension(project)
+
+ val androidXKmpExtension =
+ project.extensions.create(
+ AndroidXMultiplatformExtension.EXTENSION_NAME,
+ project,
+ )
+
+ project.tasks.register(BUILD_ON_SERVER_TASK, DefaultTask::class.java)
+ // Perform different actions based on which plugins have been applied to the project.
+ // Many of the actions overlap, ex. API tracking.
+ project.plugins.configureEach { plugin ->
+ when (plugin) {
+ is JavaGradlePluginPlugin -> configureGradlePluginPlugin(project)
+ is JavaPlugin -> configureWithJavaPlugin(project, androidXExtension)
+ is LibraryPlugin -> configureWithLibraryPlugin(project, androidXExtension)
+ is AppPlugin -> configureWithAppPlugin(project, androidXExtension)
+ is TestPlugin -> configureWithTestPlugin(project, androidXExtension)
+ is KspGradleSubplugin -> configureWithKspPlugin(project)
+ is KotlinMultiplatformAndroidPlugin ->
+ configureWithKotlinMultiplatformAndroidPlugin(
+ project,
+ androidXKmpExtension.agpKmpExtension,
+ androidXExtension,
+ )
+ is KotlinBasePluginWrapper,
+ is KotlinBaseApiPlugin ->
+ configureWithKotlinPlugin(
+ project,
+ androidXExtension,
+ plugin,
+ androidXKmpExtension,
+ )
+ is ProtobufPlugin -> configureProtobufPlugin(project)
+ }
+ }
+
+ project.configureLint()
+ project.configureKtfmt()
+ project.configureKotlinVersion()
+ project.configureJavaFormat()
+
+ // Avoid conflicts between full Guava and LF-only Guava.
+ project.configureGuavaUpgradeHandler()
+
+ // Configure all Jar-packing tasks for hermetic builds.
+ project.tasks.withType(Zip::class.java).configureEach { it.configureForHermeticBuild() }
+ project.tasks.withType(Copy::class.java).configureEach { it.configureForHermeticBuild() }
+
+ val allHostTests = project.tasks.register("allHostTests")
+ // copy host side test results to DIST
+ project.tasks.withType(AbstractTestTask::class.java) { task ->
+ configureTestTask(project, task, allHostTests, androidXExtension)
+ }
+
+ project.configureTaskTimeouts()
+ project.configureMavenArtifactUpload(androidXExtension, androidXKmpExtension) {
+ if (buildFeatures.isIsolatedProjectsEnabled()) return@configureMavenArtifactUpload
+ project.addCreateLibraryBuildInfoFileTasks(androidXExtension, androidXKmpExtension)
+ }
+ project.configureProjectStructureValidation(androidXExtension)
+ project.configureProjectVersionValidation(androidXExtension)
+ project.validateMultiplatformPluginHasNotBeenApplied()
+
+ project.tasks.register("printCoordinates", PrintProjectCoordinatesTask::class.java) {
+ it.configureWithAndroidXExtension(androidXExtension)
+ }
+ project.configureConstraintsWithinGroup(androidXExtension)
+ project.validateProjectParser(androidXExtension)
+ project.validateAllArchiveInputsRecognized()
+ project.afterEvaluate {
+ if (androidXExtension.shouldPublishSbom().get()) {
+ project.configureSbomPublishing(androidXExtension.isIsolatedProjectsEnabled())
+ }
+ if (androidXExtension.shouldPublish.get()) {
+ project.validatePublishedMultiplatformHasDefault()
+ project.addLicensesToPublishedArtifacts(androidXExtension.license)
+ project.registerValidateRelocatedDependenciesTask()
+ }
+ project.registerValidateMultiplatformSourceSetNamingTask()
+ project.validateLintVersionTestExists(androidXExtension)
+ }
+ TaskUpToDateValidator.setup(project, registry)
+
+ project.workaroundAndroidXDependencyResolutions()
+ project.configureSamplesProject()
+ project.configureMaxDepVersions(androidXExtension)
+ project.configureUnzipChromeBuildService()
+
+ project.configureDependencyAnalysisPlugin()
+ }
+
+ private fun initializeAndroidXExtension(project: Project): AndroidXExtension {
+ val versionService = LibraryVersionsService.registerOrGet(project).get()
+ val listProjectsService = ListProjectsService.registerOrGet(project)
+ return project.extensions
+ .create(
+ EXTENSION_NAME,
+ project,
+ versionService.libraryVersions,
+ versionService.libraryGroups.values.toList(),
+ versionService.libraryGroupsByGroupId,
+ versionService.overrideLibraryGroupsByProjectPath,
+ listProjectsService.map { it.allPossibleProjects },
+ { project.getHeadShaProvider() },
+ { configurationName: String ->
+ configureAarAsJarForConfiguration(project, configurationName)
+ },
+ )
+ .apply { kotlinTarget.set(KotlinTarget.DEFAULT) }
+ }
+
+ /**
+ * Disables timestamps and ensures filesystem-independent archive ordering to maximize
+ * cross-machine byte-for-byte reproducibility of artifacts.
+ */
+ private fun Zip.configureForHermeticBuild() {
+ isReproducibleFileOrder = true
+ isPreserveFileTimestamps = false
+ }
+
+ private fun Copy.configureForHermeticBuild() {
+ duplicatesStrategy = DuplicatesStrategy.FAIL
+ }
+
+ private fun configureTestTask(
+ project: Project,
+ task: AbstractTestTask,
+ anchorTask: TaskProvider,
+ androidXExtension: AndroidXExtension,
+ ) {
+ if (isJetBrainsFork(project)) return
+ anchorTask.configure { it.dependsOn(task) }
+ val xmlReportDestDir = project.getHostTestResultDirectory()
+ val testName = "${project.path}:${task.name}"
+ project.addToModuleInfo(testName, buildFeatures.isIsolatedProjectsEnabled())
+ androidXExtension.testModuleNames.add(testName)
+ val archiveName = "$testName.zip"
+ if (project.isDisplayTestOutput()) {
+ // Enable tracing to see results in command line
+ task.testLogging.apply {
+ events =
+ hashSetOf(TestLogEvent.FAILED, TestLogEvent.SKIPPED, TestLogEvent.STANDARD_OUT)
+ showExceptions = true
+ showCauses = true
+ showStackTraces = true
+ exceptionFormat = TestExceptionFormat.FULL
+ }
+ } else {
+ task.testLogging.apply {
+ showExceptions = false
+ // Disable all output, including the names of the failing tests, by specifying
+ // that the minimum granularity we're interested in is this very high number
+ // (which is higher than the current maximum granularity that Gradle offers (3))
+ minGranularity = 1000
+ }
+ val testTaskName = task.name
+ val capitalizedTestTaskName =
+ testTaskName.replaceFirstChar {
+ if (it.isLowerCase()) it.titlecase(Locale.getDefault()) else it.toString()
+ }
+ val xmlReport = task.reports.junitXml
+ if (xmlReport.required.get()) {
+ val zipXmlTask =
+ project.tasks.register(
+ "zipXmlResultsOf$capitalizedTestTaskName",
+ Zip::class.java,
+ ) {
+ it.destinationDirectory.set(xmlReportDestDir)
+ it.archiveFileName.set(archiveName)
+ it.from(project.file(xmlReport.outputLocation))
+ it.include("*.xml")
+ AffectedModuleDetector.configureTaskGuard(it)
+ }
+ task.finalizedBy(zipXmlTask)
+ }
+ }
+ }
+
+ /** Configures the project to use the Kotlin version specified by `androidx.kotlinTarget`. */
+ private fun Project.configureKotlinVersion() {
+ val kotlinVersionStringProvider = androidXConfiguration.kotlinBomVersion
+
+ // Resolve unspecified Kotlin versions to the target version.
+ // TODO(b/443037365): Remove when bug fixed as built-in Kotlin would handle this
+ configurations.configureEach { configuration ->
+ configuration.withDependencies { dependencySet ->
+ dependencySet.filterIsInstance().forEach { dependency ->
+ if (
+ dependency.group == "org.jetbrains.kotlin" &&
+ dependency.version.isNullOrEmpty()
+ ) {
+ project.dependencies.constraints.add(
+ configuration.name,
+ dependency.module.toString(),
+ ) {
+ it.version { constraint ->
+ constraint.require(kotlinVersionStringProvider.get())
+ }
+ }
+ }
+ }
+ }
+ }
+
+ fun Provider.toKotlinVersionProvider() = map { version ->
+ KotlinVersion.fromVersion(version.substringBeforeLast('.'))
+ }
+
+ // Set the Kotlin compiler's API and language version to ensure bytecode is compatible.
+ val kotlinVersionProvider = kotlinVersionStringProvider.toKotlinVersionProvider()
+ tasks.configureEach { task ->
+ if (task is KotlinCompilationTask<*>) {
+ task.compilerOptions.apiVersion.set(kotlinVersionProvider)
+ task.compilerOptions.languageVersion.set(kotlinVersionProvider)
+ }
+ }
+
+ // Specify coreLibrariesVersion for consumption by Kotlin Gradle Plugin. Note that KGP does
+ // not explicitly support varying the version between tasks/configurations for a given
+ // project, so this is not strictly correct. Picking the non-test (e.g. lower) value seems
+ // to work, though.
+ afterEvaluate { evaluatedProject ->
+ evaluatedProject.kotlinExtensionOrNull?.let { kotlinExtension ->
+ kotlinExtension.coreLibrariesVersion = kotlinVersionStringProvider.get()
+ }
+ if (evaluatedProject.androidXExtension.shouldPublish.get()) {
+ tasks.register(
+ CheckKotlinApiTargetTask.TASK_NAME,
+ CheckKotlinApiTargetTask::class.java,
+ ) {
+ it.kotlinTarget.set(kotlinVersionProvider)
+ it.outputFile.set(layout.buildDirectory.file("kotlinApiTargetCheckReport.txt"))
+ }
+ addToBuildOnServer(CheckKotlinApiTargetTask.TASK_NAME)
+ }
+ }
+
+ // Resolve classpath conflicts caused by kotlin-stdlib-jdk7 and -jdk8 artifacts by amending
+ // the kotlin-stdlib artifact metadata to add same-version constraints.
+ project.dependencies {
+ components { componentMetadata ->
+ componentMetadata.withModule(
+ "org.jetbrains.kotlin:kotlin-stdlib"
+ )
+ }
+ }
+ }
+
+ @CacheableRule
+ internal abstract class KotlinStdlibDependenciesRule : ComponentMetadataRule {
+ override fun execute(context: ComponentMetadataContext) {
+ val module = context.details.id
+ val version = module.version
+ context.details.allVariants { variantMetadata ->
+ variantMetadata.withDependencyConstraints { constraintsMetadata ->
+ val reason = "${module.name} is in atomic group ${module.group}"
+ constraintsMetadata.add("org.jetbrains.kotlin:kotlin-stdlib-jdk7:$version") {
+ it.because(reason)
+ }
+ constraintsMetadata.add("org.jetbrains.kotlin:kotlin-stdlib-jdk8:$version") {
+ it.because(reason)
+ }
+ }
+ }
+ }
+ }
+
+ private fun configureWithKotlinPlugin(
+ project: Project,
+ androidXExtension: AndroidXExtension,
+ plugin: Any,
+ androidXMultiplatformExtension: AndroidXMultiplatformExtension,
+ ) {
+ val targetsAndroid =
+ project.provider {
+ project.plugins.hasPlugin(LibraryPlugin::class.java) ||
+ project.plugins.hasPlugin(AppPlugin::class.java) ||
+ project.plugins.hasPlugin(TestPlugin::class.java) ||
+ project.plugins.hasPlugin(KotlinMultiplatformAndroidPlugin::class.java)
+ }
+ val defaultJavaTargetVersion =
+ androidXExtension.type.map {
+ jetBrainsGetDefaultTargetJavaVersion(it, project).toString()
+ }
+ val defaultJvmTarget = defaultJavaTargetVersion.map { JvmTarget.fromTarget(it) }
+ if (plugin is KotlinMultiplatformPluginWrapper) {
+ project.extensions.getByType().apply {
+ targets.withType().configureEach { t ->
+ t.compilations.configureEach { compilation ->
+ // Replace with compilation.compileJavaTaskProvider?.configure {}
+ // when b/438995010 is fixed
+ @Suppress("DEPRECATION")
+ compilation.compilerOptions.configure { jvmTarget.set(defaultJvmTarget) }
+ compilation.compileTaskProvider.configure {
+ it.compilerOptions.jvmTarget.set(defaultJvmTarget)
+ }
+ }
+ }
+ targets.withType(KotlinJvmTarget::class.java).configureEach { target ->
+ val defaultTargetVersionForNonAndroidTargets =
+ androidXExtension.type.map {
+ jetBrainsGetDefaultTargetJavaVersion(
+ softwareType = it,
+ project = project,
+ targetName = target.name,
+ )
+ .toString()
+ }
+ val defaultJvmTargetForNonAndroidTargets =
+ defaultTargetVersionForNonAndroidTargets.map { JvmTarget.fromTarget(it) }
+ target.compilations.configureEach { compilation ->
+ compilation.compileJavaTaskProvider?.configure { javaCompile ->
+ javaCompile.targetCompatibility =
+ defaultTargetVersionForNonAndroidTargets.get()
+ javaCompile.sourceCompatibility =
+ defaultTargetVersionForNonAndroidTargets.get()
+ }
+ compilation.compileTaskProvider.configure { kotlinCompile ->
+ kotlinCompile.compilerOptions {
+ jvmTarget.set(defaultJvmTargetForNonAndroidTargets)
+ // Set jdk-release version for non-Android KMP targets
+ freeCompilerArgs.add(
+ defaultTargetVersionForNonAndroidTargets.map {
+ "-Xjdk-release=$it"
+ }
+ )
+ }
+ }
+ }
+ }
+ }
+ } else {
+ project.tasks.withType(KotlinJvmCompile::class.java).configureEach { task ->
+ task.compilerOptions.jvmTarget.set(defaultJvmTarget)
+ task.compilerOptions.freeCompilerArgs.addAll(
+ targetsAndroid.zip(defaultJavaTargetVersion) { targetsAndroid, version ->
+ if (targetsAndroid) {
+ emptyList()
+ } else {
+ // Set jdk-release version for non-Android JVM projects
+ listOf("-Xjdk-release=$version")
+ }
+ }
+ )
+ }
+ }
+ project.tasks.withType(KotlinCompile::class.java).configureEach { task ->
+ val kotlinCompilerArgs =
+ project.provider {
+ val args =
+ mutableListOf(
+ "-Xskip-metadata-version-check",
+ "-jvm-default=no-compatibility",
+ )
+ if (androidXExtension.type.get().targetsKotlinConsumersOnly) {
+ // The Kotlin Compiler adds intrinsic assertions which are only relevant
+ // when the code is consumed by Java users. Therefore we can turn this off
+ // when code is being consumed by Kotlin users.
+
+ // Additional Context:
+ // https://github.com/JetBrains/kotlin/blob/master/compiler/cli/cli-common/src/org/jetbrains/kotlin/cli/common/arguments/K2JVMCompilerArguments.kt#L239
+ // b/280633711
+ args +=
+ listOf(
+ "-Xno-param-assertions",
+ "-Xno-call-assertions",
+ "-Xno-receiver-assertions",
+ )
+ }
+
+ args
+ }
+ task.compilerOptions.freeCompilerArgs.addAll(kotlinCompilerArgs)
+ }
+ if (plugin is KotlinMultiplatformPluginWrapper) {
+ KonanPrebuiltsSetup.configureKonanDirectory(project)
+ project.afterEvaluate {
+ val libraryExtension = project.extensions.findByType()
+ if (libraryExtension != null) {
+ libraryExtension.configureAndroidLibraryWithMultiplatformPluginOptions()
+ } else if (!androidXMultiplatformExtension.hasAndroidMultiplatform()) {
+ // Kotlin MPP does not apply java plugin anymore, but we still want to configure
+ // all java-related tasks.
+ // We only need to do this when project does not have Android plugin, which
+ // already
+ // configures Java tasks.
+ configureWithJavaPlugin(project, androidXExtension)
+ }
+ }
+ project.configureKmp()
+ project.configureSourceJarForMultiplatform()
+
+ // Disable any source JAR task(s) added by KotlinMultiplatformPlugin.
+ // https://youtrack.jetbrains.com/issue/KT-55881
+ project.tasks.withType(Jar::class.java).configureEach { jarTask ->
+ if (jarTask.name == "androidSourcesJar" || jarTask.name == "jvmSourcesJar") {
+ // We can't set duplicatesStrategy directly on the Jar task since it will get
+ // overridden when the KotlinMultiplatformPlugin creates child specs, but we
+ // can set it on a per-file basis.
+ jarTask.eachFile { fileCopyDetails ->
+ fileCopyDetails.duplicatesStrategy = DuplicatesStrategy.EXCLUDE
+ }
+ }
+ }
+ }
+
+ project.afterEvaluate {
+ val kotlinExtension = project.kotlinExtensionOrNull
+ kotlinExtension?.explicitApi =
+ if (androidXExtension.shouldEnforceKotlinStrictApiMode().get()) {
+ ExplicitApiMode.Strict
+ } else {
+ ExplicitApiMode.Disabled
+ }
+ if (plugin is KotlinBaseApiPlugin) {
+ // TODO(b/443080559): Remove when built-in Kotlin adds kotlin-test-junit
+ // automatically
+ (kotlinExtension as KotlinAndroidProjectExtension)
+ .target
+ .compilations
+ .configureEach { compilation ->
+ if (!compilation.name.contains("test", ignoreCase = true))
+ return@configureEach
+ compilation.defaultSourceSet.dependencies {
+ implementation(kotlin("test-junit"))
+ }
+ }
+ }
+ }
+ }
+
+ private fun configureWithAppPlugin(project: Project, androidXExtension: AndroidXExtension) {
+ project.extensions.getByType().apply {
+ configureAndroidBaseOptions(project, androidXExtension)
+ defaultConfig.targetSdk = project.defaultAndroidConfig.targetSdk
+ val debugSigningConfig = signingConfigs.getByName("debug")
+ // Use a local debug keystore to avoid build server issues.
+ debugSigningConfig.storeFile = project.getKeystore()
+ buildTypes.configureEach { buildType ->
+ // Sign all the builds (including release) with debug key
+ buildType.signingConfig = debugSigningConfig
+ }
+ configureAndroidApplicationOptions(project, androidXExtension)
+ excludeVersionFiles(packaging.resources)
+ }
+
+ project.extensions.getByType().apply {
+ beforeVariants(selector().withBuildType("release")) { variant ->
+ // Cast is needed because ApplicationAndroidComponentsExtension implements both
+ // HasUnitTestBuilder and VariantBuilder, and VariantBuilder#enableUnitTest is
+ // deprecated in favor of HasUnitTestBuilder#enableUnitTest.
+ // Remove the cast when we upgrade to AGP 9.0.0
+ (variant as HasUnitTestBuilder).enableUnitTest = false
+ }
+ onVariants { it.configureTests(project.getKeystore()) }
+ }
+
+ project.configureJavaCompilationWarnings(
+ androidXExtension = androidXExtension,
+ isTestApp = true,
+ )
+ project.buildOnServerDependsOnAssembleRelease()
+ }
+
+ private fun configureWithTestPlugin(project: Project, androidXExtension: AndroidXExtension) {
+ project.extensions.getByType().apply {
+ configureAndroidBaseOptions(project, androidXExtension)
+ defaultConfig.targetSdk = project.defaultAndroidConfig.targetSdk
+ val debugSigningConfig = signingConfigs.getByName("debug")
+ // Use a local debug keystore to avoid build server issues.
+ debugSigningConfig.storeFile = project.getKeystore()
+ buildTypes.configureEach { buildType ->
+ // Sign all the builds (including release) with debug key
+ buildType.signingConfig = debugSigningConfig
+ }
+ project.configureTestConfigGeneration(
+ androidXExtension.isIsolatedProjectsEnabled(),
+ androidXExtension,
+ )
+ project.addAppApkToTestConfigGeneration(androidXExtension)
+ excludeVersionFiles(packaging.resources)
+ }
+ project.configureJavaCompilationWarnings(androidXExtension)
+ }
+
+ private fun configureWithKspPlugin(project: Project) =
+ project.extensions.getByType().useKsp2.set(true)
+
+ private fun configureCommonAndroidLibrary(
+ project: Project,
+ androidXExtension: AndroidXExtension,
+ androidComponents:
+ AndroidComponentsExtension<*, out LibraryVariantBuilder, out LibraryVariant>,
+ ) {
+ androidComponents.onVariants { variant ->
+ variant.configureTests(project.getKeystore())
+ variant.enableMicrobenchmarkInternalDefaults(project)
+ project.validateKotlinModuleFiles(
+ variant.name,
+ variant.artifacts.get(SingleArtifact.AAR),
+ )
+ }
+
+ project.disableStrictVersionConstraints()
+ project.configureJavaCompilationWarnings(androidXExtension)
+ project.setUpCheckDocsTask(androidXExtension)
+ }
+
+ private fun KotlinSourceSet.includesSourceSet(otherName: String): Boolean =
+ name == otherName || dependsOn.any { it.includesSourceSet(otherName) }
+
+ private fun AarMetadata.configure(compileSdk: Int?) {
+ // Taken from
+ // https://developer.android.com/build/releases/gradle-plugin#api-level-support
+ fun mapToMinAgpVersion(compileSdk: Int): String {
+ return when (compileSdk) {
+ 33 -> "7.2.0"
+ 34 -> "8.1.1"
+ 35 -> "8.6.0"
+ 36 -> "8.9.1"
+ 37 -> "9.1.0"
+ else -> throw Exception("Unknown compileSdk to minAgpVersion mapping")
+ }
+ }
+
+ // Propagate the compileSdk value into minCompileSdk. Don't propagate
+ // compileSdkExtension, since only one library actually depends on the extension
+ // APIs and they can explicitly declare that in their build.gradle. Note that when
+ // we're using a preview SDK, the value for compileSdk will be null and the
+ // resulting AAR metadata won't have a minCompileSdk --
+ // this is okay because AGP automatically embeds forceCompileSdkPreview in the AAR
+ // metadata and uses it instead of minCompileSdk.
+ if (compileSdk == null) return
+ minCompileSdk = compileSdk
+ minAgpVersion = mapToMinAgpVersion(compileSdk)
+ }
+
+ private fun configureWithKotlinMultiplatformAndroidPlugin(
+ project: Project,
+ kotlinMultiplatformAndroidTarget: KotlinMultiplatformAndroidLibraryTarget,
+ androidXExtension: AndroidXExtension,
+ ) {
+ val kotlinMultiplatformAndroidComponentsExtension =
+ project.extensions.getByType()
+ kotlinMultiplatformAndroidTarget.configureAndroidBaseOptions(
+ project,
+ kotlinMultiplatformAndroidComponentsExtension,
+ androidXExtension,
+ )
+ configureCommonAndroidLibrary(
+ project,
+ androidXExtension,
+ kotlinMultiplatformAndroidComponentsExtension,
+ )
+ kotlinMultiplatformAndroidComponentsExtension.apply {
+ finalizeDsl {
+ it.aarMetadata.configure(it.compileSdk)
+ it.lint.targetSdk = project.defaultAndroidConfig.targetSdk
+ project.setUpBlankProguardFileForKmpAarIfNeeded(
+ kotlinMultiplatformAndroidTarget.optimization.consumerKeepRules
+ )
+ }
+ }
+
+ kotlinMultiplatformAndroidComponentsExtension.onVariants { variant ->
+ project.configureProjectForApiTasks(
+ AndroidMultiplatformApiTaskConfig(variant),
+ androidXExtension,
+ )
+ project.configureProjectForKzipTasks(
+ AndroidMultiplatformApiTaskConfig(variant),
+ androidXExtension,
+ )
+ project.configurePublicResourcesStub(variant)
+ project.configureMultiplatformSourcesForAndroid(androidXExtension.samplesProjects)
+ }
+
+ project.configureVersionFileWriter(project.multiplatformExtension!!, androidXExtension)
+
+ project.configureDependencyVerification(androidXExtension) { taskProvider ->
+ kotlinMultiplatformAndroidTarget.compilations.configureEach {
+ taskProvider.configure { task -> task.dependsOn(it.compileTaskProvider) }
+ }
+ }
+ project.afterEvaluate {
+ project.addToBuildOnServer("assembleAndroidMain")
+ project.addToBuildOnServer("lint")
+ // Created to be consumed by docs-tip-of-tree
+ project.configurations.register("androidIntermediates") {
+ it.isCanBeResolved = false
+ it.attributes.attribute(
+ Usage.USAGE_ATTRIBUTE,
+ project.objects.named(Usage.JAVA_RUNTIME),
+ )
+ it.attributes.attribute(
+ Category.CATEGORY_ATTRIBUTE,
+ project.objects.named(Category.LIBRARY),
+ )
+ it.attributes.attribute(
+ BuildTypeAttr.ATTRIBUTE,
+ project.objects.named("release"),
+ )
+ // disable, as it triggers android compilation during IDEA sync
+ if (!isJetBrainsFork(project)) it.outgoing.artifact(project.tasks.named("createFullJarAndroidMain"))
+ }
+ }
+ }
+
+ private fun configureProtobufPlugin(project: Project) {
+ project.extensions.getByType(ProtobufExtension::class.java).apply {
+ protoc { it.artifact = project.getLibraryByName("protobufCompiler").toString() }
+ generateProtoTasks {
+ it.all().configureEach { task ->
+ // java projects have "java" output enabled, however Android projects do not
+ // so we need to create it for Android projects.
+ // https://github.com/google/protobuf-gradle-plugin?tab=readme-ov-file#default-outputs
+ val java =
+ if (
+ project.plugins.hasPlugin("com.android.library") ||
+ project.plugins.hasPlugin("com.android.application")
+ ) {
+ task.builtins.register("java")
+ } else task.builtins.named("java")
+ java.configure { options -> options.option("lite") }
+ }
+ }
+ }
+ }
+
+ /**
+ * Excludes files telling which versions of androidx libraries were used in test apks, to avoid
+ * invalidating caches as often
+ */
+ private fun excludeVersionFiles(packaging: com.android.build.api.variant.ResourcesPackaging) {
+ packaging.excludes.add("/META-INF/androidx*.version")
+ }
+
+ /**
+ * Excludes files telling which versions of androidx libraries were used in test apks, to avoid
+ * invalidating caches as often
+ */
+ private fun excludeVersionFiles(packaging: com.android.build.api.dsl.ResourcesPackaging) {
+ packaging.excludes.add("/META-INF/androidx*.version")
+ }
+
+ private fun Project.buildOnServerDependsOnAssembleRelease() {
+ project.addToBuildOnServer("assembleRelease")
+ }
+
+ private fun HasDeviceTests.configureTests(keystore: File) {
+ deviceTests.forEach { (_, deviceTest) ->
+ deviceTest.packaging.resources.apply {
+ excludeVersionFiles(this)
+
+ // Workaround a limitation in AGP that fails to merge these META-INF license files.
+ pickFirsts.add("/META-INF/AL2.0")
+ // In addition to working around the above issue, we exclude the LGPL2.1 license as
+ // we're
+ // approved to distribute code via AL2.0 and the only dependencies which pull in
+ // LGPL2.1
+ // are currently dual-licensed with AL2.0 and LGPL2.1. The affected dependencies
+ // are:
+ // - net.java.dev.jna:jna:5.5.0
+ excludes.add("/META-INF/LGPL2.1")
+
+ // AGP is unable to merge these and multiple artifacts ship this files
+ // e.g. org/jspecify/jspecify/1.0.0/jspecify-1.0.0.jar
+ // org/bouncycastle/bcprov-jdk18on/1.78.1/bcprov-jdk18on-1.78.1.jar
+ pickFirsts.add("META-INF/versions/9/OSGI-INF/MANIFEST.MF")
+ }
+ }
+ }
+
+ private fun configureWithLibraryPlugin(project: Project, androidXExtension: AndroidXExtension) {
+ val buildTypeForTests = "release"
+ val libraryExtension = project.extensions.getByType()
+ libraryExtension.apply {
+ publishing { singleVariant(DEFAULT_PUBLISH_CONFIG) }
+
+ configureAndroidBaseOptions(project, androidXExtension)
+ val debugSigningConfig = signingConfigs.getByName("debug")
+ // Use a local debug keystore to avoid build server issues.
+ debugSigningConfig.storeFile = project.getKeystore()
+ buildTypes.configureEach { buildType ->
+ // Sign all the builds (including release) with debug key
+ buildType.signingConfig = debugSigningConfig
+ }
+ testBuildType = buildTypeForTests
+ project.configureTestConfigGeneration(
+ androidXExtension.isIsolatedProjectsEnabled(),
+ androidXExtension,
+ )
+ project.addAppApkToTestConfigGeneration(androidXExtension)
+ }
+
+ val libraryAndroidComponentsExtension =
+ project.extensions.getByType()
+ configureCommonAndroidLibrary(project, androidXExtension, libraryAndroidComponentsExtension)
+
+ libraryAndroidComponentsExtension.apply {
+ finalizeDsl {
+ it.defaultConfig.aarMetadata.configure(it.compileSdk)
+ project.setUpBlankProguardFileForAarIfNeeded(it.defaultConfig)
+ it.lint.targetSdk = project.defaultAndroidConfig.targetSdk
+ it.testOptions.targetSdk = project.defaultAndroidConfig.targetSdk
+ // Replace with a public API once available, see b/360392255
+ it.buildTypes.configureEach { buildType ->
+ if (buildType.name == buildTypeForTests && !project.hasBenchmarkPlugin())
+ (buildType as TestBuildType).isDebuggable = true
+ }
+ }
+ // Disable debug build type for Android Libraries
+ beforeVariants(selector().withBuildType("debug")) { variant -> variant.enable = false }
+ }
+
+ project.configureVersionFileWriter(libraryAndroidComponentsExtension, androidXExtension)
+
+ val prebuiltLibraries = listOf("libtracing_perfetto.so", "libc++_shared.so")
+ libraryAndroidComponentsExtension.onVariants { variant ->
+ if (variant.buildType == DEFAULT_PUBLISH_CONFIG) {
+ // Standard docs, resource API, and Metalava configuration for AndroidX projects.
+ project.configureProjectForApiTasks(
+ LibraryApiTaskConfig(variant),
+ androidXExtension,
+ )
+ project.configureProjectForKzipTasks(
+ LibraryApiTaskConfig(variant),
+ androidXExtension,
+ )
+ }
+ if (variant.name == DEFAULT_PUBLISH_CONFIG) {
+ project.configureSourceJarForAndroid(variant, androidXExtension.samplesProjects)
+ project.configurePublicResourcesStub(variant)
+ project.configureDependencyVerification(androidXExtension) { taskProvider ->
+ taskProvider.configure { task -> task.dependsOn("compileReleaseJavaWithJavac") }
+ }
+ }
+ 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)
+ }
+ project.buildOnServerDependsOnAssembleRelease()
+ }
+
+ private fun configureGradlePluginPlugin(project: Project) {
+ project.tasks.withType(ValidatePlugins::class.java).configureEach {
+ it.enableStricterValidation.set(true)
+ it.failOnWarning.set(true)
+ }
+ project.addToBuildOnServer("validatePlugins")
+ SdkResourceGenerator.generateForHostTest(project)
+ }
+
+ private fun configureWithJavaPlugin(project: Project, androidXExtension: AndroidXExtension) {
+ if (
+ project.multiplatformExtension != null &&
+ !project.multiplatformExtension!!.hasJvmTarget()
+ ) {
+ return
+ }
+ project.configureErrorProneForJava()
+
+ // Force Java 1.8 source- and target-compatibility for all Java libraries.
+ val javaExtension = project.extensions.getByType()
+ project.afterEvaluate {
+ javaExtension.apply {
+ val defaultTargetJavaVersion =
+ jetBrainsGetDefaultTargetJavaVersion(androidXExtension.type.get(), project)
+ sourceCompatibility = defaultTargetJavaVersion
+ targetCompatibility = defaultTargetJavaVersion
+ }
+ if (
+ !project.plugins.hasPlugin(KotlinBasePluginWrapper::class.java) ||
+ !project.plugins.hasPlugin(KotlinBaseApiPlugin::class.java)
+ ) {
+ project.configureSourceJarForJava(androidXExtension.samplesProjects)
+ }
+ }
+
+ project.setUpBlankProguardFileForJarIfNeeded(javaExtension)
+ project.configureJavaCompilationWarnings(androidXExtension)
+
+ if (
+ project.multiplatformExtension == null ||
+ project.multiplatformExtension!!.hasJavaEnabled()
+ ) {
+ project.configureDependencyVerification(androidXExtension) { taskProvider ->
+ taskProvider.configure { task ->
+ task.dependsOn(project.tasks.named(JavaPlugin.COMPILE_JAVA_TASK_NAME))
+ }
+ }
+ }
+
+ val apiTaskConfig =
+ if (project.multiplatformExtension != null) {
+ KmpApiTaskConfig
+ } else {
+ JavaApiTaskConfig
+ }
+
+ project.configureProjectForApiTasks(apiTaskConfig, androidXExtension)
+ project.configureProjectForKzipTasks(apiTaskConfig, androidXExtension)
+ project.setUpCheckDocsTask(androidXExtension)
+
+ if (project.multiplatformExtension == null) {
+ project.addToBuildOnServer("jar")
+ } else {
+ val multiplatformExtension = project.multiplatformExtension!!
+ multiplatformExtension.targets.forEach {
+ if (it.platformType == KotlinPlatformType.jvm) {
+ val task = project.tasks.named(it.artifactsTaskName, Jar::class.java)
+ project.addToBuildOnServer(task)
+ }
+ }
+ }
+ }
+
+ private fun Project.configureProjectStructureValidation(androidXExtension: AndroidXExtension) {
+ if (isJetBrainsFork(project)) return
+ // AndroidXExtension.mavenGroup is not readable until afterEvaluate.
+ afterEvaluate {
+ val mavenGroup = androidXExtension.mavenGroup
+ val type = androidXExtension.type.get()
+ val isProbablyPublished =
+ type == SoftwareType.PUBLISHED_LIBRARY ||
+ type == SoftwareType.PUBLISHED_LIBRARY_ONLY_USED_BY_KOTLIN_CONSUMERS
+ if (
+ mavenGroup != null && isProbablyPublished && androidXExtension.shouldPublish.get()
+ ) {
+ validateProjectMavenGroup(mavenGroup.group)
+ validateProjectMavenName(androidXExtension.name.get(), mavenGroup.group)
+ validateProjectStructure(mavenGroup.group)
+ }
+ }
+ }
+
+ private fun Project.configureProjectVersionValidation(androidXExtension: AndroidXExtension) {
+ // AndroidXExtension.mavenGroup is not readable until afterEvaluate.
+ afterEvaluate { androidXExtension.validateMavenVersion() }
+ }
+
+ private fun Any.configureAndroidBaseOptions(
+ project: Project,
+ androidXExtension: AndroidXExtension,
+ ) {
+ // Workaround to avoid specifying the parametrized types of CommonExtension explicitly
+ // So we can clean up the parameters in AGP
+ // The compiler can infer that this is CommonExtension from these checks
+ if (this !is ApplicationExtension && this !is LibraryExtension && this !is TestExtension) {
+ throw IllegalArgumentException("Unexpected extension: $this")
+ }
+ compileOptions.apply {
+ sourceCompatibility = jetBrainsGetDefaultAndroidBaseJavaVersion(project)
+ targetCompatibility = jetBrainsGetDefaultAndroidBaseJavaVersion(project)
+ }
+
+ val defaultMinSdk = project.defaultAndroidConfig.minSdk
+
+ // Suppress output of android:compileSdkVersion and related attributes (b/277836549).
+ androidResources.additionalParameters += "--no-compile-sdk-metadata"
+
+ compileSdk = project.defaultAndroidConfig.compileSdk
+
+ buildToolsVersion = project.defaultAndroidConfig.buildToolsVersion
+
+ defaultConfig.ndk.abiFilters.addAll(SUPPORTED_BUILD_ABIS)
+ defaultConfig.minSdk = defaultMinSdk
+ defaultConfig.testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
+
+ testOptions.animationsDisabled = !project.isMacrobenchmark()
+
+ project.afterEvaluate {
+ check(
+ !androidXExtension.shouldPublish.get() ||
+ !compileOptions.isCoreLibraryDesugaringEnabled
+ ) {
+ "AndroidX libraries are not permitted to use core library desugaring as it " +
+ "forces library users to also enable core library desugaring."
+ }
+
+ val minSdkVersion = defaultConfig.minSdk!!
+ check(minSdkVersion >= defaultMinSdk) {
+ "minSdkVersion $minSdkVersion lower than the default of $defaultMinSdk"
+ }
+ project.enforceBanOnVersionRanges()
+
+ if (androidXExtension.type.get().compilationTarget != CompilationTarget.DEVICE) {
+ throw IllegalStateException(
+ "${androidXExtension.type.get().name} libraries cannot apply the android plugin, as" +
+ " they do not target android devices"
+ )
+ }
+ }
+
+ project.configureErrorProneForAndroid()
+
+ // workaround for b/120487939
+ project.configurations.configureEach { configuration ->
+ // Gradle seems to crash on androidtest configurations
+ // preferring project modules...
+ if (!configuration.name.lowercase(Locale.US).contains("androidtest")) {
+ configuration.resolutionStrategy.preferProjectModules()
+ }
+ }
+
+ val componentsExtension =
+ project.extensions.getByType(AndroidComponentsExtension::class.java)
+ project.configureFtlRunner(componentsExtension)
+
+ // If a dependency is missing a debug variant, use release instead.
+ buildTypes.getByName("debug").matchingFallbacks.add("release")
+
+ // AGP warns if we use project.buildDir (or subdirs) for CMake's generated
+ // build files (ninja build files, CMakeCache.txt, etc.). Use a staging directory that
+ // lives alongside the project's buildDir.
+ @Suppress("DEPRECATION")
+ externalNativeBuild.cmake.buildStagingDirectory =
+ File(project.buildDir, "../nativeBuildStaging")
+
+ // Align the ELF region of native shared libs 16kb boundary
+ defaultConfig.externalNativeBuild.cmake.arguments.add(
+ "-DCMAKE_SHARED_LINKER_FLAGS=-Wl,-z,max-page-size=16384"
+ )
+ }
+
+ private fun KotlinMultiplatformAndroidLibraryTarget.configureAndroidBaseOptions(
+ project: Project,
+ componentsExtension: KotlinMultiplatformAndroidComponentsExtension,
+ androidXExtension: AndroidXExtension,
+ ) {
+ val defaultMinSdkVersion = project.defaultAndroidConfig.minSdk
+ val defaultCompileSdk = project.defaultAndroidConfig.compileSdk
+
+ compileSdk = defaultCompileSdk
+ buildToolsVersion = project.defaultAndroidConfig.buildToolsVersion
+
+ minSdk = defaultMinSdkVersion
+
+ lint.targetSdk = project.defaultAndroidConfig.targetSdk
+ compilations
+ .withType(KotlinMultiplatformAndroidDeviceTestCompilation::class.java)
+ .configureEach {
+ it.instrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
+ it.animationsDisabled = true
+ }
+
+ withHostTestBuilder {} // enable Android host tests
+ withDeviceTestBuilder { sourceSetTreeName = "test" }
+ .configure { signing.storeFile = project.getKeystore() }
+ configureTargetSdkForTests(project.defaultAndroidConfig.targetSdk)
+
+ // validate that SDK versions haven't been altered during evaluation
+ project.afterEvaluate {
+ val minSdkVersion = minSdk!!
+ check(minSdkVersion >= defaultMinSdkVersion) {
+ "minSdkVersion $minSdkVersion lower than the default of $defaultMinSdkVersion"
+ }
+ project.enforceBanOnVersionRanges()
+ }
+
+ project.configureTestConfigGeneration(
+ buildFeatures.isIsolatedProjectsEnabled(),
+ androidXExtension,
+ )
+ project.configureFtlRunner(componentsExtension)
+ }
+
+ // TODO(b/425976012): Set targetSdkForTests to project.defaultAndroidConfig.targetSdk
+ private fun KotlinMultiplatformAndroidLibraryTarget.configureTargetSdkForTests(version: Int?) {
+ checkNotNull(version) {
+ "version must be set for tests. call `configureTargetSdkForTests` in the `finalizeDsl` block"
+ }
+ compilations
+ .withType(KotlinMultiplatformAndroidDeviceTestCompilation::class.java)
+ .configureEach { it.targetSdk { this.version = release(version) } }
+
+ compilations
+ .withType(KotlinMultiplatformAndroidHostTestCompilation::class.java)
+ .configureEach { it.targetSdk { this.version = release(version.coerceAtMost(35)) } }
+ }
+
+ /**
+ * Adds a module handler replacement rule that treats full Guava (of any version) as an upgrade
+ * to ListenableFuture-only Guava. This prevents irreconcilable versioning conflicts and/or
+ * class duplication issues.
+ */
+ private fun Project.configureGuavaUpgradeHandler() {
+ // The full Guava artifact is very large, so they split off a special artifact containing a
+ // standalone version of the commonly-used ListenableFuture interface. However, they also
+ // structured the artifacts in a way that causes dependency resolution conflicts:
+ // - `com.google.guava:listenablefuture:1.0` contains only ListenableFuture
+ // - `com.google.guava:listenablefuture:9999.0` contains nothing
+ // - `com.google.guava:guava` contains all of Guava, including ListenableFuture
+ // If a transitive dependency includes `guava` as implementation-type and we have a direct
+ // API-type dependency on `listenablefuture:1.0`, then we'll get `listenablefuture:9999.0`
+ // on the compilation classpath -- which does not have the ListenableFuture class. However,
+ // if we tell Gradle to upgrade all LF dependencies to Guava then we'll get `guava` as an
+ // API-type dependency. See b/274621238 for more details.
+ project.dependencies {
+ modules { moduleHandler ->
+ moduleHandler.module("com.google.guava:listenablefuture") { module ->
+ module.replacedBy("com.google.guava:guava")
+ }
+ }
+ }
+ }
+
+ private fun Project.disableStrictVersionConstraints() {
+ // Gradle inserts strict version constraints to ensure that dependency versions are
+ // identical across main and test source sets. For normal projects, this ensures
+ // that test bytecode is binary- and behavior-compatible with the main source set's
+ // bytecode. For AndroidX, though, we require backward compatibility and therefore
+ // don't need to enforce such constraints.
+ project.configurations.configureEach { configuration ->
+ if (!configuration.isTest()) return@configureEach
+
+ configuration.dependencyConstraints.configureEach { dependencyConstraint ->
+ val strictVersion = dependencyConstraint.versionConstraint.strictVersion
+ if (strictVersion != "") {
+ // Migrate strict-type version constraints to required-type to allow upgrades.
+ dependencyConstraint.version { versionConstraint ->
+ versionConstraint.strictly("")
+ versionConstraint.require(strictVersion)
+ }
+ }
+ }
+ }
+ }
+
+ private fun LibraryExtension.configureAndroidLibraryWithMultiplatformPluginOptions() {
+ sourceSets.findByName("main")!!.manifest.srcFile("src/androidMain/AndroidManifest.xml")
+ sourceSets
+ .findByName("androidTest")!!
+ .manifest
+ .srcFile("src/androidDeviceTest/AndroidManifest.xml")
+ }
+
+ private fun Project.configureKmp() {
+ val kmpExtension =
+ checkNotNull(project.extensions.findByType()) {
+ """
+ Project ${project.path} applies kotlin multiplatform plugin but we cannot find the
+ KotlinMultiplatformExtension.
+ """
+ .trimIndent()
+ }
+
+ kmpExtension.targets.configureEach { kotlinTarget ->
+ kotlinTarget.compilations.configureEach { compilation ->
+ // Configure all KMP targets to allow expect/actual classes that are not stable.
+ // (see https://youtrack.jetbrains.com/issue/KT-61573)
+ compilation.compileTaskProvider.configure { task ->
+ task.compilerOptions.freeCompilerArgs.add("-Xexpect-actual-classes")
+ androidXConfiguration.kotlinApiVersion.let {
+ task.compilerOptions.apiVersion.set(it)
+ task.compilerOptions.languageVersion.set(it)
+ }
+ }
+ }
+ }
+ }
+
+ private fun ApplicationExtension.configureAndroidApplicationOptions(
+ project: Project,
+ androidXExtension: AndroidXExtension,
+ ) {
+ defaultConfig.apply {
+ versionCode = 1
+ versionName = "1.0"
+ }
+
+ project.configureTestConfigGeneration(
+ androidXExtension.isIsolatedProjectsEnabled(),
+ androidXExtension,
+ )
+ project.addAppApkToTestConfigGeneration(androidXExtension)
+ project.addAppApkToFtlRunner()
+ }
+
+ private fun Project.configureDependencyVerification(
+ androidXExtension: AndroidXExtension,
+ taskConfigurator: (TaskProvider) -> Unit,
+ ) {
+ if (buildFeatures.isIsolatedProjectsEnabled()) return
+ afterEvaluate {
+ if (androidXExtension.type.get().requiresDependencyVerification()) {
+ taskConfigurator(project.createVerifyDependencyVersionsTask())
+ }
+ }
+ }
+
+ // If this project wants other project in the same group to have the same version,
+ // this function configures those constraints.
+ private fun Project.configureConstraintsWithinGroup(androidXExtension: AndroidXExtension) {
+ if (
+ !project.shouldAddGroupConstraints().get() || buildFeatures.isIsolatedProjectsEnabled()
+ ) {
+ return
+ }
+ project.afterEvaluate {
+ // make sure that the project has a group
+ val projectGroup = androidXExtension.mavenGroup ?: return@afterEvaluate
+ // make sure that this group is configured to use a single version
+ projectGroup.atomicGroupVersion ?: return@afterEvaluate
+
+ // Under certain circumstances, a project is allowed to override its
+ // version see ( isGroupVersionOverrideAllowed ), in which case it's
+ // not participating in the versioning policy yet,
+ // and we don't assign it any version constraints
+ if (androidXExtension.mavenVersion != null) {
+ return@afterEvaluate
+ }
+
+ // We don't want to emit the same constraint into our .module file more than once,
+ // and we don't want to try to apply a constraint to a configuration that doesn't accept
+ // them,
+ // so we create a configuration to hold the constraints and make each other constraint
+ // extend it
+ val constraintConfiguration = project.configurations.create("groupConstraints")
+ project.configurations.configureEach { configuration ->
+ if (configuration != constraintConfiguration)
+ configuration.extendsFrom(constraintConfiguration)
+ }
+
+ val otherProjectsInSameGroup = androidXExtension.getOtherProjectsInSameGroup()
+ val constraints = project.dependencies.constraints
+ val allProjectsExist = buildContainsAllStandardProjects()
+ for (otherProject in otherProjectsInSameGroup) {
+ val otherGradlePath = otherProject.gradlePath
+ if (otherGradlePath == ":compose:ui:ui-android-stubs") {
+ // exemption for library that doesn't truly get published: b/168127161
+ continue
+ }
+ // We only enable constraints for builds that we intend to be able to publish from.
+ // If a project isn't included in a build we intend to be able to publish from,
+ // the project isn't going to be published.
+ // Sometimes this can happen when a project subset is enabled:
+ // The KMP project subset enabled by androidx_multiplatform_mac.sh contains
+ // :benchmark:benchmark-common but not :benchmark:benchmark-benchmark
+ // This is ok because we don't intend to publish that artifact from that build
+ val otherProjectShouldExist =
+ allProjectsExist || findProject(otherGradlePath) != null
+ if (!otherProjectShouldExist) {
+ continue
+ }
+ // We only emit constraints referring to projects that will release
+ val otherFilepath =
+ getSupportRootFolder().resolve(File(otherProject.filePath, "build.gradle"))
+ val parsed =
+ if (otherFilepath.exists()) {
+ parseBuildFile(otherFilepath)
+ } else {
+ parseBuildFile(
+ getSupportRootFolder()
+ .resolve(File(otherProject.filePath, "build.gradle.kts"))
+ )
+ }
+ if (!parsed.shouldRelease()) {
+ continue
+ }
+ if (parsed.softwareType == SoftwareType.SAMPLES) {
+ // a SAMPLES project knows how to publish, but we don't intend to actually
+ // publish it
+ continue
+ }
+ // Under certain circumstances, a project is allowed to override its
+ // version see ( isGroupVersionOverrideAllowed ), in which case it's
+ // not participating in the versioning policy yet and we don't emit
+ // version constraints referencing it
+ if (parsed.specifiesVersion) {
+ continue
+ }
+ val dependencyConstraint = project(otherGradlePath)
+ constraints.add(constraintConfiguration.name, dependencyConstraint) {
+ it.because("${project.name} is in atomic group ${projectGroup.group}")
+ }
+ }
+
+ // disallow duplicate constraints
+ project.configurations.configureEach { config ->
+ // Allow duplicate constraints in test configurations. This is partially a
+ // workaround for duplication due to downgrading strict-type dependencies to
+ // required-type, but also we don't care if tests have duplicate constraints.
+ if (config.isTest()) return@configureEach
+
+ // find all constraints contributed by this Configuration and its ancestors
+ val configurationConstraints: MutableSet = mutableSetOf()
+ config.hierarchy.forEach { parentConfig ->
+ parentConfig.dependencyConstraints.configureEach { dependencyConstraint ->
+ dependencyConstraint.apply {
+ if (
+ versionConstraint.requiredVersion != "" &&
+ versionConstraint.requiredVersion != "unspecified"
+ ) {
+ val key =
+ "${dependencyConstraint.group}:${dependencyConstraint.name}"
+ if (configurationConstraints.contains(key)) {
+ throw GradleException(
+ "Constraint on $key was added multiple times in " +
+ "$config (version = " +
+ "${versionConstraint.requiredVersion}).\n\n" +
+ "This is unnecessary and can also trigger " +
+ "https://github.com/gradle/gradle/issues/24037 in " +
+ "builds trying to use the resulting artifacts."
+ )
+ }
+ configurationConstraints.add(key)
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+
+ /**
+ * Tells whether this build contains the usual set of all projects (`./gradlew projects`)
+ * Sometimes developers request to include fewer projects because this may run more quickly
+ */
+ private fun Project.buildContainsAllStandardProjects(): Boolean {
+ if (getProjectSubset() != null) return false
+ if (ProjectLayoutType.isPlayground(this)) return false
+ return true
+ }
+
+ companion object {
+ const val FINALIZE_TEST_CONFIGS_WITH_APKS_TASK = "finalizeTestConfigsWithApks"
+ const val ZIP_TEST_CONFIGS_WITH_APKS_TASK = "zipTestConfigsWithApks"
+
+ const val TASK_GROUP_API = "API"
+
+ const val EXTENSION_NAME = "androidx"
+
+ // b/366238650
+ val SUPPORTED_BUILD_ABIS = listOf("armeabi-v7a", "arm64-v8a", "x86", "x86_64")
+
+ /** Fail the build if a non-Studio task runs longer than expected */
+ const val TASK_TIMEOUT_MINUTES = 60L
+ }
+}
+
+internal fun aospGetDefaultTargetJavaVersion(
+ softwareType: SoftwareType,
+ projectName: String? = null,
+ targetName: String? = null,
+): JavaVersion {
+ return when {
+ // TODO(b/353328300): Move room-compiler-processing to Java 17 once Dagger is ready.
+ projectName != null && projectName.contains("room3-compiler-processing") -> VERSION_11
+ projectName != null && projectName.contains("desktop") -> VERSION_11
+ targetName != null && (targetName == "desktop" || targetName == "jvmStubs") -> VERSION_11
+ softwareType.compilationTarget == CompilationTarget.HOST -> VERSION_17
+ else -> VERSION_1_8
+ }
+}
+
+private fun Project.validateLintVersionTestExists(androidXExtension: AndroidXExtension) {
+ if (!androidXExtension.type.get().isLint()) {
+ return
+ }
+ kotlinExtensionOrNull?.let { extension ->
+ val validateLintChecks =
+ tasks.register("validateLintChecks", ValidateLintChecks::class.java) { task ->
+ task.cacheEvenIfNoOutputs()
+ task.sourceDirectories.from(
+ extension.sourceSets.flatMap { it.kotlin.sourceDirectories }
+ )
+ }
+ addToBuildOnServer(validateLintChecks)
+ }
+}
+
+/** Returns whether the configuration is used for testing. */
+private fun Configuration.isTest(): Boolean = name.lowercase().contains("test")
+
+/** Returns whether the configuration is part of publication. */
+internal fun Configuration.isPublished(): Boolean =
+ !isTest() && !name.lowercase().contains("metadata") && !name.endsWith("CInterop")
+
+internal val Project.androidExtension: AndroidComponentsExtension<*, *, *>
+ get() =
+ extensions.findByType()
+ ?: throw IllegalArgumentException("Failed to find any registered Android extension")
+
+val Project.multiplatformExtension
+ get() = extensions.findByType(KotlinMultiplatformExtension::class.java)
+
+val Project.kotlinExtensionOrNull: KotlinProjectExtension?
+ get() = extensions.findByType()
+
+val Project.androidXExtension: AndroidXExtension
+ get() = extensions.getByType()
+
+/**
+ * Configures all non-Studio tasks in a project (see b/153193718 for background) to time out after
+ * [TASK_TIMEOUT_MINUTES].
+ */
+internal fun Project.configureTaskTimeouts() {
+ // A set of tasks that sometimes take >60 minutes. b/383874664
+ val slowTasks =
+ setOf(
+ ":compose:ui:ui:compileReleaseAndroidTestKotlinAndroid",
+ ":compose:foundation:foundation:compileReleaseAndroidTestKotlinAndroid",
+ ":compose:foundation:foundation:integration-tests:lazy-tests:compileReleaseAndroidTestKotlin",
+ )
+ tasks.configureEach { t ->
+ // skip adding a timeout for some tasks that both take a long time and
+ // that we can count on the user to monitor
+ if (t !is StudioTask) {
+ t.timeout.set(
+ Duration.ofMinutes(if (t.path in slowTasks) 80L else TASK_TIMEOUT_MINUTES)
+ )
+ }
+ }
+}
+
+private class JavaCompileArgumentProvider(
+ private val isTestApp: Boolean,
+ private val failOnDeprecationWarnings: Provider,
+ private val usingMaxDepVersions: Provider,
+) : CommandLineArgumentProvider {
+ override fun asArguments(): List {
+ // JDK 21 considers Java 8 an obsolete source and target value. Disable this warning.
+ val args = mutableListOf("-Xlint:-options")
+ // If we're running a hypothetical test build confirming that tip-of-tree versions
+ // are compatible, then we're not concerned about warnings
+ if (!usingMaxDepVersions.get() && !isTestApp) {
+ args.add("-Xlint:unchecked")
+ if (failOnDeprecationWarnings.get()) {
+ args.add("-Xlint:deprecation")
+ }
+ }
+ return args
+ }
+}
+
+private fun Project.configureJavaCompilationWarnings(
+ androidXExtension: AndroidXExtension,
+ isTestApp: Boolean = false,
+) {
+ project.tasks.withType(JavaCompile::class.java).configureEach { task ->
+ task.options.compilerArgumentProviders.add(
+ JavaCompileArgumentProvider(
+ isTestApp = isTestApp,
+ failOnDeprecationWarnings = androidXExtension.failOnDeprecationWarnings,
+ usingMaxDepVersions = usingMaxDepVersions(),
+ )
+ )
+ }
+}
+
+fun Project.hasBenchmarkPlugin(): Boolean {
+ return false
+}
+
+fun Project.isMacrobenchmark(): Boolean {
+ return this.path.endsWith("macrobenchmark")
+}
+
+/**
+ * Returns a string that is a valid filename and loosely based on the project name The value
+ * returned for each project will be distinct
+ */
+fun String.asFilenamePrefix(): String {
+ return this.substring(1).replace(':', '-')
+}
+
+/**
+ * Sets the specified [task] as a dependency of the top-level `check` task, ensuring that it runs as
+ * part of `./gradlew check`.
+ */
+fun Project.addToCheckTask(task: TaskProvider) {
+ project.tasks.named("check").configure { it.dependsOn(task) }
+}
+
+fun Project.validateMultiplatformPluginHasNotBeenApplied() {
+ if (plugins.hasPlugin(KotlinMultiplatformPluginWrapper::class.java)) {
+ throw GradleException(
+ "The Kotlin multiplatform plugin should only be applied by the AndroidX plugin."
+ )
+ }
+}
+
+/** Verifies that ProjectParser computes the correct values for this project */
+fun Project.validateProjectParser(androidXExtension: AndroidXExtension) {
+ if (isJetBrainsFork(project)) return
+ // If configuration fails, we don't want to validate the ProjectParser
+ // (otherwise it could report a confusing, unnecessary error)
+ project.gradle.taskGraph.whenReady {
+ val parsed = project.parse()
+ val errorPrefix = "ProjectParser error parsing ${project.path}."
+ check(androidXExtension.type.get() == parsed.softwareType) {
+ "$errorPrefix Incorrectly computed libraryType = ${parsed.softwareType} " +
+ "instead of ${androidXExtension.type.get()}"
+ }
+ check(androidXExtension.shouldPublish.get() == parsed.shouldPublish()) {
+ "$errorPrefix Incorrectly computed shouldPublish() = ${parsed.shouldPublish()} " +
+ "instead of ${androidXExtension.shouldPublish.get()}"
+ }
+ check(androidXExtension.shouldRelease.get() == parsed.shouldRelease()) {
+ "$errorPrefix Incorrectly computed shouldRelease() = ${parsed.shouldRelease()} " +
+ "instead of ${androidXExtension.shouldRelease.get()}"
+ }
+ check(androidXExtension.projectDirectlySpecifiesMavenVersion == parsed.specifiesVersion) {
+ "$errorPrefix Incorrectly computed specifiesVersion = ${parsed.specifiesVersion} " +
+ " instead of ${androidXExtension.projectDirectlySpecifiesMavenVersion}"
+ }
+ }
+}
+
+/** Validates the Maven version against Jetpack guidelines. */
+fun AndroidXExtension.validateMavenVersion() {
+ val mavenGroup = mavenGroup
+ val mavenVersion = mavenVersion
+ val forcedVersion = mavenGroup?.atomicGroupVersion
+ if (forcedVersion != null && forcedVersion == mavenVersion) {
+ throw GradleException(
+ """
+ Unnecessary override of same-group library version
+
+ Project version is already set to $forcedVersion by same-version group
+ ${mavenGroup.group}.
+
+ To fix this error, remove "mavenVersion = ..." from your build.gradle
+ configuration.
+ """
+ .trimIndent()
+ )
+ }
+}
+
+/** Workarounds for configuration resolution */
+fun Project.workaroundAndroidXDependencyResolutions() {
+ project.configurations.configureEach { configuration ->
+ // https://github.com/gradle/gradle/issues/27407
+ configuration.resolutionStrategy.preferProjectModules()
+
+ // https://github.com/gradle/gradle/issues/7594
+ configuration.resolutionStrategy.eachDependency { dependency ->
+ if (dependency.requested.group.startsWith("androidx.")) {
+ // Drop aar classifier that comes from aar in POM files
+ // as it causes a bug in Gradle. Gradle does not actually need the
+ // classifiers for Android libraries for them to work correctly.
+ dependency.artifactSelection { it.withoutArtifactSelectors() }
+ }
+ }
+ }
+}
+
+private fun Project.configureUnzipChromeBuildService() {
+ if (ProjectLayoutType.isPlayground(this)) {
+ return
+ }
+ gradle.sharedServices.registerIfAbsent("unzipChrome", UnzipChromeBuildService::class.java) {
+ it.parameters.browserDir.set(File(getPrebuiltsRoot(), "androidx/chrome-for-testing/"))
+ it.parameters.unzipToDir.set(getOutDirectory().resolve("chrome-bin"))
+ }
+}
+
+private fun Project.enforceBanOnVersionRanges() {
+ configurations.configureEach { configuration ->
+ configuration.resolutionStrategy.eachDependency { dep ->
+ val target = dep.target
+ val version = target.version
+ // Enforce the ban on declaring dependencies with version ranges.
+ // Note: In playground, this ban is exempted to allow unresolvable prebuilts
+ // to automatically get bumped to snapshot versions via version range
+ // substitution.
+ if (
+ version != null &&
+ Version.isDependencyRange(version) &&
+ project.rootProject.rootDir == project.getSupportRootFolder()
+ ) {
+ throw IllegalArgumentException(
+ "Dependency ${dep.target} declares its version as " +
+ "version range ${dep.target.version} however the use of " +
+ "version ranges is not allowed, please update the " +
+ "dependency to list a fixed version."
+ )
+ }
+ }
+ }
+}
+
+internal fun Project.hasAndroidMultiplatformPlugin(): Boolean =
+ extensions.findByType(AndroidXMultiplatformExtension::class.java)?.hasAndroidMultiplatform()
+ ?: false
+
+@Suppress("DEPRECATION")
+internal fun KotlinMultiplatformExtension.hasJavaEnabled(): Boolean =
+ targets.withType(KotlinJvmTarget::class.java).singleOrNull()?.withJavaEnabled ?: false
+
+internal fun KotlinMultiplatformExtension.hasJvmTarget(): Boolean =
+ targets.withType(KotlinJvmTarget::class.java).isEmpty().not()
+
+internal fun String.camelCase() = replaceFirstChar {
+ if (it.isLowerCase()) it.titlecase() else it.toString()
+}
diff --git a/buildSrc-fork/private/src/main/kotlin/androidx/build/AndroidXMultiplatformExtension.kt b/buildSrc-fork/private/src/main/kotlin/androidx/build/AndroidXMultiplatformExtension.kt
new file mode 100644
index 0000000000000..93252641162c1
--- /dev/null
+++ b/buildSrc-fork/private/src/main/kotlin/androidx/build/AndroidXMultiplatformExtension.kt
@@ -0,0 +1,1054 @@
+/*
+ * Copyright 2022 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package androidx.build
+
+import androidx.build.clang.AndroidXClang
+import androidx.build.clang.CombineObjectFilesTask
+import androidx.build.clang.KonanBuildService
+import androidx.build.clang.MultiTargetNativeCompilation
+import androidx.build.clang.NativeLibraryBundler
+import androidx.build.clang.configureCinterop
+import com.android.build.api.dsl.KotlinMultiplatformAndroidCompilation
+import com.android.build.api.dsl.KotlinMultiplatformAndroidLibraryTarget
+import com.android.build.gradle.api.KotlinMultiplatformAndroidPlugin
+import groovy.lang.Closure
+import java.io.File
+import javax.inject.Inject
+import org.gradle.api.Action
+import org.gradle.api.GradleException
+import org.gradle.api.NamedDomainObjectCollection
+import org.gradle.api.Project
+import org.gradle.api.artifacts.Configuration
+import org.gradle.api.configuration.BuildFeatures
+import org.gradle.api.plugins.ExtensionAware
+import org.gradle.api.tasks.PathSensitivity
+import org.gradle.api.tasks.testing.Test
+import org.gradle.kotlin.dsl.the
+import org.gradle.kotlin.dsl.withType
+import org.jetbrains.androidx.build.configureForkWebTarget
+import org.jetbrains.kotlin.gradle.ExperimentalKotlinGradlePluginApi
+import org.jetbrains.kotlin.gradle.ExperimentalWasmDsl
+import org.jetbrains.kotlin.gradle.dsl.KotlinMultiplatformExtension
+import org.jetbrains.kotlin.gradle.plugin.KotlinCompilation
+import org.jetbrains.kotlin.gradle.plugin.KotlinMultiplatformPluginWrapper
+import org.jetbrains.kotlin.gradle.plugin.KotlinPlatformType
+import org.jetbrains.kotlin.gradle.plugin.KotlinTarget
+import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinNativeCompilation
+import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinNativeTarget
+import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinNativeTargetWithHostTests
+import org.jetbrains.kotlin.gradle.targets.js.dsl.KotlinJsTargetDsl
+import org.jetbrains.kotlin.gradle.targets.js.dsl.KotlinWasmTargetDsl
+import org.jetbrains.kotlin.gradle.targets.js.ir.DefaultIncrementalSyncTask
+import org.jetbrains.kotlin.gradle.targets.js.nodejs.NodeJsEnvSpec
+import org.jetbrains.kotlin.gradle.targets.js.nodejs.NodeJsPlugin
+import org.jetbrains.kotlin.gradle.targets.js.testing.KotlinJsTest
+import org.jetbrains.kotlin.gradle.targets.js.yarn.YarnLockMismatchReport
+import org.jetbrains.kotlin.gradle.targets.js.yarn.YarnPlugin
+import org.jetbrains.kotlin.gradle.targets.js.yarn.YarnRootEnvSpec
+import org.jetbrains.kotlin.gradle.targets.jvm.KotlinJvmTarget
+import org.jetbrains.kotlin.gradle.targets.wasm.binaryen.BinaryenEnvSpec
+import org.jetbrains.kotlin.gradle.targets.wasm.binaryen.BinaryenPlugin
+import org.jetbrains.kotlin.gradle.targets.wasm.nodejs.WasmNodeJsEnvSpec
+import org.jetbrains.kotlin.gradle.targets.wasm.nodejs.WasmNodeJsPlugin
+import org.jetbrains.kotlin.gradle.targets.wasm.yarn.WasmYarnPlugin
+import org.jetbrains.kotlin.gradle.targets.wasm.yarn.WasmYarnRootEnvSpec
+import org.jetbrains.kotlin.gradle.tasks.Kotlin2JsCompile
+import org.jetbrains.kotlin.konan.target.LinkerOutputKind
+
+/**
+ * [AndroidXMultiplatformExtension] is an extension that wraps specific functionality of the Kotlin
+ * multiplatform extension, and applies the Kotlin multiplatform plugin when it is used. The purpose
+ * of wrapping is to prevent targets from being added when the platform has not been enabled. e.g.
+ * the `macosX64` target is gated on a `project.enableMac` check.
+ */
+abstract class AndroidXMultiplatformExtension(val project: Project) {
+
+ @get:Inject abstract val buildFeatures: BuildFeatures
+
+ var enableBinaryCompatibilityValidator = true
+
+ /*
+ * Adds a kotlin stdlib klib directory as an input to test tasks.
+ * This is specifically useful for BCV, but it needs to be set up by our buildSrc code to
+ * make sure we use the correct installation and don't accidentally cause something to be
+ * downloaded from the internet.
+ *
+ * Sets the `kotlin.stdlib.klib.dir` property which can be accessed inside the tests
+ */
+ fun provideKlibStdLibForTests() {
+ val konanBuildService = KonanBuildService.obtain(project)
+ // directory format of stdlib klib for use during tests
+ val stdLibKlibDir =
+ konanBuildService.map { it.parameters.konanHome.dir("klib/common/stdlib") }
+ project.tasks.withType(Test::class.java).configureEach { task ->
+ task.inputs
+ .dir(stdLibKlibDir)
+ .withPropertyName("kotlinStdLib")
+ .withPathSensitivity(PathSensitivity.RELATIVE)
+ task.doFirst {
+ task.systemProperty(
+ "kotlin.stdlib.klib.dir",
+ stdLibKlibDir.get().get().asFile.absolutePath,
+ )
+ }
+ }
+ }
+
+ // Kotlin multiplatform plugin is only applied if at least one target / sourceset is added.
+ private val kotlinExtensionDelegate = lazy {
+ project.validateMultiplatformPluginHasNotBeenApplied()
+ project.plugins.apply(KotlinMultiplatformPluginWrapper::class.java)
+ project.multiplatformExtension!!.also { it.applyAndroidXDefaultHierarchyTemplate() }
+ }
+ private val kotlinExtension: KotlinMultiplatformExtension by kotlinExtensionDelegate
+ private val agpKmpExtensionDelegate = lazy {
+ // make sure to initialize the kotlin extension by accessing the property
+ val extension = (kotlinExtension as ExtensionAware)
+ project.plugins.apply(KotlinMultiplatformAndroidPlugin::class.java)
+ extension.extensions.getByType(KotlinMultiplatformAndroidLibraryTarget::class.java)
+ }
+
+ val agpKmpExtension: KotlinMultiplatformAndroidLibraryTarget by agpKmpExtensionDelegate
+
+ /**
+ * The list of platforms that have been declared as supported in the build configuration.
+ *
+ * This may be a superset of the currently enabled platforms in [targetPlatforms].
+ */
+ val supportedPlatforms: MutableSet = mutableSetOf()
+
+ /**
+ * Artifact-redirection (parallel-graph back-end): one entry per concrete target declared inside a
+ * `redirect { }` block. Each entry names a target that the fork builds *empty* (an empty,
+ * but valid, klib/jar/aar depending on the `androidx.*` coordinate) by re-rooting its
+ * source-sets onto an empty parallel graph (`redirectCommonMain`) instead of the real
+ * `commonMain`. The JetBrains plugin reads this registry in `afterEvaluate`.
+ *
+ * `redirectCoordinate` carries the `androidx.*` group from the `redirect("group") { }` argument
+ * (required) and the optional version override; when its version is null the back-end resolves it
+ * from the `[versions]` table of `redirectversions.toml`.
+ */
+ internal data class RedirectTargetDecl(
+ val targetName: String,
+ val redirectCoordinate: RedirectCoordinate
+ )
+
+ /** Targets registered for redirect via `redirect { }`. Consumed by the JetBrains plugin. */
+ internal val redirectTargetDecls: MutableList = mutableListOf()
+
+ /**
+ * Names of redirect targets, registered **before** the target is created (see `expectRedirect`).
+ * The hierarchy-template `excludeCompilations` predicate reads this to keep redirect targets out
+ * of the `commonMain` tree. Must be populated before the target's compilation is created, because
+ * the template evaluates the predicate at compilation-creation time.
+ */
+ internal val redirectTargetNames: MutableSet = mutableSetOf()
+
+ /** Pre-register expected redirect target names so the hierarchy predicate excludes them. */
+ private fun expectRedirect(vararg names: String) { redirectTargetNames += names }
+
+ /** The `androidx.*` coordinate a `redirect("group", version) { }` block points its targets at. */
+ internal data class RedirectCoordinate(val group: String, val version: String?)
+
+ // Ambient state for the `redirect { … }` scope: non-null while a redirect block is executing
+ // (holding that block's coordinate), null otherwise. A plain target function called inside the
+ // block sees it (via `potentiallyRedirecting`) and redirects its target to the coordinate instead
+ // of fork-building.
+ private var redirectCoordinate: RedirectCoordinate? = null
+
+ /**
+ * Empty parallel root for redirect targets. Created lazily on the first redirect target (declared
+ * inside `redirect { }`) so that redirect leaves can be wired to it **at target-creation time** —
+ * this is what keeps them off the real `commonMain`. KGP applies the default hierarchy template
+ * only when a source-set
+ * has no manual `dependsOn` edge; adding one here (synchronously, during configuration) opts the
+ * redirect leaf out of the auto-wiring to `commonMain`. Doing this in `afterEvaluate` is too late
+ * (the dependsOn closure is computed reactively on edge add and is not recomputed on removal).
+ */
+ private val redirectCommonMain: org.jetbrains.kotlin.gradle.plugin.KotlinSourceSet by lazy {
+ kotlinExtension.sourceSets.maybeCreate("redirectCommonMain")
+ }
+
+ private fun recordRedirect(target: KotlinTarget, targetName: String, redirectCoordinate: RedirectCoordinate) {
+ // Invariant: the name `potentiallyRedirecting` pre-registered must match the created target,
+ // otherwise the hierarchy predicate excluded the wrong name from `commonMain`.
+ assert(target.name == targetName) {
+ "redirect target name mismatch: expected '$targetName' but created target is '${target.name}'"
+ }
+ redirectTargetNames += target.name
+ redirectTargetDecls += RedirectTargetDecl(target.name, redirectCoordinate)
+ // Wire the target's main compilation source-set to the parallel root up-front.
+ target.compilations.findByName("main")?.defaultSourceSet?.dependsOn(redirectCommonMain)
+ }
+
+ /**
+ * The list of platforms that are currently enabled.
+ *
+ * This will vary across build environments. For example, a project's build configuration may
+ * have requested `mac()` but this is not available when building on Linux.
+ */
+ val targetPlatforms: List
+ get() =
+ if (kotlinExtensionDelegate.isInitialized()) {
+ kotlinExtension.targets.mapNotNull {
+ if (it.targetName != "metadata") {
+ it.targetName
+ } else {
+ null
+ }
+ }
+ } else {
+ throw GradleException("Kotlin multi-platform extension has not been initialized")
+ }
+
+ /**
+ * Default platform identifier used for specifying POM dependencies.
+ *
+ * This platform will be added as a dependency to the multi-platform anchor artifact's POM
+ * publication. For example, if the anchor artifact is `collection` and the default platform is
+ * `jvm`, then the POM for `collection` will express a dependency on `collection-jvm`. This
+ * ensures that developers who are silently upgrade to KMP artifacts but are not using Gradle
+ * still see working artifacts.
+ *
+ * If no default was specified and a single platform is requested (ex. using [jvm]), returns the
+ * identifier for that platform.
+ */
+ var defaultPlatform: String? = null
+ get() = field ?: supportedPlatforms.singleOrNull()?.id
+ set(value) {
+ if (value != null) {
+ if (supportedPlatforms.none { it.id == value }) {
+ throw GradleException(
+ "Platform $value has not been requested as a target. " +
+ "Available platforms are: " +
+ supportedPlatforms.joinToString(", ") { it.id }
+ )
+ }
+ if (targetPlatforms.none { it == value }) {
+ throw GradleException(
+ "Platform $value is not available in this build " +
+ "environment. Available platforms are: " +
+ targetPlatforms.joinToString(", ")
+ )
+ }
+ }
+ field = value
+ }
+
+ val targets: NamedDomainObjectCollection
+ get() = kotlinExtension.targets
+
+ /** Helper class to access Clang functionality. */
+ private val clang = AndroidXClang(project)
+
+ /** Helper class to bundle outputs of clang compilation into an AAR / JAR. */
+ private val nativeLibraryBundler = NativeLibraryBundler(project)
+
+ internal fun hasNativeTarget(): Boolean {
+ // it is important to check initialized here not to trigger initialization
+ return kotlinExtensionDelegate.isInitialized() &&
+ targets.any { it.platformType == KotlinPlatformType.native }
+ }
+
+ internal fun hasAndroidMultiplatform(): Boolean {
+ return agpKmpExtensionDelegate.isInitialized()
+ }
+
+ fun sourceSets(closure: Closure<*>) {
+ if (kotlinExtensionDelegate.isInitialized()) {
+ kotlinExtension.sourceSets.configure(closure).also {
+ kotlinExtension.sourceSets.configureEach { sourceSet ->
+ if (sourceSet.name == "main" || sourceSet.name == "test") {
+ throw Exception(
+ "KMP-enabled projects must use target-prefixed " +
+ "source sets, e.g. androidMain or commonTest, rather than main or test"
+ )
+ }
+ }
+ }
+ }
+ }
+
+ /**
+ * Creates a multi-target native compilation with the given [archiveName].
+ *
+ * The given [configure] action can be used to add targets, sources, includes etc.
+ *
+ * The outputs of this compilation is not added to any artifact by default.
+ * * To use the outputs via cinterop (kotlin native), use the [createCinterop] function.
+ * * To bundle the outputs inside a JAR (to be loaded at runtime), use the
+ * [addNativeLibrariesToResources] function.
+ * * To bundle the outputs inside an AAR (to be loaded at runtime), use the
+ * [addNativeLibrariesToJniLibs] function.
+ *
+ * @param archiveName The archive file name for the native artifacts (.so, .a or .o)
+ * @param outputKind The kind of output it should be produced (library or executable).
+ * @param configure Action block to configure the compilation.
+ */
+ @JvmOverloads
+ fun createNativeCompilation(
+ archiveName: String,
+ outputKind: LinkerOutputKind = LinkerOutputKind.DYNAMIC_LIBRARY,
+ configure: Action,
+ ): MultiTargetNativeCompilation {
+ return clang.createNativeCompilation(
+ archiveName = archiveName,
+ configure = configure,
+ outputKind = outputKind,
+ )
+ }
+
+ /**
+ * Creates a Kotlin Native cinterop configuration for the given [nativeTarget] main compilation
+ * from the outputs of [nativeCompilation].
+ *
+ * @param nativeTarget The kotlin native target for which a new cinterop will be added on the
+ * main compilation.
+ * @param nativeCompilation The [MultiTargetNativeCompilation] which will be embedded into the
+ * generated cinterop klib.
+ * @param cinteropName The name of the cinterop definition. A matching "" file
+ * needs to be present in the default cinterop location
+ * (src/nativeInterop/cinterop/).
+ */
+ @JvmOverloads
+ fun createCinterop(
+ nativeTarget: KotlinNativeTarget,
+ nativeCompilation: MultiTargetNativeCompilation,
+ cinteropName: String = nativeCompilation.archiveName,
+ ) {
+ createCinterop(
+ kotlinNativeCompilation =
+ nativeTarget.compilations.getByName(KotlinCompilation.MAIN_COMPILATION_NAME)
+ as KotlinNativeCompilation,
+ nativeCompilation = nativeCompilation,
+ cinteropName = cinteropName,
+ )
+ }
+
+ /**
+ * Creates a Kotlin Native cinterop configuration for the given [kotlinNativeCompilation] from
+ * the outputs of [nativeCompilation].
+ *
+ * @param kotlinNativeCompilation The kotlin native compilation for which a new cinterop will be
+ * added
+ * @param nativeCompilation The [MultiTargetNativeCompilation] which will be embedded into the
+ * generated cinterop klib.
+ * @param cinteropName The name of the cinterop definition. A matching "" file
+ * needs to be present in the default cinterop location
+ * (src/nativeInterop/cinterop/).
+ */
+ @JvmOverloads
+ fun createCinterop(
+ kotlinNativeCompilation: KotlinNativeCompilation,
+ nativeCompilation: MultiTargetNativeCompilation,
+ cinteropName: String = nativeCompilation.archiveName,
+ ) {
+ nativeCompilation.configureCinterop(
+ kotlinNativeCompilation = kotlinNativeCompilation,
+ cinteropName = cinteropName,
+ )
+ }
+
+ /**
+ * Creates a Kotlin Native cinterop configuration for the given [kotlinNativeCompilation] from
+ * the single output of a configuration.
+ *
+ * @param kotlinNativeCompilation The kotlin native compilation for which a new cinterop will be
+ * added
+ * @param configuration The configuration to resolve. It is expected for the configuration to
+ * contain a single file of the archive file to be referenced in the C interop definition
+ * file.
+ */
+ fun createCinteropFromArchiveConfiguration(
+ kotlinNativeCompilation: KotlinNativeCompilation,
+ configuration: Configuration,
+ ) {
+ configureCinterop(project, kotlinNativeCompilation, configuration)
+ }
+
+ /**
+ * Adds the native outputs from [nativeCompilation] to the assets of the [androidTarget].
+ *
+ * @see CombineObjectFilesTask for details.
+ */
+ @JvmOverloads
+ fun addNativeLibrariesToVariantAssets(
+ androidTarget: KotlinMultiplatformAndroidLibraryTarget,
+ nativeCompilation: MultiTargetNativeCompilation,
+ forTest: Boolean = false,
+ ) =
+ nativeLibraryBundler.addNativeLibrariesToAndroidVariantSources(
+ androidTarget = androidTarget,
+ nativeCompilation = nativeCompilation,
+ forTest = forTest,
+ provideSourceDirectories = { assets },
+ )
+
+ /**
+ * Adds the native outputs from [nativeCompilation] to the jni libs dependency of the
+ * [androidTarget].
+ *
+ * @see CombineObjectFilesTask for details.
+ */
+ @JvmOverloads
+ fun addNativeLibrariesToJniLibs(
+ androidTarget: KotlinMultiplatformAndroidLibraryTarget,
+ nativeCompilation: MultiTargetNativeCompilation,
+ forTest: Boolean = false,
+ ) =
+ nativeLibraryBundler.addNativeLibrariesToAndroidVariantSources(
+ androidTarget = androidTarget,
+ nativeCompilation = nativeCompilation,
+ forTest = forTest,
+ provideSourceDirectories = { jniLibs },
+ )
+
+ /**
+ * Convenience method to add bundle native libraries with a test jar.
+ *
+ * @see addNativeLibrariesToResources
+ */
+ fun addNativeLibrariesToTestResources(
+ jvmTarget: KotlinJvmTarget,
+ nativeCompilation: MultiTargetNativeCompilation,
+ ) =
+ addNativeLibrariesToResources(
+ jvmTarget = jvmTarget,
+ nativeCompilation = nativeCompilation,
+ compilationName = KotlinCompilation.TEST_COMPILATION_NAME,
+ )
+
+ /** @see NativeLibraryBundler.addNativeLibrariesToResources */
+ @JvmOverloads
+ fun addNativeLibrariesToResources(
+ jvmTarget: KotlinJvmTarget,
+ nativeCompilation: MultiTargetNativeCompilation,
+ compilationName: String = KotlinCompilation.MAIN_COMPILATION_NAME,
+ ) =
+ nativeLibraryBundler.addNativeLibrariesToResources(
+ jvmTarget = jvmTarget,
+ nativeCompilation = nativeCompilation,
+ compilationName = compilationName,
+ )
+
+ /**
+ * Sets the default target platform.
+ *
+ * The default target platform *must* be enabled in all build environments. For projects which
+ * request multiple target platforms, this method *must* be called to explicitly specify a
+ * default target platform.
+ *
+ * See [defaultPlatform] for details on how the value is used.
+ */
+ fun defaultPlatform(value: PlatformIdentifier) {
+ defaultPlatform = value.id
+ }
+
+ @JvmOverloads
+ fun jvm(block: Action? = null): KotlinJvmTarget? = potentiallyRedirecting("jvm") {
+ supportedPlatforms.add(PlatformIdentifier.JVM)
+ if (project.enableJvm()) {
+ kotlinExtension.jvm { block?.execute(this) }
+ } else {
+ null
+ }
+ }
+
+ @JvmOverloads
+ fun jvmStubs(
+ runTests: Boolean = false,
+ block: Action? = null,
+ ): KotlinJvmTarget? {
+ supportedPlatforms.add(PlatformIdentifier.JVM_STUBS)
+ return if (project.enableJvm()) {
+ kotlinExtension.jvm("jvmStubs") {
+ block?.execute(this)
+ project.tasks.named("jvmStubsTest").configure {
+ // don't try running common tests for stubs target if disabled
+ it.enabled = runTests
+ }
+ }
+ } else {
+ null
+ }
+ }
+
+ @JvmOverloads
+ fun androidNative(block: Action? = null): List {
+ return listOfNotNull(
+ androidNativeX86(block),
+ androidNativeX64(block),
+ androidNativeArm64(block),
+ androidNativeArm32(block),
+ )
+ }
+
+ @JvmOverloads
+ fun androidNativeX86(block: Action? = null): KotlinNativeTarget? =
+ potentiallyRedirecting("androidNativeX86") {
+ supportedPlatforms.add(PlatformIdentifier.ANDROID_NATIVE_X86)
+ if (project.enableAndroidNative()) {
+ kotlinExtension.androidNativeX86 { block?.execute(this) }
+ } else {
+ null
+ }
+ }
+
+ @JvmOverloads
+ fun androidNativeX64(block: Action? = null): KotlinNativeTarget? =
+ potentiallyRedirecting("androidNativeX64") {
+ supportedPlatforms.add(PlatformIdentifier.ANDROID_NATIVE_X64)
+ if (project.enableAndroidNative()) {
+ kotlinExtension.androidNativeX64 { block?.execute(this) }
+ } else {
+ null
+ }
+ }
+
+ @JvmOverloads
+ fun androidNativeArm64(block: Action? = null): KotlinNativeTarget? =
+ potentiallyRedirecting("androidNativeArm64") {
+ supportedPlatforms.add(PlatformIdentifier.ANDROID_NATIVE_ARM64)
+ if (project.enableAndroidNative()) {
+ kotlinExtension.androidNativeArm64 { block?.execute(this) }
+ } else {
+ null
+ }
+ }
+
+ @JvmOverloads
+ fun androidNativeArm32(block: Action? = null): KotlinNativeTarget? =
+ potentiallyRedirecting("androidNativeArm32") {
+ supportedPlatforms.add(PlatformIdentifier.ANDROID_NATIVE_ARM32)
+ if (project.enableAndroidNative()) {
+ kotlinExtension.androidNativeArm32 { block?.execute(this) }
+ } else {
+ null
+ }
+ }
+
+ @JvmOverloads
+ fun androidLibrary(
+ block: Action? = null
+ ): KotlinMultiplatformAndroidLibraryTarget? = potentiallyRedirecting("android") {
+ supportedPlatforms.add(PlatformIdentifier.ANDROID)
+ if (project.enableJvm()) {
+ agpKmpExtension.also { block?.execute(it) }
+ } else {
+ null
+ }
+ }
+
+ @JvmOverloads
+ fun desktop(block: Action? = null): KotlinJvmTarget? =
+ potentiallyRedirecting("desktop") {
+ supportedPlatforms.add(PlatformIdentifier.DESKTOP)
+ if (project.enableDesktop()) {
+ kotlinExtension.jvm("desktop") { block?.execute(this) }
+ } else {
+ null
+ }
+ }
+
+ @JvmOverloads
+ fun mingwX64(block: Action? = null): KotlinNativeTargetWithHostTests? =
+ potentiallyRedirecting("mingwX64") {
+ supportedPlatforms.add(PlatformIdentifier.MINGW_X_64)
+ if (project.enableWindows()) {
+ kotlinExtension.mingwX64 { block?.execute(this) }
+ } else {
+ null
+ }
+ }
+
+ /** Configures all mac targets supported by AndroidX. */
+ @JvmOverloads
+ fun mac(block: Action? = null): List {
+ return listOfNotNull(macosArm64(block))
+ }
+
+ @JvmOverloads
+ fun macosArm64(block: Action? = null): KotlinNativeTargetWithHostTests? =
+ potentiallyRedirecting("macosArm64") {
+ supportedPlatforms.add(PlatformIdentifier.MAC_ARM_64)
+ if (project.enableMac()) {
+ kotlinExtension.macosArm64 { block?.execute(this) }
+ } else {
+ null
+ }
+ }
+
+ /** Configures all ios targets supported by AndroidX. */
+ @JvmOverloads
+ fun ios(block: Action? = null): List {
+ return listOfNotNull(iosArm64(block), iosSimulatorArm64(block))
+ }
+
+ @JvmOverloads
+ fun iosArm64(block: Action? = null): KotlinNativeTarget? =
+ potentiallyRedirecting("iosArm64") {
+ supportedPlatforms.add(PlatformIdentifier.IOS_ARM_64)
+ if (project.enableMac()) {
+ kotlinExtension.iosArm64 { block?.execute(this) }
+ } else {
+ null
+ }
+ }
+
+ @JvmOverloads
+ fun iosSimulatorArm64(block: Action? = null): KotlinNativeTarget? =
+ potentiallyRedirecting("iosSimulatorArm64") {
+ supportedPlatforms.add(PlatformIdentifier.IOS_SIMULATOR_ARM_64)
+ if (project.enableMac()) {
+ kotlinExtension.iosSimulatorArm64 { block?.execute(this) }
+ } else {
+ null
+ }
+ }
+
+ /** Configures all watchos targets supported by AndroidX. */
+ @JvmOverloads
+ fun watchos(block: Action? = null): List {
+ return listOfNotNull(
+ watchosArm32(block),
+ watchosArm64(block),
+ // TODO(https://youtrack.jetbrains.com/issue/CMP-9513) publish it
+ // watchosDeviceArm64()
+ watchosSimulatorArm64(block),
+ )
+ }
+
+ @JvmOverloads
+ fun watchosArm32(block: Action? = null): KotlinNativeTarget? =
+ potentiallyRedirecting("watchosArm32") {
+ supportedPlatforms.add(PlatformIdentifier.WATCHOS_ARM_32)
+ if (project.enableMac()) {
+ kotlinExtension.watchosArm32 { block?.execute(this) }
+ } else {
+ null
+ }
+ }
+
+ @JvmOverloads
+ fun watchosArm64(block: Action? = null): KotlinNativeTarget? =
+ potentiallyRedirecting("watchosArm64") {
+ supportedPlatforms.add(PlatformIdentifier.WATCHOS_ARM_64)
+ if (project.enableMac()) {
+ kotlinExtension.watchosArm64 { block?.execute(this) }
+ } else {
+ null
+ }
+ }
+
+ @JvmOverloads
+ fun watchosDeviceArm64(block: Action? = null): KotlinNativeTarget? =
+ potentiallyRedirecting("watchosDeviceArm64") {
+ supportedPlatforms.add(PlatformIdentifier.WATCHOS_DEVICE_ARM_64)
+ if (project.enableMac()) {
+ kotlinExtension.watchosDeviceArm64 { block?.execute(this) }
+ } else {
+ null
+ }
+ }
+
+ @JvmOverloads
+ fun watchosSimulatorArm64(block: Action? = null): KotlinNativeTarget? =
+ potentiallyRedirecting("watchosSimulatorArm64") {
+ supportedPlatforms.add(PlatformIdentifier.WATCHOS_SIMULATOR_ARM_64)
+ if (project.enableMac()) {
+ kotlinExtension.watchosSimulatorArm64 { block?.execute(this) }
+ } else {
+ null
+ }
+ }
+
+ /** Configures all tvos targets supported by AndroidX. */
+ @JvmOverloads
+ fun tvos(block: Action? = null): List {
+ return listOfNotNull(tvosArm64(block), tvosSimulatorArm64(block))
+ }
+
+ @JvmOverloads
+ fun tvosArm64(block: Action? = null): KotlinNativeTarget? =
+ potentiallyRedirecting("tvosArm64") {
+ supportedPlatforms.add(PlatformIdentifier.TVOS_ARM_64)
+ if (project.enableMac()) {
+ kotlinExtension.tvosArm64 { block?.execute(this) }
+ } else {
+ null
+ }
+ }
+
+ @JvmOverloads
+ fun tvosSimulatorArm64(block: Action? = null): KotlinNativeTarget? =
+ potentiallyRedirecting("tvosSimulatorArm64") {
+ supportedPlatforms.add(PlatformIdentifier.TVOS_SIMULATOR_ARM_64)
+ if (project.enableMac()) {
+ kotlinExtension.tvosSimulatorArm64 { block?.execute(this) }
+ } else {
+ null
+ }
+ }
+
+ @JvmOverloads
+ fun linux(block: Action? = null): List {
+ return listOfNotNull(linuxArm64(block), linuxX64(block))
+ }
+
+ @JvmOverloads
+ fun linuxArm64(block: Action? = null): KotlinNativeTarget? =
+ potentiallyRedirecting("linuxArm64") {
+ supportedPlatforms.add(PlatformIdentifier.LINUX_ARM_64)
+ if (project.enableLinux()) {
+ kotlinExtension.linuxArm64 { block?.execute(this) }
+ } else {
+ null
+ }
+ }
+
+ @JvmOverloads
+ fun linuxX64(block: Action? = null): KotlinNativeTarget? =
+ potentiallyRedirecting("linuxX64") {
+ supportedPlatforms.add(PlatformIdentifier.LINUX_X_64)
+ if (project.enableLinux()) {
+ kotlinExtension.linuxX64 { block?.execute(this) }
+ } else {
+ null
+ }
+ }
+
+ @JvmOverloads
+ fun linuxX64Stubs(block: Action? = null): KotlinNativeTarget? {
+ supportedPlatforms.add(PlatformIdentifier.LINUX_X_64_STUBS)
+ return if (project.enableLinux()) {
+ kotlinExtension.linuxX64("linuxx64Stubs") {
+ block?.execute(this)
+ project.tasks.named("linuxx64StubsTest").configure {
+ // don't try running common tests for stubs target
+ it.enabled = false
+ }
+ }
+ } else {
+ null
+ }
+ }
+
+ @JvmOverloads
+ fun js(block: Action? = null): KotlinJsTargetDsl? =
+ potentiallyRedirecting("js") {
+ configureForkWebTarget(
+ platform = PlatformIdentifier.JS,
+ isEnabled = project.enableJs(),
+ createTarget = { configure -> kotlinExtension.js(configure) },
+ block = block,
+ )
+ }
+
+ @OptIn(ExperimentalWasmDsl::class)
+ @JvmOverloads
+ fun wasmJs(block: Action? = null): KotlinWasmTargetDsl? =
+ potentiallyRedirecting("wasmJs") {
+ configureForkWebTarget(
+ platform = PlatformIdentifier.WASM_JS,
+ isEnabled = project.enableWasmJs(),
+ createTarget = { configure -> kotlinExtension.wasmJs(configure) },
+ block = block,
+ )
+ }
+
+ // --- Artifact redirection (parallel-graph back-end): see `redirect { }` below. --------------
+
+ /**
+ * Redirect scope: inside `redirect("androidx.foo") { … }` the plain target functions
+ * (`androidLibrary {}`, `ios()`, `jvm()`, …) build their target **empty** and redirect it to the
+ * `androidx.*` artifact instead of compiling the real `commonMain` — the parallel-graph back-end
+ * publishes an empty klib/jar/aar that depends on the androidx coordinate. Mix freely with plain
+ * (fork-built) targets declared outside the block for partial redirects (e.g.
+ * `redirect("androidx.foo") { androidLibrary {} }` then plain `desktop(); ios()`).
+ *
+ * [group] is the target `androidx.*` group and is **required** — every redirect declares it
+ * explicitly (no property fallback, no derivation). [version] is optional: omit it to resolve
+ * from the `[versions]` table of `redirectversions.toml`; one redirect coordinate per module.
+ *
+ * The receiver is the decorated `androidXMultiplatform` extension itself (no separate scope
+ * object), so the target list is not duplicated and Groovy nested config closures (e.g.
+ * `androidLibrary { namespace = … }`) delegate to their target as usual.
+ */
+ fun redirect(group: String, block: Action) =
+ redirect(group, null, block)
+
+ fun redirect(group: String, version: String?, block: Action) {
+ val prevRedirectScope = redirectCoordinate
+ redirectCoordinate = RedirectCoordinate(group, version)
+ try {
+ block.execute(this)
+ } finally {
+ redirectCoordinate = prevRedirectScope
+ }
+ }
+
+ /**
+ * Wraps a plain target function's creation. When called inside [redirect] { } the target's name
+ * is registered **before** the target (and its compilations) are created — so the
+ * default-hierarchy `excludeCompilations` predicate keeps the redirect leaf off the real
+ * `commonMain` — and the created target is recorded so the back-end re-roots it onto the empty
+ * `redirectCommonMain`. A no-op outside a redirect scope: the target is fork-built as usual.
+ *
+ * Every leaf target function (`jvm`, `androidLibrary`, `iosArm64`, …) routes its body through
+ * this helper, so any of them redirects automatically when invoked inside `redirect { }` —
+ * directly or via an aggregate like `ios()`/`mac()` that fans out to the leaves.
+ */
+ private fun potentiallyRedirecting(targetName: String, create: () -> T): T {
+ val redirectScope = redirectCoordinate ?: return create()
+ expectRedirect(targetName)
+ return create().also {
+ (it as? KotlinTarget)?.let { target ->
+ recordRedirect(target, targetName, redirectScope)
+ }
+ }
+ }
+
+ @OptIn(ExperimentalKotlinGradlePluginApi::class)
+ private fun KotlinMultiplatformExtension.applyAndroidXDefaultHierarchyTemplate() =
+ applyDefaultHierarchyTemplate {
+ common {
+ // Artifact redirection: keep redirect targets (declared inside `redirect { }`) OUT of
+ // the common hierarchy entirely, so the template never wires them to `commonMain`. Their
+ // leaf source-sets are instead wired to the empty `redirectCommonMain` at
+ // target-creation time (see recordRedirect). This predicate is evaluated lazily per
+ // compilation, so the redirect set — populated by `potentiallyRedirecting` before the
+ // target is created — is already visible here. No-op for modules that declare no redirects.
+ excludeCompilations { it.target.name in redirectTargetNames }
+ group("jvmAndAndroid") {
+ // TODO(b/442950553): Switch to withAndroidTarget when bug is fixed
+ withCompilations { it is KotlinMultiplatformAndroidCompilation }
+ withJvm()
+ }
+ group("nonJvm") {
+ withNative()
+ group("web") {
+ withWasmJs()
+ withJs()
+ }
+ }
+ }
+ }
+
+ private fun Project.configureWebTarget(
+ platform: PlatformIdentifier,
+ isEnabled: Boolean,
+ createTarget: (KotlinJsTargetDsl.() -> Unit) -> T,
+ block: Action? = null,
+ ): T? {
+ if (buildFeatures.isIsolatedProjectsEnabled()) return null
+ supportedPlatforms.add(platform)
+ return if (isEnabled) {
+ createTarget {
+ block?.execute(this)
+ binaries.library()
+ browser {
+ testTask {
+ it.useKarma {
+ useChromeHeadless()
+ useConfigDirectory(File(getSupportRootFolder(), "buildSrc/karmaconfig"))
+ }
+ }
+ }
+ // Do not place the config functions below before the browser DSL as the
+ // settings will be overridden
+ configureBinaryen()
+ configureDefaultIncrementalSyncTask()
+ configureKotlinJsTests()
+ configureNode()
+
+ // For KotlinWasm/Js, versions of toolchain and stdlib need to be the same:
+ // https://youtrack.jetbrains.com/issue/KT-71032
+ configurePinnedKotlinLibraries(platform)
+ }
+ } else null
+ }
+
+ /** Locates a project by path. */
+ // This method is needed for Gradle project isolation to avoid calls to parent projects due to
+ // androidx { samples(project(":foo")) }
+ // Without this method, the call above results into a call to the parent object, because
+ // AndroidXExtension has `val project: Project`, which from groovy `project` call within
+ // `androidx` block tries retrieves that project object and calls to look for :foo property
+ // on it, then checking all the parents for it.
+ fun project(name: String): Project = project.project(name)
+
+ companion object {
+ const val EXTENSION_NAME = "androidXMultiplatform"
+ }
+
+ // FORK-only public extensions
+
+ /**
+ * Configures native compilation tasks with flags to link required frameworks
+ */
+ fun configureDarwinFlags() = org.jetbrains.androidx.build.configureDarwinFlags(project)
+
+ /**
+ * Configure instrumented tests to run on an actual iOS simulator.
+ */
+ fun iosInstrumentedTest() = org.jetbrains.androidx.build.addIosInstrumentedTestSourceset(project)
+}
+
+// TODO(https://youtrack.jetbrains.com/issue/KT-76874/):
+// Remove this function when the default destinationDirectory is different for each task
+private fun Project.configureDefaultIncrementalSyncTask() {
+ val destinationPaths =
+ mapOf(
+ "jsDevelopmentLibraryCompileSync" to "js/packages/js/dev/kotlin",
+ "jsProductionLibraryCompileSync" to "js/packages/js/prod/kotlin",
+ "jsTestTestDevelopmentExecutableCompileSync" to "js/packages/js-test/dev/kotlin",
+ "jsTestTestProductionExecutableCompileSync" to "js/packages/js-test/prod/kotlin",
+ "wasmJsDevelopmentLibraryCompileSync" to "js/packages/wasm-js/dev/kotlin",
+ "wasmJsProductionLibraryCompileSync" to "js/packages/wasm-js/prod/kotlin",
+ "wasmJsTestTestDevelopmentExecutableCompileSync" to
+ "js/packages/wasm-js-test/dev/kotlin",
+ "wasmJsTestTestProductionExecutableCompileSync" to
+ "js/packages/wasm-js-test/prod/kotlin",
+ )
+
+ tasks.withType(DefaultIncrementalSyncTask::class.java).configureEach { task ->
+ val relativePath =
+ destinationPaths[task.name]
+ ?: throw IllegalArgumentException(
+ "No destination path configured for incremental‑sync task '${task.name}'"
+ )
+ task.destinationDirectory.set(file(layout.buildDirectory.dir(relativePath)))
+ }
+}
+
+internal fun Project.configureNode() {
+ val nodeJsPrebuilt =
+ File(project.getPrebuiltsRoot(), "androidx/external/org/nodejs/node").toURI().toString()
+
+ plugins.withType().configureEach {
+ the().let {
+ it.version.set(getVersionByName("node"))
+ if (!ProjectLayoutType.isPlayground(this)) {
+ it.downloadBaseUrl.set(nodeJsPrebuilt)
+ }
+ }
+ }
+ plugins.withType().configureEach {
+ the().let {
+ it.version.set(getVersionByName("node"))
+ if (!ProjectLayoutType.isPlayground(this)) {
+ it.downloadBaseUrl.set(nodeJsPrebuilt)
+ }
+ }
+ }
+
+ if (!ProjectLayoutType.isPlayground(this)) {
+ val javascriptPrebuiltsRoot =
+ File(project.getPrebuiltsRoot(), "androidx/javascript-for-kotlin")
+
+ plugins.withType().configureEach {
+ the().let {
+ it.version.set(getVersionByName("yarn"))
+ it.yarnLockMismatchReport.set(YarnLockMismatchReport.FAIL)
+ it.downloadBaseUrl.set(javascriptPrebuiltsRoot.toURI().toString())
+ }
+ }
+
+ plugins.withType().configureEach {
+ the().let {
+ it.version.set(getVersionByName("yarn"))
+ it.yarnLockMismatchReport.set(YarnLockMismatchReport.FAIL)
+ it.downloadBaseUrl.set(javascriptPrebuiltsRoot.toURI().toString())
+ }
+ }
+ }
+}
+
+@OptIn(ExperimentalWasmDsl::class)
+private fun Project.configureBinaryen() {
+ if (ProjectLayoutType.isPlayground(project)) {
+ return
+ }
+ plugins.withType().configureEach {
+ the()
+ .downloadBaseUrl
+ .set(
+ File(project.getPrebuiltsRoot(), "androidx/javascript-for-kotlin/binaryen")
+ .toURI()
+ .toString()
+ )
+ }
+}
+
+internal fun Project.configurePinnedKotlinLibraries(platform: PlatformIdentifier) {
+ multiplatformExtension?.let {
+ val kotlinLibSuffix =
+ when (platform) {
+ PlatformIdentifier.JS -> "js"
+ PlatformIdentifier.WASM_JS -> "wasm-js"
+ else -> throw IllegalStateException("Unsupported platform: $platform")
+ }
+ val kotlinVersion = project.getVersionByName("kotlin")
+ it.sourceSets.getByName("${platform.id}Main").dependencies {
+ implementation("org.jetbrains.kotlin:kotlin-stdlib-$kotlinLibSuffix:$kotlinVersion")
+ }
+ it.sourceSets.getByName("${platform.id}Test").dependencies {
+ implementation("org.jetbrains.kotlin:kotlin-stdlib-$kotlinLibSuffix:$kotlinVersion")
+ implementation("org.jetbrains.kotlin:kotlin-test-$kotlinLibSuffix:$kotlinVersion")
+ }
+ }
+}
+
+private fun Project.configureKotlinJsTests() {
+ tasks.withType(KotlinJsTest::class.java).configureEach { task ->
+ if (!ProjectLayoutType.isPlayground(this)) {
+ val unzipChromeBuildServiceProvider =
+ gradle.sharedServices.registrations.getByName("unzipChrome").service
+ task.usesService(unzipChromeBuildServiceProvider)
+ // Remove doFirst and switch to FileProperty property to set browser path when issue
+ // https://youtrack.jetbrains.com/issue/KT-72514 is resolved
+ task.doFirst {
+ task.environment(
+ "CHROME_BIN",
+ (unzipChromeBuildServiceProvider.get() as UnzipChromeBuildService).chromePath,
+ )
+ }
+ }
+ // From: https://nodejs.org/api/cli.html
+ task.nodeJsArgs.addAll(listOf("--trace-warnings", "--trace-uncaught", "--trace-sigint"))
+ }
+
+ // Compiler Arg needed for tests only: https://youtrack.jetbrains.com/issue/KT-59081
+ tasks.withType(Kotlin2JsCompile::class.java).configureEach { task ->
+ if (task.name.lowercase().contains("test")) {
+ task.compilerOptions.freeCompilerArgs.add("-Xwasm-enable-array-range-checks")
+ }
+ }
+}
+
+fun Project.validatePublishedMultiplatformHasDefault() {
+ val extension = project.extensions.getByType(AndroidXMultiplatformExtension::class.java)
+ if (extension.defaultPlatform == null && extension.supportedPlatforms.isNotEmpty()) {
+ throw GradleException(
+ "Project is published and multiple platforms are requested. You " +
+ "must explicitly specify androidXMultiplatform.defaultPlatform as one of: " +
+ extension.targetPlatforms.joinToString(", ") {
+ "PlatformIdentifier.${PlatformIdentifier.fromId(it)!!.name}"
+ }
+ )
+ }
+}
diff --git a/buildSrc-fork/private/src/main/kotlin/androidx/build/AndroidXPlaygroundRootImplPlugin.kt b/buildSrc-fork/private/src/main/kotlin/androidx/build/AndroidXPlaygroundRootImplPlugin.kt
new file mode 100644
index 0000000000000..5f4e061952000
--- /dev/null
+++ b/buildSrc-fork/private/src/main/kotlin/androidx/build/AndroidXPlaygroundRootImplPlugin.kt
@@ -0,0 +1,242 @@
+/*
+ * Copyright 2020 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package androidx.build
+
+import androidx.build.gradle.extraPropertyOrNull
+import androidx.build.gradle.isRoot
+import groovy.xml.DOMBuilder
+import java.net.URI
+import java.net.URL
+import org.gradle.api.DefaultTask
+import org.gradle.api.GradleException
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.api.artifacts.dsl.RepositoryHandler
+import org.gradle.api.tasks.testing.AbstractTestTask
+import org.gradle.work.DisableCachingByDefault
+
+/**
+ * This plugin is used in Playground projects and adds functionality like resolving to snapshot
+ * artifacts instead of projects or allowing access to public maven repositories.
+ */
+@Suppress("unused") // used in Playground Projects
+class AndroidXPlaygroundRootImplPlugin : Plugin {
+ private lateinit var rootProject: Project
+
+ /** List of snapshot repositories to fetch AndroidX artifacts */
+ private lateinit var repos: PlaygroundRepositories
+
+ /** The configuration for the plugin read from the gradle properties */
+ private lateinit var config: PlaygroundProperties
+
+ /** List of projects that were requested in the settings.gradle file */
+ private lateinit var primaryProjectPaths: Set
+
+ override fun apply(target: Project) {
+ if (!target.isRoot) {
+ throw GradleException("This plugin should only be applied to root project")
+ }
+ if (!target.plugins.hasPlugin(AndroidXRootImplPlugin::class.java)) {
+ throw GradleException(
+ "Must apply AndroidXRootImplPlugin before applying AndroidXPlaygroundRootImplPlugin"
+ )
+ }
+ rootProject = target
+ config = PlaygroundProperties.load(rootProject)
+ repos = PlaygroundRepositories(config)
+ rootProject.repositories.addPlaygroundRepositories()
+ GradleTransformWorkaround.maybeApply(rootProject)
+ PlaygroundCIHostTestsTask.register(rootProject)
+ primaryProjectPaths =
+ target.extensions.extraProperties.get("primaryProjects")!!.toString().split(",").toSet()
+ rootProject.subprojects { configureSubProject(it) }
+ }
+
+ private fun configureSubProject(project: Project) {
+ project.repositories.addPlaygroundRepositories()
+ project.configurations.configureEach { configuration ->
+ configuration.resolutionStrategy.eachDependency { details ->
+ val requested = details.requested
+ if (requested.version == SNAPSHOT_MARKER) {
+ val snapshotVersion = findSnapshotVersion(requested.group, requested.name)
+ details.useVersion(snapshotVersion)
+ }
+ }
+ }
+ if (project.path in primaryProjectPaths) {
+ project.tasks.withType(AbstractTestTask::class.java).configureEach {
+ PlaygroundCIHostTestsTask.addTask(project, it)
+ }
+ }
+ }
+
+ /**
+ * Finds the snapshot version from the AndroidX snapshot repository.
+ *
+ * This is initially done by reading the maven-metadata from the snapshot repository. The result
+ * of that query is cached in the build file so that subsequent build requests will not need to
+ * access the network.
+ */
+ private fun findSnapshotVersion(group: String, module: String): String {
+ @Suppress("DEPRECATION")
+ val snapshotVersionCache =
+ rootProject.buildDir.resolve("snapshot-version-cache/${config.snapshotBuildId}")
+ val groupPath = group.replace('.', '/')
+ val modulePath = module.replace('.', '/')
+ val metadataCacheFile = snapshotVersionCache.resolve("$groupPath/$modulePath/version.txt")
+ return if (metadataCacheFile.exists()) {
+ metadataCacheFile.readText(Charsets.UTF_8)
+ } else {
+ val metadataUrl = "${repos.snapshots.url}/$groupPath/$modulePath/maven-metadata.xml"
+ @Suppress("deprecation")
+ URL(metadataUrl).openStream().use {
+ val parsedMetadata = DOMBuilder.parse(it.reader())
+ val versionNodes = parsedMetadata.getElementsByTagName("latest")
+ if (versionNodes.length != 1) {
+ throw GradleException(
+ "AndroidXPlaygroundRootImplPlugin#findSnapshotVersion expected exactly " +
+ " one latest version in $metadataUrl, but got ${versionNodes.length}"
+ )
+ }
+ val snapshotVersion = versionNodes.item(0).textContent
+ metadataCacheFile.parentFile.mkdirs()
+ metadataCacheFile.writeText(snapshotVersion, Charsets.UTF_8)
+ snapshotVersion
+ }
+ }
+ }
+
+ private fun RepositoryHandler.addPlaygroundRepositories() {
+ repos.all.forEach { playgroundRepository ->
+ maven { repository ->
+ repository.url = URI(playgroundRepository.url)
+ repository.metadataSources {
+ it.mavenPom()
+ it.artifact()
+ }
+ repository.content {
+ it.includeGroupByRegex(playgroundRepository.includeGroupRegex)
+ if (playgroundRepository.includeModuleRegex != null) {
+ it.includeModuleByRegex(
+ playgroundRepository.includeGroupRegex,
+ playgroundRepository.includeModuleRegex,
+ )
+ }
+ }
+ }
+ }
+ google { repository ->
+ repository.content {
+ it.includeGroupByRegex("androidx.*")
+ it.includeGroupByRegex("com\\.android.*")
+ it.includeGroupByRegex("com\\.google.*")
+ }
+ }
+ mavenCentral()
+ gradlePluginPortal()
+ }
+
+ private class PlaygroundRepositories(props: PlaygroundProperties) {
+ val snapshots =
+ PlaygroundRepository(
+ "https://androidx.dev/snapshots/builds/${props.snapshotBuildId}/artifacts" +
+ "/repository",
+ includeGroupRegex = """androidx\..*""",
+ )
+ val metalava =
+ PlaygroundRepository(
+ "https://androidx.dev/metalava/builds/${props.metalavaBuildId}/artifacts" +
+ "/repo/m2repository",
+ includeGroupRegex = """com\.android\.tools\.metalava""",
+ )
+ val prebuilts =
+ PlaygroundRepository(
+ INTERNAL_PREBUILTS_REPO_URL,
+ includeGroupRegex = """androidx\..*""",
+ )
+ val dokka =
+ PlaygroundRepository(
+ "https://packages.jetbrains.team/maven/p/kt/dokka-dev",
+ includeGroupRegex = """org\.jetbrains\.dokka""",
+ )
+ val kotlinDev =
+ PlaygroundRepository(
+ "https://packages.jetbrains.team/maven/p/kt/dev/",
+ includeGroupRegex = """org\.jetbrains\.kotlin.*""",
+ )
+ val mavenSnapshots =
+ PlaygroundRepository(
+ "https://central.sonatype.com/repository/maven-snapshots/",
+ includeGroupRegex = """com\.google\.devtools.*""",
+ )
+ val all = listOf(snapshots, metalava, dokka, prebuilts, kotlinDev, mavenSnapshots)
+ }
+
+ private data class PlaygroundRepository(
+ val url: String,
+ val includeGroupRegex: String,
+ val includeModuleRegex: String? = null,
+ )
+
+ private data class PlaygroundProperties(
+ val snapshotBuildId: String,
+ val metalavaBuildId: String,
+ ) {
+ companion object {
+ fun load(project: Project): PlaygroundProperties {
+ return PlaygroundProperties(
+ snapshotBuildId = project.requireProperty(PLAYGROUND_SNAPSHOT_BUILD_ID),
+ metalavaBuildId = project.requireProperty(PLAYGROUND_METALAVA_BUILD_ID),
+ )
+ }
+
+ private fun Project.requireProperty(name: String): String {
+ return checkNotNull(extraPropertyOrNull(name)) {
+ "missing $name property. It must be defined in the gradle.properties file"
+ }
+ .toString()
+ }
+ }
+ }
+
+ companion object {
+ const val INTERNAL_PREBUILTS_REPO_URL =
+ "https://androidx.dev/storage/prebuilts/androidx/internal/repository"
+ }
+
+ @DisableCachingByDefault(because = "This is an anchor task that does no work.")
+ abstract class PlaygroundCIHostTestsTask : DefaultTask() {
+ init {
+ group = "Verification"
+ description =
+ "Runs host tests that belong to the projects which were explicitly " +
+ "requested in the playground setup."
+ }
+
+ companion object {
+ private const val NAME = "playgroundCIHostTests"
+
+ fun addTask(project: Project, task: AbstractTestTask) {
+ project.rootProject.tasks.named(NAME).configure { it.dependsOn(task) }
+ }
+
+ fun register(project: Project) {
+ project.tasks.register(NAME, PlaygroundCIHostTestsTask::class.java)
+ }
+ }
+ }
+}
diff --git a/buildSrc-fork/private/src/main/kotlin/androidx/build/AndroidXRepackageImplPlugin.kt b/buildSrc-fork/private/src/main/kotlin/androidx/build/AndroidXRepackageImplPlugin.kt
new file mode 100644
index 0000000000000..2a0ee5429951b
--- /dev/null
+++ b/buildSrc-fork/private/src/main/kotlin/androidx/build/AndroidXRepackageImplPlugin.kt
@@ -0,0 +1,154 @@
+/*
+ * Copyright 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package androidx.build
+
+import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar
+import groovy.lang.Closure
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.api.plugins.JavaLibraryPlugin
+import org.gradle.api.provider.Property
+import org.gradle.api.tasks.SourceSetContainer
+import org.gradle.api.tasks.TaskProvider
+import org.gradle.jvm.tasks.Jar
+import org.gradle.kotlin.dsl.create
+import org.jetbrains.kotlin.gradle.plugin.KotlinBasePlugin
+
+/**
+ * Plugin responsible for repackaging libraries. The plugin repackages what is set in the
+ * [RelocationExtension] by the user and reconfigures the JAR task to output the repackaged classes
+ * JAR.
+ */
+@Suppress("unused")
+class AndroidXRepackageImplPlugin : Plugin {
+
+ override fun apply(project: Project) {
+ val relocationExtension =
+ project.extensions.create(EXTENSION_NAME, project)
+ project.plugins.configureEach { plugin ->
+ when (plugin) {
+ is JavaLibraryPlugin,
+ is KotlinBasePlugin -> project.configureJavaOrKotlinLibrary(relocationExtension)
+ }
+ }
+ }
+
+ private fun Project.configureJavaOrKotlinLibrary(relocationExtension: RelocationExtension) {
+ createConfigurations()
+
+ val sourceSets = extensions.getByType(SourceSetContainer::class.java)
+ val libraryShadowJar =
+ tasks.register("shadowLibraryJar", ShadowJar::class.java) { task ->
+ task.transformers.add(
+ BundleInsideHelper.DontIncludeResourceTransformer().apply {
+ dropResourcesWithSuffix = ".proto"
+ }
+ )
+ task.transformers.add(
+ BundleInsideHelper.DontIncludeResourceTransformer().apply {
+ dropResourcesWithSuffix = ".proto.bin"
+ }
+ )
+ task.from(sourceSets.named("main").map { it.output })
+ relocationExtension.getRelocations().forEach {
+ task.relocate(it.sourcePackage, it.targetPackage)
+ }
+ relocationExtension.artifactId.orNull?.let {
+ task.configurations = listOf(configurations.getByName("repackageClasspath"))
+ }
+ }
+ addArchiveToVariants(libraryShadowJar)
+ }
+
+ private fun Project.createConfigurations() {
+ val repackage =
+ configurations.register("repackage") { config ->
+ config.isCanBeConsumed = false
+ config.isCanBeResolved = false
+ }
+
+ configurations.register("repackageClasspath") { config ->
+ config.isCanBeConsumed = false
+ config.isCanBeResolved = true
+ // remove .get() when https://github.com/gradle/gradle/issues/33396 is fixed
+ config.extendsFrom(repackage.get())
+ }
+
+ tasks.named("jar", Jar::class.java) {
+ // We cannot have two tasks with the same output as the ListTaskOutputsTask will fail.
+ // As we want the repackaged jar as the published artifact, we change the
+ // name of classifier of the JAR task
+ it.archiveClassifier.set("before-shadow")
+ }
+
+ forceJarUsageForAndroid()
+ }
+
+ /**
+ * This forces the use of repackaged JARs as opposed to the java-classes-directory for Android.
+ * Without this, AGP uses the artifacts in java-classes-directory, which do not have the classes
+ * repackaged to the target package.
+ *
+ * We attempted to extract the contents of the repackaged library JAR into classes/java/main,
+ * but the AGP transform depends on JavaCompile. We cannot make JavaCompile depend on the task
+ * that creates the shadowed library as that would result in a circular dependency.
+ */
+ private fun Project.forceJarUsageForAndroid() =
+ configurations.configureEach { configuration ->
+ if (configuration.name == "runtimeElements") {
+ configuration.outgoing.variants.removeIf { it.name == "classes" }
+ }
+ }
+
+ private fun Project.addArchiveToVariants(task: TaskProvider) =
+ configurations.configureEach { configuration ->
+ if (configuration.name == "apiElements" || configuration.name == "runtimeElements") {
+ configuration.outgoing.artifacts.clear()
+ configuration.outgoing.artifact(task)
+ }
+ }
+
+ companion object {
+ const val EXTENSION_NAME = "repackage"
+ }
+}
+
+class Relocation {
+ /* The package name and any import statements for a class that are to be relocated. */
+ var sourcePackage: String? = null
+
+ /* The package name and any import statements for a class to which they should be relocated. */
+ var targetPackage: String? = null
+}
+
+abstract class RelocationExtension(val project: Project) {
+
+ private var relocations: MutableCollection = ArrayList()
+
+ fun addRelocation(closure: Closure): Relocation {
+ val relocation = project.configure(Relocation(), closure) as Relocation
+ relocations.add(relocation)
+ return relocation
+ }
+
+ fun getRelocations(): Collection {
+ return relocations
+ }
+
+ /* Optional artifact id if the user wants to publish the dependency in the shadowed config. */
+ abstract val artifactId: Property
+}
diff --git a/buildSrc-fork/private/src/main/kotlin/androidx/build/AndroidXRootImplPlugin.kt b/buildSrc-fork/private/src/main/kotlin/androidx/build/AndroidXRootImplPlugin.kt
new file mode 100644
index 0000000000000..7e8ec94310dab
--- /dev/null
+++ b/buildSrc-fork/private/src/main/kotlin/androidx/build/AndroidXRootImplPlugin.kt
@@ -0,0 +1,250 @@
+/*
+ * Copyright 2020 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package androidx.build
+
+import androidx.build.AndroidXImplPlugin.Companion.FINALIZE_TEST_CONFIGS_WITH_APKS_TASK
+import androidx.build.AndroidXImplPlugin.Companion.ZIP_TEST_CONFIGS_WITH_APKS_TASK
+import androidx.build.buildInfo.CreateAggregateLibraryBuildInfoFileTask
+import androidx.build.buildInfo.CreateAggregateLibraryBuildInfoFileTask.Companion.CREATE_AGGREGATE_BUILD_INFO_FILES_TASK
+import androidx.build.dependencyTracker.AffectedModuleDetector
+import androidx.build.gradle.isRoot
+import androidx.build.license.ValidateLicensesExistTask
+import androidx.build.logging.TERMINAL_RED
+import androidx.build.logging.TERMINAL_RESET
+import androidx.build.playground.ValidateIntegrationPatches
+import androidx.build.playground.VerifyPlaygroundGradleConfigurationTask
+import androidx.build.studio.StudioTask.Companion.registerStudioTask
+import androidx.build.testConfiguration.registerOwnersServiceTasks
+import androidx.build.uptodatedness.TaskUpToDateValidator
+import androidx.build.uptodatedness.cacheEvenIfNoOutputs
+import com.android.Version.ANDROID_GRADLE_PLUGIN_VERSION
+import java.io.File
+import java.util.concurrent.ConcurrentHashMap
+import javax.inject.Inject
+import org.gradle.api.GradleException
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.api.configuration.BuildFeatures
+import org.gradle.api.file.RelativePath
+import org.gradle.api.tasks.Copy
+import org.gradle.api.tasks.bundling.Zip
+import org.gradle.api.tasks.bundling.ZipEntryCompression
+import org.gradle.build.event.BuildEventsListenerRegistry
+import org.gradle.kotlin.dsl.extra
+import org.gradle.kotlin.dsl.register
+import org.gradle.kotlin.dsl.withType
+import org.jetbrains.kotlin.gradle.targets.js.npm.tasks.KotlinNpmInstallTask
+import org.jetbrains.kotlin.gradle.targets.js.npm.tasks.KotlinToolingSetupTask
+
+abstract class AndroidXRootImplPlugin : Plugin {
+ @get:Inject abstract val registry: BuildEventsListenerRegistry
+ @get:Inject abstract val buildFeatures: BuildFeatures
+
+ override fun apply(project: Project) {
+ if (!project.isRoot) {
+ throw Exception("This plugin should only be applied to root project")
+ }
+ project.configureRootProject()
+ }
+
+ private fun Project.configureRootProject() {
+ project.validateAllAndroidxArgumentsAreRecognized()
+ tasks.register("listAndroidXProperties", ListAndroidXPropertiesTask::class.java)
+ tasks.register("createProject", ProjectCreatorTask::class.java)
+ configureKtfmtCheckFile()
+ maybeRegisterFilterableTask()
+ registerListAffectedProjectsTask()
+
+ /* In JetBrains Fork we don't force AGP version.
+ // If we're running inside Studio, validate the Android Gradle Plugin version.
+ val expectedAgpVersion = System.getenv("EXPECTED_AGP_VERSION")
+ if (providers.gradleProperty("android.injected.invoked.from.ide").isPresent) {
+ if (expectedAgpVersion != ANDROID_GRADLE_PLUGIN_VERSION) {
+ throw GradleException(
+ """
+ Please close and restart Android Studio.
+
+ Expected AGP version \"$expectedAgpVersion\" does not match actual AGP version
+ \"$ANDROID_GRADLE_PLUGIN_VERSION\". This happens when AGP is updated while
+ Studio is running and can be fixed by restarting Studio.
+ """
+ .trimIndent()
+ )
+ }
+ }
+ */
+
+ val verifyPlayground = VerifyPlaygroundGradleConfigurationTask.createIfNecessary(project)
+
+ val aggregateBuildInfo =
+ if (!buildFeatures.isIsolatedProjectsEnabled()) {
+ tasks.register(
+ CREATE_AGGREGATE_BUILD_INFO_FILES_TASK,
+ CreateAggregateLibraryBuildInfoFileTask::class.java,
+ )
+ } else null
+
+ val attestationManifest =
+ if (!buildFeatures.isIsolatedProjectsEnabled()) {
+ tasks.register(ATTESTATION_TASK_NAME, AttestationManifestTask::class.java) { task ->
+ task.manifestFile.set(
+ getDistributionDirectory().file("attestation_manifest.json")
+ )
+ }
+ } else null
+ tasks.register(BUILD_ON_SERVER_TASK, BuildOnServerTask::class.java) { task ->
+ task.cacheEvenIfNoOutputs()
+ task.aggregateBuildInfoFile.set(
+ getDistributionDirectory().file(AGGREGATE_BUILD_INFO_FILE_NAME)
+ )
+ verifyPlayground?.let { task.dependsOn(it) }
+ aggregateBuildInfo?.let { task.dependsOn(it) }
+ attestationManifest?.let { task.dependsOn(it) }
+ }
+
+ extra.set("projects", ConcurrentHashMap())
+
+ /**
+ * Copy App APKs (from ApkOutputProviders) into [getTestConfigDirectory] before zipping.
+ * Flatten directory hierarchy as both TradeFed and FTL work with flat hierarchy.
+ */
+ val finalizeConfigsTask =
+ project.tasks.register(FINALIZE_TEST_CONFIGS_WITH_APKS_TASK, Copy::class.java) {
+ it.from(project.getAppApksFilesDirectory())
+ it.into(project.getTestConfigDirectory())
+ it.eachFile { f -> f.relativePath = RelativePath(true, f.name) }
+ it.includeEmptyDirs = false
+ }
+
+ // NOTE: this task is used by the Github CI as well. If you make any changes here,
+ // please update the .github/workflows files as well, if necessary.
+ project.tasks.register(ZIP_TEST_CONFIGS_WITH_APKS_TASK, Zip::class.java) {
+ // Flatten PrivacySandbox APKs in separate task to preserve file order in resulting ZIP.
+ it.dependsOn(finalizeConfigsTask)
+ it.destinationDirectory.set(project.getDistributionDirectory())
+ it.archiveFileName.set("androidTest.zip")
+ it.from(project.getTestConfigDirectory())
+ // We're mostly zipping a bunch of .apk files that are already compressed
+ it.entryCompression = ZipEntryCompression.STORED
+ // Archive is greater than 4Gb :O
+ it.isZip64 = true
+ it.isReproducibleFileOrder = true
+ }
+
+ AffectedModuleDetector.configure(gradle, this)
+
+ if (!buildFeatures.isIsolatedProjectsEnabled()) {
+ registerOwnersServiceTasks()
+ }
+ registerStudioTask()
+
+ project.tasks.register("listTaskOutputs", ListTaskOutputsTask::class.java) { task ->
+ task.outputFile.set(project.getDistributionDirectory().file("task_outputs.txt"))
+ task.removePrefix(project.getCheckoutRoot().path)
+ }
+
+ TaskUpToDateValidator.setup(project, registry)
+
+ /**
+ * Add dependency analysis plugin and add buildHealth task to buildOnServer when
+ * maxDepVersions is not enabled
+ */
+ if (!project.usingMaxDepVersions().get()) {
+ project.plugins.apply("com.autonomousapps.dependency-analysis")
+
+ // Ignore advice regarding ktx dependencies
+ val dependencyAnalysis =
+ project.extensions.getByType(
+ com.autonomousapps.DependencyAnalysisExtension::class.java
+ )
+ dependencyAnalysis.structure { it.ignoreKtx(true) }
+ }
+ project.configureTasksForKotlinWeb()
+
+ tasks.register("checkExternalLicenses", ValidateLicensesExistTask::class.java) {
+ it.prebuiltsDirectory.set(File(getPrebuiltsRoot(), "androidx/external"))
+ it.baseline.set(layout.projectDirectory.file("license-baseline.txt"))
+ it.cacheEvenIfNoOutputs()
+ }
+
+ ValidateIntegrationPatches.createTask(project)
+
+ fetchDevelocityKeysIfNeeded()
+ }
+
+ private fun Project.configureTasksForKotlinWeb() {
+ val offlineMirrorStorage =
+ if (ProjectLayoutType.isPlayground(this)) {
+ project.file(
+ layout.buildDirectory.dir("javascript-for-playground").map {
+ it.asFile.also { file -> file.mkdirs() }
+ }
+ )
+ } else {
+ File(getPrebuiltsRoot(), "androidx/javascript-for-kotlin")
+ }
+
+ val createYarnRcFileTask =
+ tasks.register("createYarnRcFile", CreateYarnRcFileTask::class.java) {
+ it.offlineMirrorStorage.set(offlineMirrorStorage)
+ it.cacheStorage.set(layout.buildDirectory.dir("yarnCache"))
+ it.yarnrcFile.set(layout.buildDirectory.file(".yarnrc"))
+ }
+ val createWasmYarnRcFileTask =
+ tasks.register("createWasmYarnRcFile", CreateYarnRcFileTask::class.java) {
+ it.offlineMirrorStorage.set(offlineMirrorStorage)
+ it.cacheStorage.set(layout.buildDirectory.dir("wasmYarnCache"))
+ it.yarnrcFile.set(layout.buildDirectory.file("wasm/.yarnrc"))
+ }
+
+ configureNode()
+
+ // ensure yarn install is complete before using it to install kotlin wasm tooling
+ tasks.withType().configureEach {
+ it.dependsOn(tasks.withType())
+ }
+
+ tasks.withType().configureEach {
+ when (it.name) {
+ "kotlinNpmInstall" -> it.dependsOn(createYarnRcFileTask)
+ "kotlinWasmNpmInstall" -> it.dependsOn(createWasmYarnRcFileTask)
+ }
+ it.args.addAll(listOf("--ignore-engines", "--verbose"))
+ if (project.useYarnOffline()) {
+ it.args.add("--offline")
+ it.additionalFiles.plus(offlineMirrorStorage)
+ it.doFirst {
+ println(
+ """
+ Fetching yarn packages from the offline mirror: ${offlineMirrorStorage.path}.
+ Your build will fail if a package is not in the offline mirror. To fix, run:
+
+ $TERMINAL_RED./gradlew kotlinNpmInstall kotlinWasmNpmInstall -Pandroidx.yarnOfflineMode=false && ./gradlew kotlinUpgradeYarnLock kotlinWasmUpgradeYarnLock$TERMINAL_RESET
+
+ this will download the dependencies from the internet and update the lockfile.
+ Don't forget to upload the changes to Gerrit!
+ """
+ .trimIndent()
+ .replace("\n", " ")
+ )
+ }
+ }
+ }
+ }
+}
+
+internal const val AGGREGATE_BUILD_INFO_FILE_NAME = "androidx_aggregate_build_info.txt"
diff --git a/buildSrc-fork/private/src/main/kotlin/androidx/build/AttestationManifestTask.kt b/buildSrc-fork/private/src/main/kotlin/androidx/build/AttestationManifestTask.kt
new file mode 100644
index 0000000000000..db94dca8cf8f1
--- /dev/null
+++ b/buildSrc-fork/private/src/main/kotlin/androidx/build/AttestationManifestTask.kt
@@ -0,0 +1,71 @@
+/*
+ * Copyright 2025 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package androidx.build
+
+import org.gradle.api.DefaultTask
+import org.gradle.api.Project
+import org.gradle.api.file.RegularFileProperty
+import org.gradle.api.provider.MapProperty
+import org.gradle.api.provider.Provider
+import org.gradle.api.tasks.CacheableTask
+import org.gradle.api.tasks.Input
+import org.gradle.api.tasks.OutputFile
+import org.gradle.api.tasks.TaskAction
+import org.gradle.kotlin.dsl.named
+
+@CacheableTask
+abstract class AttestationManifestTask : DefaultTask() {
+ @get:Input abstract val sbomMap: MapProperty
+
+ @get:Input abstract val zipMap: MapProperty
+
+ @get:OutputFile abstract val manifestFile: RegularFileProperty
+
+ @TaskAction
+ fun writeManifest() {
+ val output =
+ zipMap.get().keys.joinToString(separator = ",\n", prefix = "[\n", postfix = "\n]") { key
+ ->
+ check(sbomMap.get().containsKey(key)) {
+ "sbomMap is missing an entry for $key project"
+ }
+ """ {
+ "artifact_path": "${zipMap.get()[key]!!}",
+ "sbom_path": "${sbomMap.get()[key]!!}",
+ "attest_archive_contents": true
+ }"""
+ }
+ manifestFile.get().asFile.writeText(output)
+ }
+}
+
+internal fun Project.addSbomToAttestation(relativeSbomPath: Provider) {
+ rootProject.tasks.named(ATTESTATION_TASK_NAME).configure { manifestTask
+ ->
+ manifestTask.sbomMap.put(path, relativeSbomPath)
+ }
+}
+
+internal fun Project.addZipToAttestation(relativeZipPath: Provider) {
+ if (ProjectLayoutType.isPlayground(this)) return
+ rootProject.tasks.named(ATTESTATION_TASK_NAME).configure { manifestTask
+ ->
+ manifestTask.zipMap.put(path, relativeZipPath)
+ }
+}
+
+internal const val ATTESTATION_TASK_NAME = "attestationManifest"
diff --git a/buildSrc-fork/private/src/main/kotlin/androidx/build/BenchmarkConfiguration.kt b/buildSrc-fork/private/src/main/kotlin/androidx/build/BenchmarkConfiguration.kt
new file mode 100644
index 0000000000000..89725cdb00a7d
--- /dev/null
+++ b/buildSrc-fork/private/src/main/kotlin/androidx/build/BenchmarkConfiguration.kt
@@ -0,0 +1,69 @@
+/*
+ * Copyright 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package androidx.build
+
+import com.android.build.api.variant.HasDeviceTests
+import org.gradle.api.Project
+
+/**
+ * Enable internal defaults for microbenchmark which can be used to set defaults we aren't ready to
+ * apply publicly, or which require root to function.
+ *
+ * See [androidx.build.testConfiguration.INST_ARG_BLOCKLIST], which can be used to suppress some of
+ * these args in CI.
+ */
+internal fun HasDeviceTests.enableMicrobenchmarkInternalDefaults(project: Project) {
+ if (project.hasBenchmarkPlugin()) {
+ deviceTests.forEach { (_, deviceTest) ->
+ // Enables CPU perf event counters both locally, and in CI
+ deviceTest.instrumentationRunnerArguments.put(
+ "androidx.benchmark.cpuEventCounter.enable",
+ "true",
+ )
+
+ // Set default events to aid in CI investigations of run to run noise
+ // Avoid using more than three, or capture may fail reporting all zeros, see b/291826415
+ deviceTest.instrumentationRunnerArguments.put(
+ "androidx.benchmark.cpuEventCounter.events",
+ "Instructions,L1DMisses,BranchMisses",
+ )
+
+ // Force AndroidX devs to disable JIT on rooted devices
+ deviceTest.instrumentationRunnerArguments.put(
+ "androidx.benchmark.requireJitDisabledIfRooted",
+ "true",
+ )
+
+ // Check that speed compilation always used when benchmark invoked
+ deviceTest.instrumentationRunnerArguments.put("androidx.benchmark.requireAot", "true")
+
+ // Throw if measureRepeated() called on main thread to avoid ANRs
+ deviceTest.instrumentationRunnerArguments.put(
+ "androidx.benchmark.throwOnMainThreadMeasureRepeated",
+ "true",
+ )
+
+ // Enables long-running method tracing on the UI thread, even if that risks ANR for
+ // profiling convenience.
+ // NOTE, this *must* be suppressed in CI!!
+ deviceTest.instrumentationRunnerArguments.put(
+ "androidx.benchmark.profiling.skipWhenDurationRisksAnr",
+ "false",
+ )
+ }
+ }
+}
diff --git a/buildSrc-fork/private/src/main/kotlin/androidx/build/BuildOnServerTask.kt b/buildSrc-fork/private/src/main/kotlin/androidx/build/BuildOnServerTask.kt
new file mode 100644
index 0000000000000..e6d7376ff1946
--- /dev/null
+++ b/buildSrc-fork/private/src/main/kotlin/androidx/build/BuildOnServerTask.kt
@@ -0,0 +1,56 @@
+/*
+ * Copyright 2019 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package androidx.build
+
+import java.io.FileNotFoundException
+import org.gradle.api.DefaultTask
+import org.gradle.api.file.RegularFileProperty
+import org.gradle.api.tasks.CacheableTask
+import org.gradle.api.tasks.InputFile
+import org.gradle.api.tasks.PathSensitive
+import org.gradle.api.tasks.PathSensitivity
+import org.gradle.api.tasks.TaskAction
+
+/**
+ * Task for building all of Androidx libraries and documentation
+ *
+ * AndroidXImplPlugin configuration adds dependencies to BuildOnServer for all of the tasks that
+ * produce artifacts that we want to build on server builds When BuildOnServer executes, it
+ * double-checks that all expected artifacts were built
+ */
+@CacheableTask
+abstract class BuildOnServerTask : DefaultTask() {
+
+ init {
+ group = "Build"
+ description = "Builds all of the Androidx libraries and documentation"
+ }
+
+ @get:InputFile
+ @get:PathSensitive(PathSensitivity.RELATIVE)
+ abstract val aggregateBuildInfoFile: RegularFileProperty
+
+ @TaskAction
+ fun checkAllBuildOutputs() {
+ if (!aggregateBuildInfoFile.get().asFile.exists()) {
+ throw FileNotFoundException(
+ "buildOnServer required output missing: " +
+ "${aggregateBuildInfoFile.get().asFile.path}"
+ )
+ }
+ }
+}
diff --git a/buildSrc-fork/private/src/main/kotlin/androidx/build/CheckKotlinApiTargetTask.kt b/buildSrc-fork/private/src/main/kotlin/androidx/build/CheckKotlinApiTargetTask.kt
new file mode 100644
index 0000000000000..23e117df41af1
--- /dev/null
+++ b/buildSrc-fork/private/src/main/kotlin/androidx/build/CheckKotlinApiTargetTask.kt
@@ -0,0 +1,90 @@
+/*
+ * Copyright 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package androidx.build
+
+import org.gradle.api.DefaultTask
+import org.gradle.api.artifacts.component.ModuleComponentIdentifier
+import org.gradle.api.file.RegularFileProperty
+import org.gradle.api.provider.Property
+import org.gradle.api.provider.Provider
+import org.gradle.api.tasks.Input
+import org.gradle.api.tasks.Internal
+import org.gradle.api.tasks.OutputFile
+import org.gradle.api.tasks.TaskAction
+import org.gradle.work.DisableCachingByDefault
+import org.jetbrains.kotlin.gradle.dsl.KotlinVersion
+
+/** Check if the kotlin-stdlib transitive dependencies are the same as the project specified one. */
+@DisableCachingByDefault(because = "not worth caching")
+abstract class CheckKotlinApiTargetTask : DefaultTask() {
+
+ @get:Input abstract val kotlinTarget: Property
+
+ @get:Internal val projectPath: String = project.path
+
+ @get:Input
+ val allDependencies: Provider>> =
+ project.provider {
+ project.configurations
+ .filter(project::shouldVerifyConfiguration)
+ .filter { it.isCanBeResolved && it.isPublished() }
+ .flatMap { config ->
+ config.incoming.resolutionResult.allComponents.mapNotNull { component ->
+ (component.id as? ModuleComponentIdentifier)?.let { id ->
+ "${id.module}:${id.version}" to config.name
+ }
+ }
+ }
+ }
+
+ @get:OutputFile abstract val outputFile: RegularFileProperty
+
+ @TaskAction
+ fun check() {
+ val incompatibleConfigurations =
+ allDependencies
+ .get()
+ .asSequence()
+ .filter { it.first.startsWith("kotlin-stdlib:") }
+ .map { it.first.substringAfter(":") to it.second }
+ .map { KotlinVersion.fromVersion(it.first.substringBeforeLast('.')) to it.second }
+ .filter { it.first > kotlinTarget.get() }
+ .map { "${it.second} (${it.first})" }
+ .toList()
+
+ val outputFile = outputFile.get().asFile
+ outputFile.parentFile.mkdirs()
+
+ if (incompatibleConfigurations.isNotEmpty()) {
+ val errorMessage =
+ incompatibleConfigurations.joinToString(
+ separator = "\n - ",
+ prefix =
+ "The project's kotlin-stdlib target is ${kotlinTarget.get()} but these " +
+ "configurations are pulling in higher versions of kotlin-stdlib:\n - ",
+ postfix =
+ "\n\nRun ./gradlew $projectPath:dependencies to see which dependency is " +
+ "pulling in the incompatible kotlin-stdlib",
+ )
+ outputFile.writeText("FAILURE: $errorMessage")
+ throw IllegalStateException(errorMessage)
+ }
+ }
+
+ companion object {
+ const val TASK_NAME = "checkKotlinApiTarget"
+ }
+}
diff --git a/collection/collection-compatibility-stub/src/commonMain/kotlin/EmptyFile.kt b/buildSrc-fork/private/src/main/kotlin/androidx/build/ClasspathBuilder.kt
similarity index 54%
rename from collection/collection-compatibility-stub/src/commonMain/kotlin/EmptyFile.kt
rename to buildSrc-fork/private/src/main/kotlin/androidx/build/ClasspathBuilder.kt
index cfcdef3ab267e..3d9c86d000465 100644
--- a/collection/collection-compatibility-stub/src/commonMain/kotlin/EmptyFile.kt
+++ b/buildSrc-fork/private/src/main/kotlin/androidx/build/ClasspathBuilder.kt
@@ -14,9 +14,17 @@
* limitations under the License.
*/
-// We prefer to have no source code here, but a module can't be empty.
-// We use this module to publish a dumb klib to be provided to the compilation of user projects.
-// It's needed because Kotlin tries to resolve the dependencies listed in klib manifest.
-// There is an intention to drop this behavior: https://youtrack.jetbrains.com/issue/KT-61096
-// The actual klib is published at androidx maven coordinates in Google maven.
-// This module depends on the actual klib, so the module API will be available transitively.
\ No newline at end of file
+package androidx.build
+
+import org.gradle.api.Project
+import org.gradle.api.file.FileCollection
+
+/**
+ * Returns a FileCollection that is a classpath of the library defined in the libs.versions.toml.
+ */
+fun Project.getLibraryClasspath(libraryName: String): FileCollection {
+ return configurations
+ .detachedConfiguration(dependencies.create(getLibraryByName(libraryName)))
+ .incoming
+ .files
+}
diff --git a/buildSrc-fork/private/src/main/kotlin/androidx/build/ConfigureAarAsJar.kt b/buildSrc-fork/private/src/main/kotlin/androidx/build/ConfigureAarAsJar.kt
new file mode 100644
index 0000000000000..09984dcf20739
--- /dev/null
+++ b/buildSrc-fork/private/src/main/kotlin/androidx/build/ConfigureAarAsJar.kt
@@ -0,0 +1,53 @@
+/*
+ * Copyright 2022 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package androidx.build
+
+import com.android.build.api.attributes.BuildTypeAttr
+import org.gradle.api.Project
+import org.gradle.api.artifacts.type.ArtifactTypeDefinition
+import org.gradle.api.attributes.Usage
+import org.gradle.api.attributes.java.TargetJvmEnvironment
+
+/**
+ * Creates `[configurationName]AarAsJar` config for JVM tests that need Android library classes on
+ * the classpath.
+ */
+internal fun configureAarAsJarForConfiguration(project: Project, configurationName: String) {
+ val releaseVariant =
+ project.objects.named(BuildTypeAttr::class.java, Release.DEFAULT_PUBLISH_CONFIG)
+ val javaApiUsage = project.objects.named(Usage::class.java, Usage.JAVA_API)
+ val androidJvmEnv =
+ project.objects.named(TargetJvmEnvironment::class.java, TargetJvmEnvironment.ANDROID)
+
+ val aarAsJarConfig =
+ project.configurations.register("${configurationName}AarAsJar") {
+ it.isTransitive = false
+ it.isCanBeConsumed = false
+ it.isCanBeResolved = true
+
+ it.attributes.apply {
+ attribute(BuildTypeAttr.ATTRIBUTE, releaseVariant)
+ attribute(Usage.USAGE_ATTRIBUTE, javaApiUsage)
+ attribute(TargetJvmEnvironment.TARGET_JVM_ENVIRONMENT_ATTRIBUTE, androidJvmEnv)
+ attribute(ArtifactTypeDefinition.ARTIFACT_TYPE_ATTRIBUTE, "android-classes-jar")
+ }
+ }
+
+ project.configurations.named(configurationName) { config ->
+ config.dependencies.add(project.dependencies.create(aarAsJarConfig.get().incoming.files))
+ }
+}
diff --git a/buildSrc-fork/private/src/main/kotlin/androidx/build/CreateYarnRcTask.kt b/buildSrc-fork/private/src/main/kotlin/androidx/build/CreateYarnRcTask.kt
new file mode 100644
index 0000000000000..e9e96e6a359a9
--- /dev/null
+++ b/buildSrc-fork/private/src/main/kotlin/androidx/build/CreateYarnRcTask.kt
@@ -0,0 +1,60 @@
+/*
+ * Copyright 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package androidx.build
+
+import org.gradle.api.DefaultTask
+import org.gradle.api.file.DirectoryProperty
+import org.gradle.api.file.RegularFileProperty
+import org.gradle.api.tasks.InputDirectory
+import org.gradle.api.tasks.OutputDirectory
+import org.gradle.api.tasks.OutputFile
+import org.gradle.api.tasks.PathSensitive
+import org.gradle.api.tasks.PathSensitivity
+import org.gradle.api.tasks.TaskAction
+import org.gradle.work.DisableCachingByDefault
+
+/**
+ * Creates an `.yarnrc` file in a specified directory. The `.yarnrc` file will contain the path to
+ * the offline storage of the required dependencies.
+ */
+@DisableCachingByDefault(because = "not worth caching")
+abstract class CreateYarnRcFileTask : DefaultTask() {
+
+ @get:InputDirectory
+ @get:PathSensitive(PathSensitivity.ABSOLUTE)
+ abstract val offlineMirrorStorage: DirectoryProperty
+
+ @get:OutputDirectory abstract val cacheStorage: DirectoryProperty
+
+ @get:OutputFile abstract val yarnrcFile: RegularFileProperty
+
+ @TaskAction
+ fun createFile() {
+ val offlineStoragePath = offlineMirrorStorage.get().asFile.absolutePath
+ val cacheStoragePath = cacheStorage.get().asFile.absolutePath
+ yarnrcFile.get().asFile.let {
+ it.parentFile.mkdirs()
+ it.writeText(
+ """
+ yarn-offline-mirror "$offlineStoragePath"
+ cache-folder "$cacheStoragePath"
+ """
+ .trimIndent()
+ )
+ }
+ }
+}
diff --git a/buildSrc-fork/private/src/main/kotlin/androidx/build/DependencyAnalysisPostProcessingTasks.kt b/buildSrc-fork/private/src/main/kotlin/androidx/build/DependencyAnalysisPostProcessingTasks.kt
new file mode 100644
index 0000000000000..2deb4e5785381
--- /dev/null
+++ b/buildSrc-fork/private/src/main/kotlin/androidx/build/DependencyAnalysisPostProcessingTasks.kt
@@ -0,0 +1,282 @@
+/*
+ * Copyright 2025 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package androidx.build
+
+import androidx.build.logging.TERMINAL_RED
+import androidx.build.logging.TERMINAL_RESET
+import androidx.build.uptodatedness.cacheEvenIfNoOutputs
+import com.autonomousapps.AbstractPostProcessingTask
+import com.autonomousapps.model.ModuleCoordinates
+import com.autonomousapps.model.ProjectAdvice
+import com.autonomousapps.model.ProjectCoordinates
+import com.google.gson.Gson
+import com.google.gson.GsonBuilder
+import java.io.File
+import kotlin.text.appendLine
+import org.gradle.api.Project
+import org.gradle.api.file.RegularFileProperty
+import org.gradle.api.tasks.CacheableTask
+import org.gradle.api.tasks.InputFile
+import org.gradle.api.tasks.Internal
+import org.gradle.api.tasks.Optional
+import org.gradle.api.tasks.OutputFile
+import org.gradle.api.tasks.PathSensitive
+import org.gradle.api.tasks.PathSensitivity
+import org.gradle.api.tasks.TaskAction
+
+/**
+ * Task that reports dependency analysis advice for the project. It gets advice from the dependency
+ * analysis gradle plugin and checks the baselines for the advice already captured and only reports
+ * if additional violations are found.
+ */
+@CacheableTask
+abstract class ReportDependencyAnalysisAdviceTask : AbstractPostProcessingTask() {
+ init {
+ group = "Verification"
+ description = "Task for generating advice for dependency analysis"
+ }
+
+ @get:Internal abstract val baseLineFile: RegularFileProperty
+
+ @InputFile
+ @Optional
+ @PathSensitive(PathSensitivity.NONE)
+ fun getDependencyAnalysisBaseline(): File? = baseLineFile.get().asFile.takeIf { it.exists() }
+
+ @get:Internal val projectPath: String = project.path
+ @get:Internal val isKMP: Boolean = project.multiplatformExtension != null
+ @get:Internal
+ val isPublishedLibrary: Boolean =
+ project.extensions.getByType(AndroidXExtension::class.java).type ==
+ SoftwareType.PUBLISHED_LIBRARY
+
+ @TaskAction
+ fun getAdvice() {
+ val projectAdvice =
+ this@ReportDependencyAnalysisAdviceTask.projectAdvice().toAndroidxProjectAdvice()
+
+ val baselineAdvice =
+ Gson()
+ .fromJson(
+ getDependencyAnalysisBaseline()?.readText(),
+ AndroidxProjectAdvice::class.java,
+ )
+
+ val advice =
+ if (baselineAdvice != null) {
+ getIncrementalAdvice(
+ projectAdvice.dependencyAdvice.filter {
+ !baselineAdvice.dependencyAdvice.contains(it)
+ }
+ )
+ } else {
+ getIncrementalAdvice(projectAdvice.dependencyAdvice)
+ }
+
+ if (advice.isNotBlank()) {
+ error(
+ """
+ There are some new dependencies added to this change that might be misconfigured:
+ $advice
+ ********************************************************************************
+ $TERMINAL_RED
+ To get a complete list of misconfigured dependencies, please run:
+ ./gradlew $projectPath:projectHealth.
+ To update the dependency analysis baseline file, please run:
+ ./gradlew $projectPath:updateDependencyAnalysisBaseline
+ $TERMINAL_RESET
+ ********************************************************************************
+ """
+ .trimIndent()
+ )
+ }
+ }
+
+ private fun getIncrementalAdvice(missingDependencyAdvice: List): String {
+ // Skip the reporting of modify dependencies for now, so that advice is easier to follow.
+ val unused = mutableSetOf()
+ val transitive = mutableSetOf()
+ val advice = StringBuilder()
+
+ missingDependencyAdvice.forEach {
+ // Don't fail CI if test source set has misconfigured dependencies
+ if (it.fromConfiguration?.contains("test", ignoreCase = true) == true) {
+ return@forEach
+ }
+ if (it.toConfiguration?.contains("test", ignoreCase = true) == true) {
+ return@forEach
+ }
+
+ val isCompileOnly =
+ it.toConfiguration?.endsWith("compileOnly", ignoreCase = true) == true
+ val isTransitiveDependencyAdvice =
+ it.fromConfiguration == null && it.toConfiguration != null && !isCompileOnly
+ val isUnusedDependencyAdvice =
+ it.fromConfiguration != null && it.toConfiguration == null
+
+ val identifier =
+ if (it.coordinates.type == "project") {
+ "project(${it.coordinates.identifier})"
+ } else {
+ "'${it.coordinates.identifier}:${it.coordinates.resolvedVersion}'"
+ }
+ if (isTransitiveDependencyAdvice) {
+ transitive.add("${it.toConfiguration}($identifier)")
+ }
+ if (isUnusedDependencyAdvice) {
+ unused.add("${it.fromConfiguration}($identifier)")
+ }
+ }
+ if (unused.isNotEmpty()) {
+ advice.appendLine("Unused dependencies which should be removed:")
+ advice.appendLine(unused.sorted().joinToString(separator = "\n"))
+ }
+ if (transitive.isNotEmpty()) {
+ advice.appendLine("These transitive dependencies can be declared directly:")
+ advice.appendLine(transitive.sorted().joinToString(separator = "\n"))
+ }
+ return advice.toString()
+ }
+}
+
+/** Task to update dependency analysis baselines for the project. */
+@CacheableTask
+abstract class UpdateDependencyAnalysisBaseLineTask : AbstractPostProcessingTask() {
+ init {
+ group = "Verification"
+ description = "Task for updating dependency analysis baselines"
+ }
+
+ @get:OutputFile abstract val outputFile: RegularFileProperty
+ @get:Internal val isKMP: Boolean = project.multiplatformExtension != null
+ @get:Internal
+ val isPublishedLibrary: Boolean =
+ project.extensions.getByType(AndroidXExtension::class.java).type ==
+ SoftwareType.PUBLISHED_LIBRARY
+
+ @TaskAction
+ fun updateBaseLineForDependencyAnalysisAdvice() {
+ val projectAdvice =
+ this@UpdateDependencyAnalysisBaseLineTask.projectAdvice().toAndroidxProjectAdvice()
+ val outputFile = outputFile.get()
+ val gson = GsonBuilder().setPrettyPrinting().create()
+ outputFile.asFile.writeText(gson.toJson(projectAdvice))
+ }
+}
+
+/**
+ * Configure the dependency analysis gradle plugin and register new post-processing tasks:
+ * 1. Updating the baselines for advice provided by the plugin.
+ * 2. Getting any incremental advice not captured in the baselines.
+ */
+internal fun Project.configureDependencyAnalysisPlugin() {
+ plugins.apply("com.autonomousapps.dependency-analysis")
+
+ val updateDependencyAnalysisBaselineTask =
+ tasks.register(
+ "updateDependencyAnalysisBaseline",
+ UpdateDependencyAnalysisBaseLineTask::class.java,
+ ) { task ->
+ task.outputFile.set(layout.projectDirectory.file("dependencyAnalysis-baseline.json"))
+ task.cacheEvenIfNoOutputs()
+ // DAGP currently doesn't support KMP, enable KMP projects when b/394970486 is resolved
+ task.onlyIf { !(task.isKMP) && task.isPublishedLibrary }
+ }
+
+ val reportDependencyAnalysisAdviceTask =
+ tasks.register(
+ "reportDependencyAnalysisAdvice",
+ ReportDependencyAnalysisAdviceTask::class.java,
+ ) { task ->
+ task.baseLineFile.set(layout.projectDirectory.file("dependencyAnalysis-baseline.json"))
+ task.cacheEvenIfNoOutputs()
+ // DAGP currently doesn't support KMP, enable KMP projects when b/394970486 is resolved
+ task.onlyIf { !(task.isKMP) && task.isPublishedLibrary }
+ }
+
+ val dependencyAnalysisSubExtension =
+ extensions.getByType(com.autonomousapps.DependencyAnalysisSubExtension::class.java)
+ dependencyAnalysisSubExtension.registerPostProcessingTask(reportDependencyAnalysisAdviceTask)
+ dependencyAnalysisSubExtension.registerPostProcessingTask(updateDependencyAnalysisBaselineTask)
+
+ // Ignore advice for runTimeOnly, compileOnly or incorrect dependency configs
+ // since it affects downstream consumers
+ dependencyAnalysisSubExtension.issues { it.onIncorrectConfiguration { it.severity("ignore") } }
+ dependencyAnalysisSubExtension.issues { it.onRuntimeOnly { it.severity("ignore") } }
+ dependencyAnalysisSubExtension.issues { it.onCompileOnly { it.severity("ignore") } }
+
+ // DAGP currently doesn't support KMP, enable KMP projects when b/394970486 is resolved
+ // Enable CI check for published libraries
+ if (
+ multiplatformExtension == null &&
+ androidXExtension.type.get() == SoftwareType.PUBLISHED_LIBRARY
+ ) {
+ addToBuildOnServer(reportDependencyAnalysisAdviceTask)
+ }
+}
+
+/**
+ * Helper data classes to store the advice provided Dependency Analysis Gradle plugin in baselines.
+ */
+internal data class AndroidxProjectAdvice(
+ val projectPath: String,
+ val dependencyAdvice: List,
+)
+
+internal data class DependencyAdvice(
+ val coordinates: Coordinates,
+ val fromConfiguration: String?,
+ val toConfiguration: String?,
+)
+
+internal data class Coordinates(
+ val type: String,
+ val identifier: String,
+ val resolvedVersion: String?,
+)
+
+/** Convert advice reported by DAGP into format suitable for storing in baselines. */
+internal fun ProjectAdvice.toAndroidxProjectAdvice(): AndroidxProjectAdvice {
+ return AndroidxProjectAdvice(
+ projectPath = projectPath,
+ dependencyAdvice =
+ dependencyAdvice.map {
+ val type =
+ if (it.coordinates is ProjectCoordinates) {
+ "project"
+ } else {
+ "module"
+ }
+ val resolvedVersion =
+ if (it.coordinates is ModuleCoordinates) {
+ (it.coordinates as ModuleCoordinates).resolvedVersion
+ } else {
+ null
+ }
+ DependencyAdvice(
+ coordinates =
+ Coordinates(
+ identifier = it.coordinates.identifier,
+ resolvedVersion = resolvedVersion,
+ type = type,
+ ),
+ fromConfiguration = it.fromConfiguration,
+ toConfiguration = it.toConfiguration,
+ )
+ },
+ )
+}
diff --git a/buildSrc-fork/private/src/main/kotlin/androidx/build/DevelocityTokenFetcher.kt b/buildSrc-fork/private/src/main/kotlin/androidx/build/DevelocityTokenFetcher.kt
new file mode 100644
index 0000000000000..562129865adf0
--- /dev/null
+++ b/buildSrc-fork/private/src/main/kotlin/androidx/build/DevelocityTokenFetcher.kt
@@ -0,0 +1,73 @@
+/*
+ * Copyright 2025 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package androidx.build
+
+import com.google.cloud.secretmanager.v1.SecretManagerServiceClient
+import com.google.cloud.secretmanager.v1.SecretVersionName
+import java.io.File
+import org.gradle.api.Project
+import org.gradle.api.provider.ValueSource
+import org.gradle.api.provider.ValueSourceParameters
+
+/**
+ * If the user hasn't set up develocity on this machine then fetch a shared key to enable it for
+ * them.
+ */
+internal fun Project.fetchDevelocityKeysIfNeeded() {
+ // Playground users don't need Develocity set up
+ if (ProjectLayoutType.isPlayground(this)) return
+
+ // We are in CI, so we should not fetch these keys
+ if (System.getenv("IS_ANDROIDX_CI") != null) return
+
+ // User does not have remote cache enabled, so we will not have access to GCP
+ if (System.getenv("USE_ANDROIDX_REMOTE_BUILD_CACHE") !in setOf("gcp", "true")) return
+
+ val keys = File("${System.getenv("GRADLE_USER_HOME")}/develocity/keys.properties")
+
+ // User already has the keys
+ if (keys.exists()) return
+
+ keys.parentFile.mkdirs()
+
+ val keysProvider = providers.of(DevelocityKeysValueSource::class.java) {}
+ keys.writeText(keysProvider.get())
+}
+
+/**
+ * Using a ValueSource to fetch Develocity keys because the SecretManagerServiceClient on Macs use
+ * external processes (such as codesign and install_name_tool) and that is not allowed when
+ * configuration cache is enabled without wrapping those calls in a ValueSource.
+ */
+internal abstract class DevelocityKeysValueSource :
+ ValueSource {
+ override fun obtain(): String? {
+ var value: String? = null
+ try {
+ SecretManagerServiceClient.create().use { manager ->
+ val secretVersionName =
+ SecretVersionName.of("androidx-ge", "develocity-token", "latest")
+ val response = manager.accessSecretVersion(secretVersionName)
+ value = response.payload.data.toStringUtf8()
+ }
+ } catch (e: Exception) {
+ println("Failed to fetch develocity keys")
+ e.printStackTrace()
+ }
+ return value
+ }
+}
diff --git a/buildSrc-fork/private/src/main/kotlin/androidx/build/ErrorProneConfiguration.kt b/buildSrc-fork/private/src/main/kotlin/androidx/build/ErrorProneConfiguration.kt
new file mode 100644
index 0000000000000..19c4ab840900f
--- /dev/null
+++ b/buildSrc-fork/private/src/main/kotlin/androidx/build/ErrorProneConfiguration.kt
@@ -0,0 +1,323 @@
+/*
+ * Copyright 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package androidx.build
+
+import com.android.build.api.variant.AndroidComponentsExtension
+import org.gradle.api.Project
+import org.gradle.api.artifacts.Configuration
+import org.gradle.api.logging.Logging
+import org.gradle.api.plugins.JavaPlugin.COMPILE_JAVA_TASK_NAME
+import org.gradle.api.provider.Provider
+import org.gradle.api.tasks.Input
+import org.gradle.api.tasks.SourceSetContainer
+import org.gradle.api.tasks.TaskProvider
+import org.gradle.api.tasks.compile.JavaCompile
+import org.gradle.kotlin.dsl.exclude
+import org.gradle.kotlin.dsl.get
+import org.gradle.kotlin.dsl.getByName
+import org.gradle.process.CommandLineArgumentProvider
+import org.jetbrains.kotlin.gradle.plugin.KotlinCompilation
+
+const val ERROR_PRONE_TASK = "runErrorProne"
+
+private const val ERROR_PRONE_CONFIGURATION = "errorprone"
+private val log = Logging.getLogger("ErrorProneConfiguration")
+
+fun Project.configureErrorProneForJava() {
+ val errorProneConfiguration = createErrorProneConfiguration()
+ project.extensions.getByName("sourceSets").configureEach {
+ project.configurations[it.annotationProcessorConfigurationName].extendsFrom(
+ errorProneConfiguration
+ )
+ }
+ val kmpExtension = project.multiplatformExtension
+ log.info("Configuring error-prone for ${project.path}")
+ if (kmpExtension != null) { // KMP project
+ val compileJavaTaskProvider =
+ kmpExtension
+ .jvm()
+ .compilations
+ .getByName(KotlinCompilation.MAIN_COMPILATION_NAME)
+ .compileJavaTaskProvider
+ makeErrorProneTask(compileJavaTaskProvider)
+ } else { // non-KMP project
+ makeErrorProneTask(tasks.withType(JavaCompile::class.java).named(COMPILE_JAVA_TASK_NAME))
+ }
+}
+
+fun Project.configureErrorProneForAndroid() {
+ val androidComponents = extensions.findByType(AndroidComponentsExtension::class.java)
+ androidComponents?.onVariants { variant ->
+ if (variant.buildType == "release") {
+ @Suppress("UnstableApiUsage", "USELESS_ELVIS")
+ // b/397707182 this is still @Incubating in AGP
+ // b/328749039 This is being made nullable in AGP
+ val javaCompilation = variant.javaCompilation ?: return@onVariants
+ val errorProneConfiguration = createErrorProneConfiguration()
+ configurations
+ .getByName(variant.annotationProcessorConfiguration.name)
+ .extendsFrom(errorProneConfiguration)
+
+ log.info("Configuring error-prone for ${variant.name}'s java compile")
+ afterEvaluate {
+ makeErrorProneTask(
+ compileTaskProvider =
+ tasks
+ .withType(JavaCompile::class.java)
+ .named("compile${variant.name.camelCase()}JavaWithJavac"),
+ taskSuffix = variant.name.camelCase(),
+ ) { javaCompile ->
+ @Suppress("UnstableApiUsage") // JavaCompilation b/397707182
+ val annotationArgs = javaCompilation.annotationProcessor.arguments
+ javaCompile.options.compilerArgumentProviders.add(
+ CommandLineArgumentProviderAdapter(annotationArgs)
+ )
+ }
+ }
+ }
+ }
+}
+
+class CommandLineArgumentProviderAdapter(@get:Input val arguments: Provider>) :
+ CommandLineArgumentProvider {
+ override fun asArguments(): MutableIterable {
+ return mutableListOf().also {
+ for ((key, value) in arguments.get()) {
+ it.add("-A$key=$value")
+ }
+ }
+ }
+}
+
+private fun Project.createErrorProneConfiguration(): Configuration =
+ configurations.findByName(ERROR_PRONE_CONFIGURATION)
+ ?: configurations.create(ERROR_PRONE_CONFIGURATION).apply {
+ isCanBeConsumed = false
+ isCanBeResolved = true
+ exclude(group = "com.google.errorprone", module = "javac")
+ project.dependencies.add(ERROR_PRONE_CONFIGURATION, getLibraryByName("errorProne"))
+ }
+
+// Given an existing JavaCompile task, reconfigures the task to use the ErrorProne compiler plugin
+private fun JavaCompile.configureWithErrorProne() {
+ options.isFork = true
+ options.forkOptions.jvmArgs!!.addAll(
+ listOf(
+ "--add-exports=jdk.compiler/com.sun.tools.javac.api=ALL-UNNAMED",
+ "--add-exports=jdk.compiler/com.sun.tools.javac.file=ALL-UNNAMED",
+ "--add-exports=jdk.compiler/com.sun.tools.javac.main=ALL-UNNAMED",
+ "--add-exports=jdk.compiler/com.sun.tools.javac.model=ALL-UNNAMED",
+ "--add-exports=jdk.compiler/com.sun.tools.javac.parser=ALL-UNNAMED",
+ "--add-exports=jdk.compiler/com.sun.tools.javac.processing=ALL-UNNAMED",
+ "--add-exports=jdk.compiler/com.sun.tools.javac.tree=ALL-UNNAMED",
+ "--add-exports=jdk.compiler/com.sun.tools.javac.util=ALL-UNNAMED",
+ "--add-opens=jdk.compiler/com.sun.tools.javac.code=ALL-UNNAMED",
+ "--add-opens=jdk.compiler/com.sun.tools.javac.comp=ALL-UNNAMED",
+ )
+ )
+ val compilerArgs = this.options.compilerArgs
+ compilerArgs +=
+ listOf(
+ "--should-stop=ifError=FLOW",
+ // Tell error-prone that we are running it on android compatible libraries
+ "-XDandroidCompatible=true",
+ "-XDcompilePolicy=simple", // Workaround for b/36098770
+ listOf(
+ "-Xplugin:ErrorProne",
+
+ // : Disables warnings in classes annotated with @Generated
+ "-XepDisableWarningsInGeneratedCode",
+
+ // Ignore intermediate build output, generated files, and external sources. Also
+ // sources
+ // imported from Android Studio and IntelliJ which are used in the lint-checks
+ // project.
+ "-XepExcludedPaths:.*/(build/generated|build/errorProne|external|" +
+ "compileTransaction/compile-output|" +
+ "lint-checks/src/main/java/androidx/com)/.*",
+
+ // Consider re-enabling the following checks. Disabled as part of
+ // error-prone upgrade
+ "-Xep:InlineMeSuggester:OFF",
+ "-Xep:NarrowCalculation:OFF",
+ "-Xep:LongDoubleConversion:OFF",
+ "-Xep:UnicodeEscape:OFF",
+ "-Xep:JavaUtilDate:OFF",
+ "-Xep:UnrecognisedJavadocTag:OFF",
+ "-Xep:ObjectEqualsForPrimitives:OFF",
+ "-Xep:DoNotCallSuggester:OFF",
+ "-Xep:EqualsNull:OFF",
+ "-Xep:MalformedInlineTag:OFF",
+ "-Xep:MissingSuperCall:OFF",
+ "-Xep:ToStringReturnsNull:OFF",
+ "-Xep:ReturnValueIgnored:OFF",
+ "-Xep:MissingImplementsComparable:OFF",
+ "-Xep:EmptyTopLevelDeclaration:OFF",
+ "-Xep:InvalidThrowsLink:OFF",
+ "-Xep:StaticAssignmentOfThrowable:OFF",
+ "-Xep:DoNotClaimAnnotations:OFF",
+ "-Xep:AlreadyChecked:OFF",
+ "-Xep:StringSplitter:OFF",
+ "-Xep:NonApiType:OFF",
+ "-Xep:StringCaseLocaleUsage:OFF",
+ "-Xep:LabelledBreakTarget:OFF",
+ "-Xep:Finalize:OFF",
+ "-Xep:AddressSelection:OFF",
+ "-Xep:StringCharset:OFF",
+ "-Xep:EnumOrdinal:OFF",
+ "-Xep:ClassInitializationDeadlock:OFF",
+ "-Xep:VoidUsed:OFF",
+ "-Xep:EffectivelyPrivate:OFF",
+ "-Xep:StatementSwitchToExpressionSwitch:OFF",
+ "-Xep:AssignmentExpression:OFF",
+ "-Xep:DuplicateBranches:OFF",
+ "-Xep:FormatStringShouldUsePlaceholders:OFF",
+ "-Xep:RedundantControlFlow:OFF",
+ "-Xep:CollectionUndefinedEquality:OFF",
+ "-Xep:JavaDurationGetSecondsToToSeconds:OFF",
+ "-Xep:BooleanLiteral:OFF",
+
+ // We allow inter library RestrictTo usage.
+ "-Xep:RestrictTo:OFF",
+
+ // Disable the following checks.
+ "-Xep:UnescapedEntity:OFF",
+ "-Xep:MissingSummary:OFF",
+ "-Xep:StaticAssignmentInConstructor:OFF",
+ "-Xep:InvalidLink:OFF",
+ "-Xep:InvalidInlineTag:OFF",
+ "-Xep:EmptyBlockTag:OFF",
+ "-Xep:EmptyCatch:OFF",
+ "-Xep:JdkObsolete:OFF",
+ "-Xep:PublicConstructorForAbstractClass:OFF",
+ "-Xep:MutablePublicArray:OFF",
+ "-Xep:NonCanonicalType:OFF",
+ "-Xep:ModifyCollectionInEnhancedForLoop:OFF",
+ "-Xep:InheritDoc:OFF",
+ "-Xep:InvalidParam:OFF",
+ "-Xep:InlineFormatString:OFF",
+ "-Xep:InvalidBlockTag:OFF",
+ "-Xep:ProtectedMembersInFinalClass:OFF",
+ "-Xep:SameNameButDifferent:OFF",
+ "-Xep:AnnotateFormatMethod:OFF",
+ "-Xep:ReturnFromVoid:OFF",
+ "-Xep:AlmostJavadoc:OFF",
+ "-Xep:InjectScopeAnnotationOnInterfaceOrAbstractClass:OFF",
+ "-Xep:InvalidThrows:OFF",
+
+ // Disable checks which are already enforced by lint.
+ "-Xep:PrivateConstructorForUtilityClass:OFF",
+
+ // Enforce the following checks.
+ "-Xep:JavaTimeDefaultTimeZone:ERROR",
+ "-Xep:ParameterNotNullable:ERROR",
+ "-Xep:MissingOverride:ERROR",
+ "-Xep:EqualsHashCode:ERROR",
+ "-Xep:NarrowingCompoundAssignment:ERROR",
+ "-Xep:ClassNewInstance:ERROR",
+ "-Xep:ClassCanBeStatic:ERROR",
+ "-Xep:SynchronizeOnNonFinalField:ERROR",
+ "-Xep:OperatorPrecedence:ERROR",
+ "-Xep:IntLongMath:ERROR",
+ "-Xep:MissingFail:ERROR",
+ "-Xep:JavaLangClash:ERROR",
+ "-Xep:TypeParameterUnusedInFormals:ERROR",
+ // "-Xep:StringSplitter:ERROR", // disabled with upgrade to 2.14.0
+ "-Xep:ReferenceEquality:ERROR",
+ "-Xep:AssertionFailureIgnored:ERROR",
+ "-Xep:UnnecessaryParentheses:ERROR",
+ "-Xep:EqualsGetClass:ERROR",
+ "-Xep:UnusedVariable:ERROR",
+ "-Xep:UnusedMethod:ERROR",
+ "-Xep:UndefinedEquals:ERROR",
+ "-Xep:ThreadLocalUsage:ERROR",
+ "-Xep:FutureReturnValueIgnored:ERROR",
+ "-Xep:ArgumentSelectionDefectChecker:ERROR",
+ "-Xep:HidingField:ERROR",
+ "-Xep:UnsynchronizedOverridesSynchronized:ERROR",
+ "-Xep:Finally:ERROR",
+ "-Xep:ThreadPriorityCheck:ERROR",
+ "-Xep:AutoValueFinalMethods:ERROR",
+ "-Xep:ImmutableEnumChecker:ERROR",
+ "-Xep:UnsafeReflectiveConstructionCast:ERROR",
+ "-Xep:LockNotBeforeTry:ERROR",
+ "-Xep:DoubleCheckedLocking:ERROR",
+ "-Xep:InconsistentCapitalization:ERROR",
+ "-Xep:ModifiedButNotUsed:ERROR",
+ "-Xep:AmbiguousMethodReference:ERROR",
+ "-Xep:EqualsIncompatibleType:ERROR",
+ "-Xep:ParameterName:ERROR",
+ "-Xep:RxReturnValueIgnored:ERROR",
+ "-Xep:BadImport:ERROR",
+ "-Xep:MissingCasesInEnumSwitch:ERROR",
+ "-Xep:ObjectToString:ERROR",
+ "-Xep:CatchAndPrintStackTrace:ERROR",
+ "-Xep:MixedMutabilityReturnType:ERROR",
+
+ // Enforce checks related to nullness annotation usage
+ "-Xep:NullablePrimitiveArray:ERROR",
+ "-Xep:MultipleNullnessAnnotations:ERROR",
+ "-Xep:NullablePrimitive:ERROR",
+ "-Xep:NullableVoid:ERROR",
+ "-Xep:NullableWildcard:ERROR",
+ "-Xep:NullableTypeParameter:ERROR",
+ "-Xep:NullableConstructor:ERROR",
+
+ // Nullaway
+ "-XepIgnoreUnknownCheckNames", // https://github.com/uber/NullAway/issues/25
+ "-Xep:NullAway:ERROR",
+ "-XepOpt:NullAway:AnnotatedPackages=android.arch,android.support,androidx",
+ )
+ .joinToString(" "),
+ )
+}
+
+/**
+ * Given a [JavaCompile] task, creates a task that runs the ErrorProne compiler with the same
+ * settings.
+ *
+ * @param onConfigure optional callback which lazily evaluates on task configuration. Use this to do
+ * any additional configuration such as overriding default settings.
+ */
+private fun Project.makeErrorProneTask(
+ compileTaskProvider: TaskProvider?,
+ taskSuffix: String = "",
+ onConfigure: (errorProneTask: JavaCompile) -> Unit = {},
+) = afterEvaluate {
+ val compileTaskProviderExists = provider { compileTaskProvider != null }
+ val errorProneTaskProvider =
+ tasks.register("$ERROR_PRONE_TASK$taskSuffix", JavaCompile::class.java) {
+ it.onlyIf { compileTaskProviderExists.get() }
+ val compileTask = compileTaskProvider?.get() ?: return@register
+ it.group = "Build"
+ it.description = "Compile this project's Java code with Error-prone compiler"
+ it.classpath = compileTask.classpath
+ it.source = compileTask.source
+ it.destinationDirectory.set(layout.buildDirectory.dir("errorProne/$taskSuffix"))
+ it.options.compilerArgs = compileTask.options.compilerArgs.toMutableList()
+ it.options.annotationProcessorPath = compileTask.options.annotationProcessorPath
+ it.options.bootstrapClasspath = compileTask.options.bootstrapClasspath
+ it.sourceCompatibility = compileTask.sourceCompatibility
+ it.targetCompatibility = compileTask.targetCompatibility
+ it.configureWithErrorProne()
+ it.dependsOn(compileTask.dependsOn)
+
+ onConfigure(it)
+ }
+ addToCheckTask(errorProneTaskProvider)
+ addToBuildOnServer(errorProneTaskProvider)
+}
diff --git a/buildSrc-fork/private/src/main/kotlin/androidx/build/FilteredAnchorTask.kt b/buildSrc-fork/private/src/main/kotlin/androidx/build/FilteredAnchorTask.kt
new file mode 100644
index 0000000000000..73aca8299419d
--- /dev/null
+++ b/buildSrc-fork/private/src/main/kotlin/androidx/build/FilteredAnchorTask.kt
@@ -0,0 +1,110 @@
+/*
+ * Copyright 2023 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package androidx.build
+
+import androidx.build.FilteredAnchorTask.Companion.GLOBAL_TASK_NAME
+import androidx.build.FilteredAnchorTask.Companion.PROP_PATH_PREFIX
+import androidx.build.FilteredAnchorTask.Companion.PROP_TASK_NAME
+import org.gradle.api.DefaultTask
+import org.gradle.api.GradleException
+import org.gradle.api.Project
+import org.gradle.api.tasks.Input
+import org.gradle.api.tasks.TaskAction
+import org.gradle.api.tasks.TaskProvider
+import org.gradle.work.DisableCachingByDefault
+
+@DisableCachingByDefault(because = "This is an anchor task that does no work.")
+abstract class FilteredAnchorTask : DefaultTask() {
+ init {
+ group = "Help"
+ description =
+ "Runs tasks with a name specified by -P$PROP_TASK_NAME= for projects with " +
+ "a path prefix specified by -P$PROP_PATH_PREFIX="
+ }
+
+ @get:Input abstract var pathPrefix: String
+
+ @get:Input abstract var taskName: String
+
+ @TaskAction
+ fun exec() {
+ if (dependsOn.isEmpty()) {
+ throw GradleException(
+ "Failed to find any filterable tasks with name \"$taskName\" " +
+ "and path prefixed with \"$pathPrefix\""
+ )
+ }
+ }
+
+ companion object {
+ const val GLOBAL_TASK_NAME = "filterTasks"
+ const val PROP_PATH_PREFIX = "androidx.pathPrefix"
+ const val PROP_TASK_NAME = "androidx.taskName"
+ }
+}
+
+/**
+ * Offers the specified [taskProviders] to the global [FilteredAnchorTask], adding them if they
+ * match the requested path prefix and task name.
+ */
+internal fun Project.addFilterableTasks(vararg taskProviders: TaskProvider<*>?) {
+ if (
+ providers.gradleProperty(PROP_PATH_PREFIX).isPresent &&
+ providers.gradleProperty(PROP_TASK_NAME).isPresent
+ ) {
+ val pathPrefixes = (properties[PROP_PATH_PREFIX] as String).split(",")
+ if (pathPrefixes.any { pathPrefix -> relativePathForFiltering().startsWith(pathPrefix) }) {
+ val taskName = properties[PROP_TASK_NAME] as String
+ taskProviders
+ .find { taskProvider -> taskName == taskProvider?.name }
+ ?.let { taskProvider ->
+ rootProject.tasks.named(GLOBAL_TASK_NAME).configure { task ->
+ task.dependsOn(taskProvider)
+ }
+ }
+ }
+ }
+}
+
+/**
+ * Registers the global [FilteredAnchorTask] if the required command-line properties are set.
+ *
+ * For example, to run `checkApi` for all projects under `core/core/`: ./gradlew filterTasks
+ * -Pandroidx.taskName=checkApi -Pandroidx.pathPrefix=core/core/
+ */
+internal fun Project.maybeRegisterFilterableTask() {
+ if (
+ providers.gradleProperty(PROP_TASK_NAME).isPresent &&
+ providers.gradleProperty(PROP_PATH_PREFIX).isPresent
+ ) {
+ tasks.register(GLOBAL_TASK_NAME, FilteredAnchorTask::class.java) { task ->
+ task.pathPrefix = properties[PROP_PATH_PREFIX] as String
+ task.taskName = properties[PROP_TASK_NAME] as String
+ }
+ }
+}
+
+/**
+ * Returns an AndroidX-relative path for the [Project], inserting the root project directory when
+ * run in a Playground context such that paths are consistent with the AndroidX context.
+ */
+internal fun Project.relativePathForFiltering(): String =
+ if (ProjectLayoutType.isPlayground(project)) {
+ "${projectDir.relativeTo(getSupportRootFolder())}/"
+ } else {
+ "${projectDir.relativeTo(rootDir)}/"
+ }
diff --git a/buildSrc-fork/private/src/main/kotlin/androidx/build/FtlRunner.kt b/buildSrc-fork/private/src/main/kotlin/androidx/build/FtlRunner.kt
new file mode 100644
index 0000000000000..fe60ce9da74c8
--- /dev/null
+++ b/buildSrc-fork/private/src/main/kotlin/androidx/build/FtlRunner.kt
@@ -0,0 +1,333 @@
+/*
+ * Copyright 2023 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package androidx.build
+
+import com.android.build.api.artifact.Artifacts
+import com.android.build.api.artifact.SingleArtifact
+import com.android.build.api.variant.AndroidComponentsExtension
+import com.android.build.api.variant.ApplicationAndroidComponentsExtension
+import com.android.build.api.variant.BuiltArtifactsLoader
+import com.android.build.api.variant.HasDeviceTests
+import javax.inject.Inject
+import org.gradle.api.DefaultTask
+import org.gradle.api.Project
+import org.gradle.api.file.DirectoryProperty
+import org.gradle.api.provider.ListProperty
+import org.gradle.api.provider.Property
+import org.gradle.api.provider.Provider
+import org.gradle.api.tasks.Input
+import org.gradle.api.tasks.InputFiles
+import org.gradle.api.tasks.Internal
+import org.gradle.api.tasks.Optional
+import org.gradle.api.tasks.PathSensitive
+import org.gradle.api.tasks.PathSensitivity
+import org.gradle.api.tasks.TaskAction
+import org.gradle.api.tasks.options.Option
+import org.gradle.kotlin.dsl.getByType
+import org.gradle.process.ExecOperations
+import org.gradle.process.ExecSpec
+import org.gradle.work.DisableCachingByDefault
+
+@DisableCachingByDefault(because = "Expected to rerun every time")
+abstract class FtlRunner : DefaultTask() {
+ init {
+ group = "Verification"
+ description = "Runs devices tests in Firebase Test Lab filtered by --className"
+ }
+
+ @get:Inject abstract val execOperations: ExecOperations
+
+ @get:InputFiles
+ @get:PathSensitive(PathSensitivity.RELATIVE)
+ abstract val testFolder: DirectoryProperty
+
+ @get:Internal abstract val testLoader: Property
+
+ @get:InputFiles
+ @get:PathSensitive(PathSensitivity.RELATIVE)
+ @get:Optional
+ abstract val appFolder: DirectoryProperty
+
+ @get:Internal abstract val appLoader: Property
+
+ @get:Input abstract val apkPackageName: Property
+
+ @get:Optional
+ @get:Input
+ @get:Option(option = "className", description = "Fully qualified class name of a class to run")
+ abstract val className: Property
+
+ @get:Optional
+ @get:Input
+ @get:Option(option = "packageName", description = "Package name test classes to run")
+ abstract val packageName: Property
+
+ @get:Optional
+ @get:Input
+ @get:Option(option = "pullScreenshots", description = "true if screenshots should be pulled")
+ abstract val pullScreenshots: Property
+
+ @get:Optional
+ @get:Input
+ @get:Option(option = "testTimeout", description = "timeout to pass to FTL test runner")
+ abstract val testTimeout: Property
+
+ @get:Optional
+ @get:Input
+ @get:Option(
+ option = "instrumentationArgs",
+ description = "instrumentation arguments to pass to FTL test runner",
+ )
+ abstract val instrumentationArgs: Property
+
+ @get:Optional
+ @get:Input
+ @get:Option(
+ option = "api",
+ description =
+ "repeatable argument for which apis to run ftl tests on. " +
+ "Only relevant to $FTL_ON_APIS_NAME. Can be 23, 26, 28, 30, 33, 34, 35.",
+ )
+ abstract val apis: ListProperty
+
+ @get:Optional
+ @get:Input
+ @get:Option(
+ option = "shardCount",
+ description = "Number of shards to split tests into (requires gcloud beta)",
+ )
+ abstract val shardCount: Property
+
+ @get:Optional
+ @get:Input
+ @get:Option(
+ option = "excludeAnnotation",
+ description =
+ "Repeatable argument to exclude annotations. " +
+ "Example: `--excludeAnnotation androidx.test.filters.FlakyTest`",
+ )
+ abstract val excludeAnnotations: ListProperty
+
+ @get:Input abstract val device: ListProperty
+
+ @TaskAction
+ fun execThings() {
+ if (!System.getenv().containsKey("GOOGLE_APPLICATION_CREDENTIALS")) {
+ throw Exception(
+ "Running tests in FTL requires credentials, you have not set up " +
+ "GOOGLE_APPLICATION_CREDENTIALS, follow go/androidx-dev#remote-build-cache"
+ )
+ }
+ val testApk =
+ testLoader.get().load(testFolder.get())
+ ?: throw RuntimeException("Cannot load required APK for task: $name")
+ val testApkPath = testApk.elements.single().outputFile
+ val appApkPath =
+ if (appLoader.isPresent) {
+ val appApk =
+ appLoader.get().load(appFolder.get())
+ ?: throw RuntimeException("Cannot load required APK for task: $name")
+ appApk.elements.single().outputFile
+ } else {
+ "gs://androidx-ftl-test-results/github-ci-action/placeholderApp/" +
+ "d345c82828c355acc1432535153cf1dcf456e559c26f735346bf5f38859e0512.apk"
+ }
+ try {
+ execOperations.printCommandAndExec { it.commandLine("gcloud", "--version") }
+ } catch (_: Exception) {
+ throw Exception(
+ "Missing gcloud, please follow go/androidx-dev#remote-build-cache to set it up"
+ )
+ }
+
+ val filterList = buildList {
+ if (className.isPresent) add("class ${className.get()}")
+ if (packageName.isPresent) add("package ${packageName.get()}")
+ if (excludeAnnotations.isPresent) {
+ addAll(excludeAnnotations.get().map { "notAnnotation $it" })
+ }
+ }
+ val hasFilters = filterList.isNotEmpty()
+ val filters = filterList.joinToString(separator = ",")
+
+ val shouldPull = pullScreenshots.isPresent && pullScreenshots.get() == "true"
+
+ val needsBeta = shardCount.isPresent
+ execOperations.printCommandAndExec {
+ it.commandLine(
+ listOfNotNull(
+ "gcloud",
+ if (needsBeta) "beta" else null,
+ "--project",
+ "androidx-dev-prod",
+ "firebase",
+ "test",
+ "android",
+ "run",
+ "--type",
+ "instrumentation",
+ "--no-performance-metrics",
+ "--no-auto-google-login",
+ "--app",
+ appApkPath,
+ "--test",
+ testApkPath,
+ "--results-bucket=androidx-dev-prod-test-results",
+ if (hasFilters) "--test-targets" else null,
+ if (hasFilters) filters else null,
+ if (shouldPull) "--directories-to-pull" else null,
+ if (shouldPull) {
+ "/sdcard/Android/data/${apkPackageName.get()}/cache/androidx_screenshots"
+ } else null,
+ if (testTimeout.isPresent) "--timeout" else null,
+ if (testTimeout.isPresent) testTimeout.get() else null,
+ if (shardCount.isPresent) "--num-uniform-shards" else null,
+ if (shardCount.isPresent) shardCount.get() else null,
+ if (instrumentationArgs.isPresent) "--environment-variables" else null,
+ if (instrumentationArgs.isPresent) instrumentationArgs.get() else null,
+ ) + getDeviceArguments()
+ )
+ }
+ }
+
+ private fun getDeviceArguments(): List {
+ val devices = device.get().ifEmpty { readApis() }
+ return devices.flatMap { listOf("--device", "model=$it,locale=en_US,orientation=portrait") }
+ }
+
+ private fun readApis(): Collection {
+ val apis = apis.get()
+ if (apis.isEmpty()) {
+ throw RuntimeException("--api must be specified when using $FTL_ON_APIS_NAME.")
+ }
+
+ val apisWithoutModels = apis.filter { it !in API_TO_MODEL_MAP }
+ if (apisWithoutModels.isNotEmpty()) {
+ throw RuntimeException("Unknown apis specified: ${apisWithoutModels.joinToString()}")
+ }
+
+ return apis.map { API_TO_MODEL_MAP[it]!! }
+ }
+}
+
+private const val NEXUS_6P = "Nexus6P,version=27"
+private const val A10 = "a10,version=29"
+private const val PETTYL = "pettyl,version=27"
+private const val HWCOR = "HWCOR,version=27"
+private const val Q2Q = "q2q,version=31"
+
+private const val PHYSICAL_PIXEL9 = "tokay,version=34"
+private const val MEDIUM_PHONE_36 = "MediumPhone.arm,version=36"
+private const val MEDIUM_PHONE_35 = "MediumPhone.arm,version=35"
+private const val MEDIUM_PHONE_34 = "MediumPhone.arm,version=34"
+private const val MEDIUM_PHONE_33 = "MediumPhone.arm,version=33"
+private const val MEDIUM_PHONE_30 = "MediumPhone.arm,version=30"
+private const val MEDIUM_PHONE_28 = "MediumPhone.arm,version=28"
+private const val MEDIUM_PHONE_26 = "MediumPhone.arm,version=26"
+private const val NEXUS5_23 = "Nexus5.gce_x86,version=23"
+private const val PIXEL2_33 = "Pixel2.arm,version=33"
+private const val PIXEL2_30 = "Pixel2.arm,version=30"
+private const val PIXEL2_28 = "Pixel2.arm,version=28"
+private const val PIXEL2_26 = "Pixel2.arm,version=26"
+
+private val API_TO_MODEL_MAP =
+ mapOf(
+ 36 to MEDIUM_PHONE_36,
+ 35 to MEDIUM_PHONE_35,
+ 34 to MEDIUM_PHONE_34,
+ 33 to MEDIUM_PHONE_33,
+ 30 to MEDIUM_PHONE_30,
+ 28 to MEDIUM_PHONE_28,
+ 26 to MEDIUM_PHONE_26,
+ 23 to NEXUS5_23,
+ )
+
+private const val FTL_ON_APIS_NAME = "ftlOnApis"
+private val devicesToRunOn =
+ listOf(
+ FTL_ON_APIS_NAME to listOf(), // instead read devices via repeatable --api
+ "ftlphysicalpixel9api34" to listOf(PHYSICAL_PIXEL9),
+ "ftlmediumphoneapi36" to listOf(MEDIUM_PHONE_36),
+ "ftlmediumphoneapi35" to listOf(MEDIUM_PHONE_35),
+ "ftlmediumphoneapi34" to listOf(MEDIUM_PHONE_34),
+ "ftlmediumphoneapi33" to listOf(MEDIUM_PHONE_33),
+ "ftlmediumphoneapi30" to listOf(MEDIUM_PHONE_30),
+ "ftlmediumphoneapi28" to listOf(MEDIUM_PHONE_28),
+ "ftlmediumphoneapi26" to listOf(MEDIUM_PHONE_26),
+ "ftlnexus5api23" to listOf(NEXUS5_23),
+ "ftlCoreTelecomDeviceSet" to listOf(NEXUS_6P, A10, PETTYL, HWCOR, Q2Q),
+ "ftlpixel2api33" to listOf(PIXEL2_33),
+ "ftlpixel2api30" to listOf(PIXEL2_30),
+ "ftlpixel2api28" to listOf(PIXEL2_28),
+ "ftlpixel2api26" to listOf(PIXEL2_26),
+ )
+
+internal fun Project.registerRunner(
+ name: String,
+ artifacts: Artifacts,
+ namespace: Provider,
+) {
+ devicesToRunOn.forEach { (taskPrefix, model) ->
+ tasks.register("$taskPrefix$name", FtlRunner::class.java) { task ->
+ task.device.set(model)
+ task.apkPackageName.set(namespace)
+ task.testFolder.set(artifacts.get(SingleArtifact.APK))
+ task.testLoader.set(artifacts.getBuiltArtifactsLoader())
+ }
+ }
+}
+
+fun Project.configureFtlRunner(androidComponentsExtension: AndroidComponentsExtension<*, *, *>) {
+ androidComponentsExtension.apply {
+ onVariants { variant ->
+ when {
+ variant is HasDeviceTests -> {
+ variant.deviceTests.forEach { (_, deviceTest) ->
+ registerRunner(deviceTest.name, deviceTest.artifacts, deviceTest.namespace)
+ }
+ }
+ project.plugins.hasPlugin("com.android.test") -> {
+ registerRunner(variant.name, variant.artifacts, variant.namespace)
+ }
+ }
+ }
+ }
+}
+
+fun Project.addAppApkToFtlRunner() {
+ extensions.getByType().apply {
+ onVariants(selector().withBuildType("debug")) { appVariant ->
+ devicesToRunOn.forEach { (taskPrefix, _) ->
+ tasks.named("$taskPrefix${appVariant.name}AndroidTest") { configTask ->
+ configTask as FtlRunner
+ configTask.appFolder.set(appVariant.artifacts.get(SingleArtifact.APK))
+ configTask.appLoader.set(appVariant.artifacts.getBuiltArtifactsLoader())
+ }
+ }
+ }
+ }
+}
+
+private fun ExecOperations.printCommandAndExec(action: (ExecSpec) -> Unit) {
+ exec { spec ->
+ action(spec)
+
+ // Just approximating the command for user verification.
+ val commandLine = spec.commandLine.map { if (" " in it) "\"$it\"" else it }
+ println("Executing command: `${commandLine.joinToString(" ")}`")
+ }
+}
diff --git a/buildSrc-fork/private/src/main/kotlin/androidx/build/GradleTransformWorkaround.kt b/buildSrc-fork/private/src/main/kotlin/androidx/build/GradleTransformWorkaround.kt
new file mode 100644
index 0000000000000..73ea330cd483f
--- /dev/null
+++ b/buildSrc-fork/private/src/main/kotlin/androidx/build/GradleTransformWorkaround.kt
@@ -0,0 +1,72 @@
+/*
+ * Copyright 2022 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package androidx.build
+
+import androidx.build.gradle.isRoot
+import org.gradle.api.Project
+
+/**
+ * Creates a dependency substitution rule to workaround
+ * [a Gradle bug](https://github.com/gradle/gradle/issues/20778).
+ *
+ * The root cause of the bug is a mix of external and project coordinates existing simultaneously in
+ * the dependency graph. A Gradle optimization attempts to simplify/minimize this graph to allow
+ * artifact transforms to being executing as soon as possible, but the optimization was too
+ * aggressive in the Androidx case.
+ *
+ * This workaround creates a no-op/unmatching rule which invalidates the above optimization and
+ * prevents transformations from executing too eagerly.
+ *
+ * This is necessary for Gradle 7.5-rc-1, but should be fixed in Gradle 7.5.1 or 7.6, at which point
+ * this class can be removed.
+ */
+object GradleTransformWorkaround {
+ /**
+ * This function applies the [GradleTransformWorkaround] to the given root project, if necessary
+ * (if it includes lifecycle-common).
+ *
+ * @param rootProject The root project whose sub-projects will be updated with the workaround.
+ */
+ fun maybeApply(rootProject: Project) {
+ check(rootProject.isRoot) {
+ """
+ GradleTransformWorkaround must be invoked with the root project
+ because it needs to be applied to all sub-projects.
+ """
+ .trimIndent()
+ }
+ rootProject.subprojects { subProject ->
+ if (subProject.path == ":lifecycle:lifecycle-common") {
+ rootProject.subprojects { it.applyArtifactTransformWorkaround() }
+ }
+ }
+ }
+
+ private fun Project.applyArtifactTransformWorkaround() {
+ this.configurations.configureEach { c ->
+ c.resolutionStrategy.dependencySubstitution { selector ->
+ selector
+ .substitute(selector.module("unmatched:unmatched"))
+ .using(selector.project(":lifecycle:lifecycle-common"))
+ .because(
+ "workaround gradle/gradle#20778 with intentionally unmatching " +
+ "substitution rule"
+ )
+ }
+ }
+ }
+}
diff --git a/buildSrc-fork/private/src/main/kotlin/androidx/build/JavaFormat.kt b/buildSrc-fork/private/src/main/kotlin/androidx/build/JavaFormat.kt
new file mode 100644
index 0000000000000..c8107a2aad686
--- /dev/null
+++ b/buildSrc-fork/private/src/main/kotlin/androidx/build/JavaFormat.kt
@@ -0,0 +1,104 @@
+/*
+ * Copyright 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package androidx.build
+
+import javax.inject.Inject
+import org.gradle.api.DefaultTask
+import org.gradle.api.Project
+import org.gradle.api.file.ConfigurableFileCollection
+import org.gradle.api.file.FileTree
+import org.gradle.api.model.ObjectFactory
+import org.gradle.api.tasks.CacheableTask
+import org.gradle.api.tasks.Classpath
+import org.gradle.api.tasks.IgnoreEmptyDirectories
+import org.gradle.api.tasks.Input
+import org.gradle.api.tasks.InputFiles
+import org.gradle.api.tasks.OutputFiles
+import org.gradle.api.tasks.PathSensitive
+import org.gradle.api.tasks.PathSensitivity
+import org.gradle.api.tasks.SkipWhenEmpty
+import org.gradle.api.tasks.TaskAction
+import org.gradle.api.tasks.options.Option
+import org.gradle.process.ExecOperations
+
+fun Project.configureJavaFormat() {
+ tasks.register("javaFormat", JavaFormatTask::class.java) { task ->
+ task.javaFormatClasspath.from(getLibraryClasspath("googlejavaformat"))
+ }
+}
+
+@CacheableTask
+abstract class JavaFormatTask : DefaultTask() {
+ init {
+ description = "Fix Java code style deviations."
+ group = "formatting"
+ }
+
+ @get:Input
+ @set:Option(option = "fix-imports-only", description = "Only correct imports")
+ var importsOnly: Boolean = false
+
+ @get:Inject abstract val execOperations: ExecOperations
+
+ @get:Classpath abstract val javaFormatClasspath: ConfigurableFileCollection
+
+ @get:Inject abstract val objects: ObjectFactory
+
+ @[InputFiles PathSensitive(PathSensitivity.RELATIVE) SkipWhenEmpty IgnoreEmptyDirectories]
+ open fun getInputFiles(): FileTree {
+ return objects.fileTree().setDir(INPUT_DIR).apply {
+ include(INCLUDED_FILES)
+ exclude(excludedDirectoryGlobs)
+ }
+ }
+
+ // Format task rewrites inputs, so the outputs are the same as inputs.
+ @OutputFiles fun getRewrittenFiles(): FileTree = getInputFiles()
+
+ private fun getArgsList(): List {
+ val arguments = mutableListOf("--aosp", "--replace")
+ if (importsOnly) arguments.add("--fix-imports-only")
+ arguments.addAll(getInputFiles().files.map { it.absolutePath })
+ return arguments
+ }
+
+ @TaskAction
+ fun runFormat() {
+ execOperations.javaexec { javaExecSpec ->
+ javaExecSpec.mainClass.set(MAIN_CLASS)
+ javaExecSpec.classpath = javaFormatClasspath
+ javaExecSpec.args = getArgsList()
+ javaExecSpec.jvmArgs(
+ "--add-exports=jdk.compiler/com.sun.tools.javac.api=ALL-UNNAMED",
+ "--add-exports=jdk.compiler/com.sun.tools.javac.code=ALL-UNNAMED",
+ "--add-exports=jdk.compiler/com.sun.tools.javac.file=ALL-UNNAMED",
+ "--add-exports=jdk.compiler/com.sun.tools.javac.parser=ALL-UNNAMED",
+ "--add-exports=jdk.compiler/com.sun.tools.javac.tree=ALL-UNNAMED",
+ "--add-exports=jdk.compiler/com.sun.tools.javac.util=ALL-UNNAMED",
+ )
+ }
+ }
+
+ companion object {
+ private val excludedDirectories = listOf("test-data", "external")
+
+ private val excludedDirectoryGlobs = excludedDirectories.map { "**/$it/**/*.java" }
+ private const val MAIN_CLASS = "com.google.googlejavaformat.java.Main"
+ private const val INPUT_DIR = "src"
+ private const val INCLUDED_FILES = "**/*.java"
+ }
+}
diff --git a/buildSrc-fork/private/src/main/kotlin/androidx/build/KonanPrebuiltsSetup.kt b/buildSrc-fork/private/src/main/kotlin/androidx/build/KonanPrebuiltsSetup.kt
new file mode 100644
index 0000000000000..6abf9d5567a76
--- /dev/null
+++ b/buildSrc-fork/private/src/main/kotlin/androidx/build/KonanPrebuiltsSetup.kt
@@ -0,0 +1,100 @@
+/*
+ * Copyright 2023 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package androidx.build
+
+import androidx.build.gradle.extraPropertyOrNull
+import java.io.File
+import org.gradle.api.Project
+import org.jetbrains.kotlin.gradle.tasks.CInteropProcess
+import org.jetbrains.kotlin.gradle.tasks.KotlinNativeCompile
+import org.jetbrains.kotlin.konan.target.Distribution
+
+/** Helper class to override Konan prebuilts directories to use local konan prebuilts. */
+object KonanPrebuiltsSetup {
+ /**
+ * Flag to notify we've updated the konan properties so that we can avoid re-doing it if
+ * [configureKonanDirectory] call comes from multiple code paths.
+ */
+ private const val DID_SETUP_KONAN_PROPERTIES_FLAG = "androidx.didSetupKonanProperties"
+
+ /**
+ * Flag that causes konan to run in a separate process whose working directory is the compiling
+ * project (i.e. frameworks/support/room3/room3-runtime) and not the root project
+ * (frameworks/support).
+ */
+ private const val DISABLE_COMPILER_DAEMON_FLAG = "kotlin.native.disableCompilerDaemon"
+
+ /**
+ * Creates a Konan distribution with the given [prebuiltsDirectory] and [konanHome].
+ *
+ * @param prebuiltsDirectory The directory where AndroidX prebuilts are present. Can be `null`
+ * for playground builds which means we'll fetch Kotlin Native prebuilts from the internet
+ * using the Kotlin Gradle Plugin.
+ */
+ fun createKonanDistribution(prebuiltsDirectory: File?, konanHome: File) =
+ Distribution(
+ konanHome = konanHome.canonicalPath,
+ onlyDefaultProfiles = false,
+ propertyOverrides =
+ prebuiltsDirectory?.let { mapOf("dependenciesUrl" to "file://${it.canonicalPath}") },
+ )
+
+ /** Returns `true` if the project's konan prebuilts is already configured. */
+ fun isConfigured(project: Project): Boolean {
+ return project.extensions.extraProperties.has(DID_SETUP_KONAN_PROPERTIES_FLAG)
+ }
+
+ /** Sets the konan distribution url to the prebuilts directory. */
+ fun configureKonanDirectory(project: Project) {
+ check(!isConfigured(project)) {
+ "Konan prebuilts directories for project ${project.path} are already configured"
+ }
+ if (ProjectLayoutType.isPlayground(project)) {
+ // playground does not use prebuilts
+ } else {
+ // set konan prebuilts download URLs to AndroidX prebuilts
+ project.overrideKotlinNativeDistributionUrlToLocalDirectory()
+ project.overrideKotlinNativeDependenciesUrlToLocalDirectory()
+ }
+ project.extensions.extraProperties.set(DID_SETUP_KONAN_PROPERTIES_FLAG, true)
+ }
+
+ private fun Project.overrideKotlinNativeDependenciesUrlToLocalDirectory() {
+ val compilerDaemonDisabled =
+ extraPropertyOrNull(DISABLE_COMPILER_DAEMON_FLAG)?.toString()?.toBoolean() == true
+ val konanPrebuiltsFolder = getKonanPrebuiltsFolder()
+ val rootBaseDir = if (compilerDaemonDisabled) projectDir else rootProject.projectDir
+ // use relative path so it doesn't affect gradle remote cache.
+ val relativeRootPath = konanPrebuiltsFolder.relativeTo(rootBaseDir).path
+ val relativeProjectPath = konanPrebuiltsFolder.relativeTo(projectDir).path
+ tasks.withType(KotlinNativeCompile::class.java).configureEach {
+ it.compilerOptions.freeCompilerArgs.add(
+ "-Xoverride-konan-properties=dependenciesUrl=file:$relativeRootPath"
+ )
+ }
+ tasks.withType(CInteropProcess::class.java).configureEach {
+ it.settings.extraOpts +=
+ listOf("-Xoverride-konan-properties", "dependenciesUrl=file:$relativeProjectPath")
+ }
+ }
+
+ private fun Project.overrideKotlinNativeDistributionUrlToLocalDirectory() {
+ val url =
+ "file:${getKonanPrebuiltsFolder().resolve("nativeCompilerPrebuilts").absolutePath}"
+ extensions.extraProperties["kotlin.native.distribution.baseDownloadUrl"] = url
+ }
+}
diff --git a/buildSrc-fork/private/src/main/kotlin/androidx/build/Ktfmt.kt b/buildSrc-fork/private/src/main/kotlin/androidx/build/Ktfmt.kt
new file mode 100644
index 0000000000000..146f6a78403b4
--- /dev/null
+++ b/buildSrc-fork/private/src/main/kotlin/androidx/build/Ktfmt.kt
@@ -0,0 +1,292 @@
+/*
+ * Copyright 2023 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package androidx.build
+
+import androidx.build.logging.TERMINAL_RED
+import androidx.build.logging.TERMINAL_RESET
+import androidx.build.uptodatedness.cacheEvenIfNoOutputs
+import java.io.ByteArrayOutputStream
+import java.io.File
+import java.nio.file.Paths
+import javax.inject.Inject
+import org.gradle.api.DefaultTask
+import org.gradle.api.Project
+import org.gradle.api.attributes.java.TargetJvmEnvironment
+import org.gradle.api.attributes.java.TargetJvmEnvironment.TARGET_JVM_ENVIRONMENT_ATTRIBUTE
+import org.gradle.api.file.ConfigurableFileCollection
+import org.gradle.api.file.FileCollection
+import org.gradle.api.file.FileTree
+import org.gradle.api.model.ObjectFactory
+import org.gradle.api.tasks.CacheableTask
+import org.gradle.api.tasks.Classpath
+import org.gradle.api.tasks.Input
+import org.gradle.api.tasks.InputFiles
+import org.gradle.api.tasks.Internal
+import org.gradle.api.tasks.OutputFiles
+import org.gradle.api.tasks.PathSensitive
+import org.gradle.api.tasks.PathSensitivity
+import org.gradle.api.tasks.SkipWhenEmpty
+import org.gradle.api.tasks.TaskAction
+import org.gradle.api.tasks.options.Option
+import org.gradle.kotlin.dsl.named
+import org.gradle.process.ExecOperations
+
+fun Project.configureKtfmt() {
+ val ktfmtClasspath = getKtfmtConfiguration()
+ tasks.register("ktFormat", KtfmtFormatTask::class.java) { task ->
+ task.ktfmtClasspath.from(ktfmtClasspath)
+ }
+
+ val ktCheckTask =
+ tasks.register("ktCheck", KtfmtCheckTask::class.java) { task ->
+ task.ktfmtClasspath.from(ktfmtClasspath)
+ task.cacheEvenIfNoOutputs()
+ }
+
+ // afterEvaluate because Gradle's default "check" task doesn't exist yet
+ afterEvaluate {
+ addToCheckTask(ktCheckTask)
+ addToBuildOnServer(ktCheckTask)
+ }
+}
+
+private val ExcludedDirectories = listOf("test-data", "external")
+
+private val ExcludedDirectoryGlobs = ExcludedDirectories.map { "**/$it/**/*.kt" }
+private const val MainClass = "com.facebook.ktfmt.cli.Main"
+private const val InputDir = "src"
+private const val IncludedFiles = "**/*.kt"
+
+private fun Project.getKtfmtConfiguration(): FileCollection {
+ val conf = configurations.detachedConfiguration(dependencies.create(getLibraryByName("ktfmt")))
+ conf.attributes {
+ it.attribute(
+ TARGET_JVM_ENVIRONMENT_ATTRIBUTE,
+ project.objects.named(TargetJvmEnvironment.STANDARD_JVM),
+ )
+ }
+ return conf.incoming.files
+}
+
+@CacheableTask
+abstract class BaseKtfmtTask : DefaultTask() {
+ @get:Inject abstract val execOperations: ExecOperations
+
+ @get:Classpath abstract val ktfmtClasspath: ConfigurableFileCollection
+
+ @get:Inject abstract val objects: ObjectFactory
+
+ @get:Internal val projectPath: String = project.path
+
+ @[InputFiles PathSensitive(PathSensitivity.RELATIVE) SkipWhenEmpty]
+ open fun getInputFiles(): FileTree {
+ val projectDirectory = overrideDirectory
+ val subdirectories = overrideSubdirectories
+ if (projectDirectory == null || subdirectories.isNullOrEmpty()) {
+ // If we have a valid override, use that as the default fileTree
+ return objects.fileTree().setDir(InputDir).apply {
+ include(IncludedFiles)
+ exclude(ExcludedDirectoryGlobs)
+ }
+ }
+ return objects.fileTree().setDir(projectDirectory).apply {
+ subdirectories.forEach { include("$it/src/**/*.kt") }
+ }
+ }
+
+ /** Allows overriding to use a custom directory instead of default [Project.getProjectDir]. */
+ @get:Internal var overrideDirectory: File? = null
+
+ /**
+ * Used together with [overrideDirectory] to specify which specific subdirectories should be
+ * analyzed.
+ */
+ @get:Internal var overrideSubdirectories: List? = null
+
+ protected fun runKtfmt(format: Boolean) {
+ if (getInputFiles().files.isEmpty()) return
+ val outputStream = ByteArrayOutputStream()
+ val errorStream = ByteArrayOutputStream()
+ execOperations.javaexec { javaExecSpec ->
+ javaExecSpec.standardOutput = outputStream
+ javaExecSpec.errorOutput = errorStream
+ javaExecSpec.mainClass.set(MainClass)
+ javaExecSpec.classpath = ktfmtClasspath
+ javaExecSpec.args = getArgsList(format = format)
+ javaExecSpec.jvmArgs("--add-opens=java.base/java.lang=ALL-UNNAMED")
+ overrideDirectory?.let { javaExecSpec.workingDir = it }
+ }
+
+ // https://github.com/facebook/ktfmt/blob/9830466327b72879808b0d6266d2cc69ef0197b2/core/src/main/java/com/facebook/ktfmt/cli/Main.kt#L168
+ // Info messages are printed to error, filter these out to avoid stderr clutter.
+ val error =
+ errorStream
+ .toString()
+ .lines()
+ .filterNot { it.startsWith("Done formatting ") }
+ .joinToString(separator = "\n")
+
+ if (error.isNotBlank()) {
+ System.err.println(error)
+ }
+
+ val output = outputStream.toString()
+ if (output.isNotEmpty()) {
+ error(processOutput(output))
+ }
+ }
+
+ open fun processOutput(output: String): String =
+ """
+ Failed check for the following files:
+ $output
+ """
+ .trimIndent()
+
+ private fun getArgsList(format: Boolean): List {
+ val arguments = mutableListOf("--kotlinlang-style")
+ if (!format) arguments.add("--dry-run")
+ arguments.addAll(getInputFiles().files.map { it.absolutePath })
+ return arguments
+ }
+}
+
+@CacheableTask
+abstract class KtfmtFormatTask : BaseKtfmtTask() {
+ init {
+ description = "Fix Kotlin code style deviations."
+ group = "formatting"
+ }
+
+ // Format task rewrites inputs, so the outputs are the same as inputs.
+ @OutputFiles fun getRewrittenFiles(): FileTree = getInputFiles()
+
+ @TaskAction
+ fun runFormat() {
+ runKtfmt(format = true)
+ }
+}
+
+@CacheableTask
+abstract class KtfmtCheckTask : BaseKtfmtTask() {
+ init {
+ description = "Check Kotlin code style."
+ group = "Verification"
+ }
+
+ @TaskAction
+ fun runCheck() {
+ runKtfmt(format = false)
+ }
+
+ override fun processOutput(output: String): String =
+ """
+ Failed check for the following files:
+ $output
+
+ ********************************************************************************
+ ${TERMINAL_RED}You can automatically fix these issues with:
+ ./gradlew $projectPath:ktFormat$TERMINAL_RESET
+ ********************************************************************************
+ """
+ .trimIndent()
+}
+
+@CacheableTask
+abstract class KtfmtCheckFileTask : BaseKtfmtTask() {
+ init {
+ description = "Check Kotlin code style."
+ group = "Verification"
+ }
+
+ @get:Internal val projectDir = project.projectDir
+
+ @get:Input
+ @set:Option(
+ option = "file",
+ description =
+ "File to check. This option can be used multiple times: --file file1.kt " +
+ "--file file2.kt",
+ )
+ var files: List = emptyList()
+
+ @get:Input
+ @set:Option(
+ option = "format",
+ description =
+ "Use --format to auto-correct style violations (if some errors cannot be " +
+ "fixed automatically they will be printed to stderr)",
+ )
+ var format = false
+
+ override fun getInputFiles(): FileTree {
+ if (files.isEmpty()) {
+ return objects.fileTree().setDir(projectDir).apply { exclude("**") }
+ }
+ val kotlinFiles =
+ files
+ .filter { file ->
+ val isKotlinFile = file.endsWith(".kt") || file.endsWith(".ktx")
+ val inExcludedDir =
+ Paths.get(file).any { subPath ->
+ ExcludedDirectories.contains(subPath.toString())
+ }
+
+ isKotlinFile && !inExcludedDir
+ }
+ .map { it.replace("./", "**/") }
+
+ if (kotlinFiles.isEmpty()) {
+ return objects.fileTree().setDir(projectDir).apply { exclude("**") }
+ }
+ return objects.fileTree().setDir(projectDir).apply { include(kotlinFiles) }
+ }
+
+ @TaskAction
+ fun runCheck() {
+ runKtfmt(format = format)
+ }
+
+ override fun processOutput(output: String): String {
+ val kotlinFiles =
+ files.filter { file ->
+ val isKotlinFile = file.endsWith(".kt") || file.endsWith(".ktx")
+ val inExcludedDir =
+ Paths.get(file).any { subPath ->
+ ExcludedDirectories.contains(subPath.toString())
+ }
+
+ isKotlinFile && !inExcludedDir
+ }
+ return """
+ Failed check for the following files:
+ $output
+
+ ********************************************************************************
+ ${TERMINAL_RED}You can attempt to automatically fix these issues with:
+ ./gradlew :ktCheckFile --format ${kotlinFiles.joinToString(separator = " "){ "--file $it" }}$TERMINAL_RESET
+ ********************************************************************************
+ """
+ .trimIndent()
+ }
+}
+
+fun Project.configureKtfmtCheckFile() {
+ tasks.register("ktCheckFile", KtfmtCheckFileTask::class.java) { task ->
+ task.ktfmtClasspath.from(getKtfmtConfiguration())
+ }
+}
diff --git a/buildSrc-fork/private/src/main/kotlin/androidx/build/LibraryVersionsService.kt b/buildSrc-fork/private/src/main/kotlin/androidx/build/LibraryVersionsService.kt
new file mode 100644
index 0000000000000..8de86aa297551
--- /dev/null
+++ b/buildSrc-fork/private/src/main/kotlin/androidx/build/LibraryVersionsService.kt
@@ -0,0 +1,193 @@
+/*
+ * Copyright 2021 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package androidx.build
+
+import org.gradle.api.GradleException
+import org.gradle.api.Project
+import org.gradle.api.provider.Provider
+import org.gradle.api.services.BuildService
+import org.gradle.api.services.BuildServiceParameters
+import org.tomlj.Toml
+import org.tomlj.TomlParseResult
+import org.tomlj.TomlTable
+
+/** Loads Library groups and versions from a specified TOML file. */
+abstract class LibraryVersionsService : BuildService {
+ interface Parameters : BuildServiceParameters {
+ var tomlFileName: String
+ var tomlFileContents: Provider
+ }
+
+ private val parsedTomlFile: TomlParseResult by lazy {
+ val result = Toml.parse(parameters.tomlFileContents.get())
+ if (result.hasErrors()) {
+ val issues =
+ result.errors().joinToString(separator = "\n") {
+ "${parameters.tomlFileName}:${it.position()}: ${it.message}"
+ }
+ throw Exception("${parameters.tomlFileName} file has issues.\n$issues")
+ }
+ result
+ }
+
+ private fun getTable(key: String): TomlTable {
+ return parsedTomlFile.getTable(key)
+ ?: throw GradleException("Library versions toml file is missing [$key] table")
+ }
+
+ // map from name of constant to Version
+ val libraryVersions: Map by lazy {
+ val versions = getTable("versions")
+ versions.keySet().associateWith { versionName ->
+ val versionValue = versions.getString(versionName)!!
+ Version.parseOrNull(versionValue)
+ ?: throw GradleException(
+ "$versionName does not match expected format - $versionValue"
+ )
+ }
+ }
+
+ // map of library groups keyed by their variable name in the toml file
+ val libraryGroups: Map by lazy {
+ val result = mutableMapOf()
+ for (association in libraryGroupAssociations) {
+ result[association.declarationName] = association.libraryGroup
+ }
+ result
+ }
+
+ // map of library groups keyed by group name
+ val libraryGroupsByGroupId: Map by lazy {
+ val result = mutableMapOf()
+ for (association in libraryGroupAssociations) {
+ // Check for duplicate groups
+ val groupId = association.libraryGroup.group
+ val existingAssociation = result[groupId]
+ if (existingAssociation != null) {
+ if (
+ existingAssociation.atomicGroupVersion != null &&
+ association.libraryGroup.atomicGroupVersion != null &&
+ existingAssociation.group !in ALLOWED_ATOMIC_GROUP_EXCEPTIONS
+ ) {
+ throw GradleException(
+ "Multiple atomic groups defined with the same Maven group ID: $groupId"
+ )
+ }
+ if (association.overrideIncludeInProjectPaths.isEmpty()) {
+ throw GradleException(
+ "Duplicate library group $groupId defined in " +
+ "${association.declarationName} does not set overrideInclude. " +
+ "Declarations beyond the first can only have an effect if they set " +
+ "overrideInclude"
+ )
+ }
+ } else {
+ result[groupId] = association.libraryGroup
+ }
+ }
+ result
+ }
+
+ // map from project name to group override if applicable
+ val overrideLibraryGroupsByProjectPath: Map by lazy {
+ val result = mutableMapOf()
+ for (association in libraryGroupAssociations) {
+ for (overridePath in association.overrideIncludeInProjectPaths) {
+ result[overridePath] = association.libraryGroup
+ }
+ }
+ result
+ }
+
+ private val libraryGroupAssociations: List by lazy {
+ val groups = getTable("groups")
+
+ fun readGroupVersion(groupDefinition: TomlTable, groupName: String, key: String): Version? {
+ val versionRef = groupDefinition.getString(key) ?: return null
+ if (!versionRef.startsWith(VersionReferencePrefix)) {
+ throw GradleException(
+ "Group entry $key is expected to start with $VersionReferencePrefix"
+ )
+ }
+ // name without `versions.`
+ val atomicGroupVersionName = versionRef.removePrefix(VersionReferencePrefix)
+ return libraryVersions[atomicGroupVersionName]
+ ?: error(
+ "Group entry $groupName specifies $atomicGroupVersionName, but such version " +
+ "doesn't exist"
+ )
+ }
+ groups.keySet().sorted().map { name ->
+ // get group name
+ val groupDefinition = groups.getTable(name)!!
+ val groupName = groupDefinition.getString("group")!!
+
+ // get group version, if any
+ val atomicGroupVersion =
+ readGroupVersion(
+ groupDefinition = groupDefinition,
+ groupName = groupName,
+ key = AtomicGroupVersion,
+ )
+ val overrideApplyToProjects =
+ (groupDefinition.getArray("overrideInclude")?.toList() ?: listOf()).map {
+ it as String
+ }
+
+ val group = LibraryGroup(groupName, atomicGroupVersion)
+ LibraryGroupAssociation(name, group, overrideApplyToProjects)
+ }
+ }
+
+ companion object {
+ internal fun registerOrGet(project: Project): Provider {
+ val tomlFileName = "libraryversions.toml"
+ val toml = project.lazyReadFile(tomlFileName)
+
+ return project.gradle.sharedServices.registerIfAbsent(
+ "libraryVersionsService",
+ LibraryVersionsService::class.java,
+ ) { spec ->
+ spec.parameters.tomlFileName = tomlFileName
+ spec.parameters.tomlFileContents = toml
+ }
+ }
+ }
+}
+
+// a LibraryGroupSpec knows how to associate a LibraryGroup with the appropriate projects
+private data class LibraryGroupAssociation(
+ // the name of the variable to which it is assigned in the toml file
+ val declarationName: String,
+ // the group
+ val libraryGroup: LibraryGroup,
+ // the paths of any additional projects that this group should be assigned to
+ val overrideIncludeInProjectPaths: List,
+)
+
+private const val VersionReferencePrefix = "versions."
+private const val AtomicGroupVersion = "atomicGroupVersion"
+
+// Maven groups that should be skipped for atomic duplication checks. Do not add further entries.
+// TODO(b/401002936, b/401000219, b/401003097, b/401005632): Remove groups from this list
+private val ALLOWED_ATOMIC_GROUP_EXCEPTIONS =
+ listOf(
+ "androidx.camera",
+ "androidx.compose.material3",
+ "androidx.lifecycle",
+ "androidx.tracing",
+ )
diff --git a/buildSrc-fork/private/src/main/kotlin/androidx/build/LintConfiguration.kt b/buildSrc-fork/private/src/main/kotlin/androidx/build/LintConfiguration.kt
new file mode 100644
index 0000000000000..7684ebdb2cf42
--- /dev/null
+++ b/buildSrc-fork/private/src/main/kotlin/androidx/build/LintConfiguration.kt
@@ -0,0 +1,313 @@
+/*
+ * Copyright 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package androidx.build
+
+import androidx.build.checkapi.shouldConfigureApiTasks
+import com.android.build.api.dsl.KotlinMultiplatformAndroidLibraryTarget
+import com.android.build.api.dsl.Lint
+import com.android.build.api.variant.KotlinMultiplatformAndroidComponentsExtension
+import com.android.build.api.variant.LintLifecycleExtension
+import com.android.build.gradle.AppPlugin
+import com.android.build.gradle.LibraryPlugin
+import com.android.build.gradle.api.KotlinMultiplatformAndroidPlugin
+import java.io.File
+import org.gradle.api.GradleException
+import org.gradle.api.Project
+import org.gradle.api.file.RegularFileProperty
+import org.gradle.api.plugins.JavaPlugin
+import org.gradle.kotlin.dsl.getByType
+import org.jetbrains.kotlin.gradle.plugin.KotlinBasePlugin
+
+/** Single entry point to Android Lint configuration. */
+fun Project.configureLint() {
+ project.plugins.configureEach { plugin ->
+ when (plugin) {
+ is AppPlugin -> configureAndroidProjectForLint(isLibrary = false)
+ is LibraryPlugin -> configureAndroidProjectForLint(isLibrary = true)
+ is KotlinMultiplatformAndroidPlugin ->
+ configureAndroidMultiplatformProjectForLint(
+ extensions.getByType().agpKmpExtension,
+ extensions.getByType(),
+ )
+ // Only configure non-multiplatform Java projects via JavaPlugin. Multiplatform
+ // projects targeting Java (e.g. `jvm { withJava() }`) are configured via
+ // KotlinBasePlugin.
+ is JavaPlugin ->
+ if (project.multiplatformExtension == null) {
+ configureNonAndroidProjectForLint()
+ }
+ // Only configure non-Android multiplatform projects via KotlinBasePlugin.
+ // Multiplatform projects targeting Android (e.g. `id("com.android.library")`) are
+ // configured via AppPlugin or LibraryPlugin.
+ is KotlinBasePlugin ->
+ if (
+ project.multiplatformExtension != null &&
+ !project.plugins.hasPlugin(AppPlugin::class.java) &&
+ !project.plugins.hasPlugin(LibraryPlugin::class.java) &&
+ !project.plugins.hasPlugin(KotlinMultiplatformAndroidPlugin::class.java)
+ ) {
+ configureNonAndroidProjectForLint()
+ }
+ }
+ }
+}
+
+/** Android Lint configuration entry point for Android projects. */
+private fun Project.configureAndroidProjectForLint(isLibrary: Boolean) =
+ extensions.findByType(LintLifecycleExtension::class.java)!!.finalizeDsl { lint ->
+ // The lintAnalyze task is used by `androidx-studio-integration-lint.sh`.
+ tasks.register("lintAnalyze") { task -> task.enabled = false }
+
+ configureLint(lint, isLibrary)
+ }
+
+private fun Project.configureAndroidMultiplatformProjectForLint(
+ extension: KotlinMultiplatformAndroidLibraryTarget,
+ componentsExtension: KotlinMultiplatformAndroidComponentsExtension,
+) {
+ componentsExtension.finalizeDsl {
+ // The lintAnalyze task is used by `androidx-studio-integration-lint.sh`.
+ tasks.register("lintAnalyze") { task -> task.enabled = false }
+ configureLint(extension.lint, isLibrary = true)
+ }
+}
+
+/** Android Lint configuration entry point for non-Android projects. */
+private fun Project.configureNonAndroidProjectForLint() = afterEvaluate {
+ // For Android projects, the Android Gradle Plugin is responsible for applying the lint plugin;
+ // however, we need to apply it ourselves for non-Android projects.
+ apply(mapOf("plugin" to "com.android.lint"))
+
+ // The lintAnalyzeDebug task is used by `androidx-studio-integration-lint.sh`.
+ tasks.register("lintAnalyzeDebug") { it.enabled = false }
+
+ // For Android projects, we can run lint configuration last using `DslLifecycle.finalizeDsl`;
+ // however, we need to run it using `Project.afterEvaluate` for non-Android projects.
+ configureLint(project.extensions.getByType(), isLibrary = true)
+}
+
+private fun Project.findLintProject(path: String): Project? {
+ return project.rootProject.findProject(path)
+ ?: if (allowMissingLintProject()) {
+ null
+ } else {
+ throw GradleException("Project $path does not exist")
+ }
+}
+
+private fun Project.configureLint(lint: Lint, isLibrary: Boolean) {
+ val extension = project.androidXExtension
+ val type = extension.type.get()
+ val lintChecksProject = findLintProject(":lint-checks") ?: return
+ project.dependencies.add("lintChecks", lintChecksProject)
+
+ if (type in setOf(SoftwareType.GRADLE_PLUGIN, SoftwareType.INTERNAL_GRADLE_PLUGIN)) {
+ project.rootProject.findProject(":lint:lint-gradle")?.let {
+ project.dependencies.add("lintChecks", it)
+ }
+ }
+
+ // The purpose of this specific project is to test that lint is running, so
+ // it contains expected violations that we do not want to trigger a build failure
+ val isTestingLintItself = (project.path == ":lint-checks:integration-tests")
+
+ lint.apply {
+ // Skip lintVital tasks on assemble. We explicitly run lintRelease for libraries.
+ checkReleaseBuilds = false
+ }
+
+ // Lint is configured entirely in finalizeDsl so that individual projects cannot easily
+ // disable individual checks in the DSL for any reason.
+ lint.apply {
+ if (!isTestingLintItself) {
+ abortOnError = true
+ }
+ ignoreWarnings = true
+
+ // Run lint on tests. All checks defined with test scope will be run on test sources.
+ // Additional checks for tests can be specified in the top-level lint.xml.
+ ignoreTestSources = false
+ checkTestSources = false
+
+ // Write output directly to the console (and nowhere else).
+ textReport = true
+ htmlReport = false
+
+ // Format output for convenience.
+ explainIssues = true
+ noLines = false
+ quiet = true
+
+ // We run lint on each library, so we don't want transitive checking of each dependency
+ checkDependencies = false
+
+ if (type.allowCallingVisibleForTestsApis) {
+ // Test libraries are allowed to call @VisibleForTests code
+ disable.add("VisibleForTests")
+ } else {
+ fatal.add("VisibleForTests")
+ }
+
+ if (type.isForTesting) {
+ // Disable this check as we do allow usage of junit as a dependency
+ disable.add("InvalidPackage")
+ } else {
+ fatal.add("InvalidPackage")
+ }
+
+ // Disable a check that's only relevant for apps that ship to Play Store. (b/299278101)
+ disable.add("ExpiredTargetSdkVersion")
+
+ // Disable dependency checks that suggest to change them. We want libraries to be
+ // intentional with their dependency version bumps.
+ disable.add("KtxExtensionAvailable")
+ disable.add("GradleDependency")
+
+ // Disable a check that's only relevant for real apps. For our test apps we're not
+ // concerned with drawables potentially being a little bit blurry
+ disable.add("IconMissingDensityFolder")
+
+ // Disable until it works for our projects, b/171986505
+ disable.add("JavaPluginLanguageLevel")
+
+ // Explicitly disable StopShip check (see b/244617216)
+ disable.add("StopShip")
+
+ // Swap the built-in RestrictedApi check for our "fixed" version (see b/297047524)
+ disable.add("RestrictedApi")
+ fatal.add("RestrictedApiAndroidX")
+
+ // Provide stricter enforcement for project types intended to run on a device.
+ if (type.compilationTarget == CompilationTarget.DEVICE) {
+ fatal.add("Assert")
+ fatal.add("NewApi")
+ fatal.add("ObsoleteSdkInt")
+ fatal.add("NoHardKeywords")
+ fatal.add("UnusedResources")
+ fatal.add("KotlinPropertyAccess")
+ fatal.add("LambdaLast")
+ if (type != SoftwareType.PUBLISHED_PROTO_LIBRARY) {
+ // Enforce UnknownNullness for all device targeting projects except for proto
+ // projects that generate code without proper nullability annotations.
+ fatal.add("UnknownNullness")
+ }
+
+ // Too many Kotlin features require synthetic accessors - we want to rely on R8 to
+ // remove these accessors
+ disable.add("SyntheticAccessor")
+
+ // Only check for missing translations in finalized (beta and later) modules.
+ if (extension.mavenVersion?.isFinalApi() == true) {
+ fatal.add("MissingTranslation")
+ } else {
+ disable.add("MissingTranslation")
+ }
+ } else {
+ disable.add("BanUncheckedReflection")
+ disable.add("BanConcurrentHashMap")
+ }
+
+ // Only show ObsoleteCompatMethod in the IDE.
+ disable.add("ObsoleteCompatMethod")
+
+ // Broken in 7.0.0-alpha15 due to b/187343720
+ disable.add("UnusedResources")
+
+ if (type == SoftwareType.SAMPLES) {
+ // TODO: b/190833328 remove if / when AGP will analyze dependencies by default
+ // This is needed because SampledAnnotationDetector uses partial analysis, and
+ // hence requires dependencies to be analyzed.
+ checkDependencies = true
+ }
+
+ // Only run certain checks where API tracking is important.
+ if (type.checkApi is RunApiTasks.No) {
+ disable.add("IllegalExperimentalApiUsage")
+ }
+
+ // Run the JSpecifyNullness check unless opted-out (for projects that haven't migrated yet).
+ if (extension.optOutJSpecify) {
+ disable.add("JSpecifyNullness")
+ } else {
+ fatal.add("JSpecifyNullness")
+ }
+
+ fatal.add("UastImplementation") // go/hide-uast-impl
+ fatal.add("KotlincFE10") // b/239982263
+
+ disable.add("RequiresWindowSdk") // temporarily disable this check due to downstream diff
+
+ // Report errors for incompatible custom lint jars
+ fatal.add("ObsoleteLintCustomCheck")
+
+ // If a project targets only Kotlin consumers, it is allowed to define experimental
+ // properties because the Kotlin compiler warns users that the properties are experimental.
+ // If a project can have Java clients, enable the lint check banning experimental properties
+ // because the experimental detector lint which warns Java clients about experimental usage
+ // isn't able to handle experimental properties correctly.
+ // Projects that don't run API compatibility checks can define experimental properties (lint
+ // check disabled) since the entire API surface makes no compatibility guarantees.
+ if (type.targetsKotlinConsumersOnly || !extension.shouldConfigureApiTasks().get()) {
+ disable.add("ExperimentalPropertyAnnotation")
+ } else {
+ fatal.add("ExperimentalPropertyAnnotation")
+ }
+
+ if (!isLibrary) {
+ // These lint checks are specifically for libraries.
+ disable.add("MissingServiceExportedEqualsTrue")
+ disable.add("MetadataTagInsideApplicationTag")
+ }
+
+ fatal.add("CheckResult")
+ fatal.add("PrivateResource")
+
+ val lintXmlPath =
+ if (type == SoftwareType.SAMPLES) {
+ "buildSrc/lint/lint_samples.xml"
+ } else {
+ "buildSrc/lint/lint.xml"
+ }
+
+ // Prevent libraries from fully overriding the config from buildSrc. Projects can create a
+ // custom lint.xml that will also be picked up by lint (which searches for one starting from
+ // the project dir and then moving up directories). The order of precedence for config rules
+ // is here: https://googlesamples.github.io/android-custom-lint-rules/usage/lintxml.md.html
+ if (lintConfig != null) {
+ throw IllegalStateException(
+ "Project should not override the lint configuration from `$lintXmlPath`.\n" +
+ "To add additional lint configuration for this project, create a `lint.xml` " +
+ "file in the project directory but do not set it as the `lintConfig` in the " +
+ "project's build file."
+ )
+ }
+
+ // suppress warnings more specifically than issue-wide severity (regexes)
+ // Currently suppresses warnings from baseline files working as intended
+ lintConfig = File(project.getSupportRootFolder(), lintXmlPath)
+ baseline = lintBaseline.get().asFile
+ }
+ project.buildOnServerDependsOnLint()
+}
+
+private fun Project.buildOnServerDependsOnLint() {
+ if (!project.usingMaxDepVersions().get()) {
+ project.addToBuildOnServer("lint")
+ }
+}
+
+private val Project.lintBaseline: RegularFileProperty
+ get() = project.objects.fileProperty().fileValue(File(projectDir, "lint-baseline.xml"))
diff --git a/buildSrc-fork/private/src/main/kotlin/androidx/build/ListAffectedProjectsTask.kt b/buildSrc-fork/private/src/main/kotlin/androidx/build/ListAffectedProjectsTask.kt
new file mode 100644
index 0000000000000..ebcebfd0c93c8
--- /dev/null
+++ b/buildSrc-fork/private/src/main/kotlin/androidx/build/ListAffectedProjectsTask.kt
@@ -0,0 +1,172 @@
+/*
+ * Copyright 2025 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package androidx.build
+
+import androidx.build.gitclient.getChangedFilesProvider
+import kotlin.Suppress
+import org.gradle.api.DefaultTask
+import org.gradle.api.Project
+import org.gradle.api.file.RegularFileProperty
+import org.gradle.api.provider.ListProperty
+import org.gradle.api.provider.MapProperty
+import org.gradle.api.provider.Property
+import org.gradle.api.provider.Provider
+import org.gradle.api.tasks.Input
+import org.gradle.api.tasks.Internal
+import org.gradle.api.tasks.OutputFile
+import org.gradle.api.tasks.TaskAction
+import org.gradle.api.tasks.options.Option
+import org.gradle.kotlin.dsl.extra
+import org.gradle.work.DisableCachingByDefault
+
+/**
+ * Determines the affected projects based on changed files.
+ *
+ * This task is designed to run every time and identifies the projects impacted by changes in the
+ * source files. It generates a list of Gradle task commands for the affected projects and writes
+ * them to an output file.
+ */
+@DisableCachingByDefault(because = "The purpose of this task is to run each time")
+abstract class ListAffectedProjectsTask : DefaultTask() {
+
+ @get:Input abstract val changedFiles: ListProperty
+
+ @get:Input abstract val projectConsumersMap: MapProperty>
+
+ @get:Input abstract val tasksToRun: ListProperty
+
+ @get:Input abstract val shouldRunOnDependentProjects: Property
+
+ @get:OutputFile abstract val outputFile: RegularFileProperty
+
+ @get:Internal
+ val listProjectsServiceProvider: Provider =
+ ListProjectsService.registerOrGet(project)
+
+ @Option(
+ option = "baseCommit",
+ description = "The base commit to compare changes against. Defaults to last merge commit.",
+ )
+ fun setBaseCommit(commit: String?) {
+ changedFiles.set(project.getChangedFilesProvider(project.provider { commit }))
+ }
+
+ @Suppress("UNUSED")
+ @Option(
+ option = "tasksToRun",
+ description = "Comma-separated list of tasks to run (e.g. 'bOS, allHostTests')",
+ )
+ fun setTasksRun(tasks: String) {
+ tasksToRun.set(tasks.split(",").map(String::trim))
+ }
+
+ @Suppress("UNUSED")
+ @Option(
+ option = "runOnDependentProjects",
+ description = "Boolean flag to also run tasks on dependent projects",
+ )
+ fun setRunOnDependentProjects(flag: String) {
+ this.shouldRunOnDependentProjects.set(flag.toBoolean())
+ }
+
+ @TaskAction
+ fun listAffectedProjects() {
+ val changedFilesList = changedFiles.get()
+ println("Changed files: $changedFilesList")
+ val allProjects = listProjectsServiceProvider.get().allPossibleProjects
+ val projectConsumers = projectConsumersMap.get()
+ val tasks = tasksToRun.get()
+ check(tasks.isNotEmpty()) { "tasksToRun cannot be empty" }
+
+ val projectByFilePath = allProjects.associateBy({ it.filePath }, { it.gradlePath })
+
+ val changedProjects =
+ changedFilesList
+ .mapNotNull { changedFile ->
+ when {
+ changedFile.startsWith("buildSrc/") -> ":buildSrc-tests"
+ "/src/" in changedFile -> {
+ val candidate = changedFile.substringBefore("/src/")
+ projectByFilePath[candidate]
+ }
+ else -> {
+ val sortedProjects =
+ allProjects
+ .map { it.filePath to it.gradlePath }
+ .sortedByDescending { it.first.length }
+ sortedProjects
+ .firstOrNull { (projectFilePath, _) ->
+ changedFile.startsWith(projectFilePath)
+ }
+ ?.second
+ }
+ }
+ }
+ .toSet()
+
+ val affectedProjects =
+ if (shouldRunOnDependentProjects.get()) {
+ changedProjects.flatMap { findAllProjectsDependingOn(it, projectConsumers) }.toSet()
+ } else {
+ changedProjects
+ }
+
+ val commands =
+ affectedProjects
+ // TODO(b/396611615): Remove when :docs-tip-of-tree can run bOS locally
+ .filterNot { it == ":docs-tip-of-tree" }
+ .flatMap { project -> tasks.map { task -> "$project:$task" } }
+
+ with(outputFile.get().asFile) {
+ parentFile.mkdirs()
+ writeText(commands.joinToString(" "))
+ }
+ }
+}
+
+private fun findAllProjectsDependingOn(
+ projectPath: String,
+ projectConsumers: Map>,
+): Set {
+ val result = mutableSetOf()
+ val toBeTraversed = ArrayDeque().apply { add(projectPath) }
+
+ while (toBeTraversed.isNotEmpty()) {
+ val path = toBeTraversed.removeFirst()
+ if (result.add(path)) {
+ projectConsumers[path]?.let { dependents -> toBeTraversed.addAll(dependents) }
+ }
+ }
+ return result
+}
+
+internal fun Project.registerListAffectedProjectsTask() =
+ tasks.register("listAffectedProjects", ListAffectedProjectsTask::class.java) { task ->
+ task.tasksToRun.convention(listOf("bOS"))
+ task.shouldRunOnDependentProjects.convention(false)
+ task.setBaseCommit(null)
+
+ @Suppress("UNCHECKED_CAST")
+ task.projectConsumersMap.set(
+ (gradle.extra["allProjectConsumers"] as Map>)
+ )
+
+ task.outputFile.set(layout.buildDirectory.file("changedProjects.txt"))
+
+ // Always run task
+ task.outputs.upToDateWhen { false }
+ }
diff --git a/buildSrc-fork/private/src/main/kotlin/androidx/build/ListAndroidXPropertiesTask.kt b/buildSrc-fork/private/src/main/kotlin/androidx/build/ListAndroidXPropertiesTask.kt
new file mode 100644
index 0000000000000..330ddecfeda3b
--- /dev/null
+++ b/buildSrc-fork/private/src/main/kotlin/androidx/build/ListAndroidXPropertiesTask.kt
@@ -0,0 +1,36 @@
+/*
+ * Copyright 2020 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package androidx.build
+
+import org.gradle.api.DefaultTask
+import org.gradle.api.tasks.TaskAction
+import org.gradle.work.DisableCachingByDefault
+
+/** Lists recognized properties whose names start with "androidx" */
+@DisableCachingByDefault(because = "Too many inputs to cache, and runs quickly anyway")
+abstract class ListAndroidXPropertiesTask : DefaultTask() {
+ init {
+ group = "Help"
+ description = "Lists AndroidX-specific properties (specifiable via -Pandroidx.*)"
+ }
+
+ @TaskAction
+ fun exec() {
+ project.logger.lifecycle(ALL_ANDROIDX_PROPERTIES.joinToString("\n"))
+ project.logger.lifecycle("See AndroidXGradleProperties.kt for more information")
+ }
+}
diff --git a/buildSrc-fork/private/src/main/kotlin/androidx/build/ListProjectsService.kt b/buildSrc-fork/private/src/main/kotlin/androidx/build/ListProjectsService.kt
new file mode 100644
index 0000000000000..e2a1cf3107586
--- /dev/null
+++ b/buildSrc-fork/private/src/main/kotlin/androidx/build/ListProjectsService.kt
@@ -0,0 +1,50 @@
+/*
+ * Copyright 2022 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package androidx.build
+
+import org.gradle.api.Project
+import org.gradle.api.provider.Provider
+import org.gradle.api.services.BuildService
+import org.gradle.api.services.BuildServiceParameters
+
+/** Lists projects as specified by settings.gradle */
+abstract class ListProjectsService : BuildService {
+ interface Parameters : BuildServiceParameters {
+ var settingsFile: Provider
+ }
+
+ // Lists all project paths mentioned in frameworks/support/settings.gradle
+ // Note that this might be more than the full list of projects configured in this build:
+ // a) Configuration-on-demand can disable projects mentioned in settings.gradle
+ // B) Playground builds use their own settings.gradle files
+ val allPossibleProjects: List by lazy {
+ SettingsParser.findProjects(parameters.settingsFile.get())
+ }
+
+ companion object {
+ internal fun registerOrGet(project: Project): Provider {
+ // service that can compute full list of projects in settings.gradle
+ val settings = project.lazyReadFile("settings.gradle")
+ return project.gradle.sharedServices.registerIfAbsent(
+ "listProjectsService",
+ ListProjectsService::class.java,
+ ) { spec ->
+ spec.parameters.settingsFile = settings
+ }
+ }
+ }
+}
diff --git a/buildSrc-fork/private/src/main/kotlin/androidx/build/ListTaskOutputsTask.kt b/buildSrc-fork/private/src/main/kotlin/androidx/build/ListTaskOutputsTask.kt
new file mode 100644
index 0000000000000..b54bef5102889
--- /dev/null
+++ b/buildSrc-fork/private/src/main/kotlin/androidx/build/ListTaskOutputsTask.kt
@@ -0,0 +1,247 @@
+/*
+ * Copyright 2019 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package androidx.build
+
+import org.gradle.api.DefaultTask
+import org.gradle.api.GradleException
+import org.gradle.api.Task
+import org.gradle.api.file.RegularFileProperty
+import org.gradle.api.provider.ListProperty
+import org.gradle.api.provider.Property
+import org.gradle.api.tasks.CacheableTask
+import org.gradle.api.tasks.Input
+import org.gradle.api.tasks.Nested
+import org.gradle.api.tasks.OutputFile
+import org.gradle.api.tasks.TaskAction
+
+/** Finds the outputs of every task and saves this mapping into a file */
+@CacheableTask
+abstract class ListTaskOutputsTask : DefaultTask() {
+ @OutputFile val outputFile: RegularFileProperty = project.objects.fileProperty()
+ @Input val removePrefixes: MutableList = mutableListOf()
+ @get:Nested abstract val producers: ListProperty
+
+ init {
+ group = "Help"
+ project.gradle.taskGraph.whenReady {
+ val taskOutputProducerList = mutableListOf()
+ project.allprojects { otherProject ->
+ otherProject.tasks.forEach { task ->
+ project.objects.newInstance(TaskOutputProducer::class.java).apply {
+ taskPath.set(task.path)
+ taskClass.set(task::class.qualifiedName ?: task::class.java.name)
+ validate.set(shouldValidateTaskOutput(task))
+ val fileElements = task.outputs.files.elements
+ outputPaths.set(
+ fileElements.map { set ->
+ set.map { it.asFile.invariantSeparatorsPath }
+ }
+ )
+ taskOutputProducerList.add(this)
+ }
+ }
+ }
+ producers.set(taskOutputProducerList)
+ }
+ }
+
+ fun removePrefix(prefix: String) {
+ removePrefixes.add("$prefix/")
+ }
+
+ @TaskAction
+ fun exec() {
+ val outputText = computeOutputText(producers.get())
+ val outputFile = outputFile.get()
+ outputFile.asFile.writeText(outputText)
+ }
+
+ private fun computeOutputText(producers: List): String {
+ val tasksByOutput: MutableMap = hashMapOf()
+ for (producer in producers) {
+ for (path in producer.outputPaths.get()) {
+ val existing = tasksByOutput[path]
+ if (existing != null) {
+ if (existing.validate.get() && producer.validate.get()) {
+ throw GradleException(
+ "Output file $path was declared as an output of multiple tasks: " +
+ "${producer.taskPath.get()} and ${existing.taskPath.get()}"
+ )
+ }
+ if (existing.taskPath.get() > producer.taskPath.get()) continue
+ }
+ tasksByOutput[path] = producer
+ }
+ }
+ return formatTasks(tasksByOutput, removePrefixes)
+ }
+
+ // Given a map from output file path to Task, formats into a String
+ private fun formatTasks(
+ tasksByOutput: MutableMap,
+ removePrefixes: List,
+ ): String {
+ val messages: MutableList = mutableListOf()
+ for ((path, task) in tasksByOutput) {
+ var filePath = path
+ for (prefix in removePrefixes) {
+ filePath = filePath.removePrefix(prefix)
+ }
+
+ messages.add(
+ formatInColumns(
+ listOf(
+ filePath,
+ " - " + task.taskPath.get() + " (" + task.taskClass.get() + ")",
+ )
+ )
+ )
+ }
+ messages.sort()
+ return messages.joinToString("\n")
+ }
+
+ // Given a list of columns, indents and joins them to be easy to read
+ private fun formatInColumns(columns: List): String {
+ val components = mutableListOf()
+ var textLength = 0
+ for (column in columns) {
+ val roundedTextLength =
+ if (textLength == 0) {
+ textLength
+ } else {
+ ((textLength / 32) + 1) * 32
+ }
+ val extraSpaces = " ".repeat(roundedTextLength - textLength)
+ components.add(extraSpaces)
+ textLength = roundedTextLength
+ components.add(column)
+ textLength += column.length
+ }
+ return components.joinToString("")
+ }
+}
+
+// TODO(149103692): remove all elements of this set
+private val taskNamesKnownToDuplicateOutputs =
+ setOf(
+ // Instead of adding new elements to this set, prefer to disable unused tasks when possible
+
+ // b/308798582
+ "transformNonJvmMainCInteropDependenciesMetadataForIde",
+ "transformAndroidNativeMainCInteropDependenciesMetadataForIde",
+ "transformAndroidNativeTestCInteropDependenciesMetadataForIde",
+ "transformAppleMainCInteropDependenciesMetadataForIde",
+ "transformAppleTestCInteropDependenciesMetadataForIde",
+ "transformDarwinTestCInteropDependenciesMetadataForIde",
+ "transformDarwinMainCInteropDependenciesMetadataForIde",
+ "transformCommonMainCInteropDependenciesMetadataForIde",
+ "transformCommonTestCInteropDependenciesMetadataForIde",
+ "transformIosMainCInteropDependenciesMetadataForIde",
+ "transformIosTestCInteropDependenciesMetadataForIde",
+ "transformMacosMainCInteropDependenciesMetadataForIde",
+ "transformMacosTestCInteropDependenciesMetadataForIde",
+ "transformNativeTestCInteropDependenciesMetadataForIde",
+ "transformNativeMainCInteropDependenciesMetadataForIde",
+ "transformTvosMainCInteropDependenciesMetadataForIde",
+ "transformTvosTestCInteropDependenciesMetadataForIde",
+ "transformWatchosMainCInteropDependenciesMetadataForIde",
+ "transformWatchosTestCInteropDependenciesMetadataForIde",
+ "transformUnixMainCInteropDependenciesMetadataForIde",
+ "transformUnixTestCInteropDependenciesMetadataForIde",
+ "transformLinuxMainCInteropDependenciesMetadataForIde",
+ "transformLinuxTestCInteropDependenciesMetadataForIde",
+ "transformNonIosNativeTestCInteropDependenciesMetadataForIde",
+ "transformNonJvmCommonMainCInteropDependenciesMetadataForIde",
+
+ // The following tests intentionally have the same output of golden images
+ "updateGoldenDesktopTest",
+ "updateGoldenDebugUnitTest",
+
+ // The following tasks have the same output file:
+ // ../../prebuilts/androidx/javascript-for-kotlin/yarn.lock
+ "kotlinRestoreYarnLock",
+ "kotlinWasmRestoreYarnLock",
+ "kotlinNpmInstall",
+ "kotlinWasmNpmInstall",
+ "kotlinUpgradePackageLock",
+ "kotlinWasmUpgradePackageLock",
+ "kotlinUpgradeYarnLock",
+ "kotlinWasmUpgradeYarnLock",
+ "kotlinStorePackageLock",
+ "kotlinWasmStorePackageLock",
+ "kotlinStoreYarnLock",
+ "kotlinWasmStoreYarnLock",
+
+ // The following tasks have the same output file:
+ // $OUT_DIR/androidx/build/wasm/yarn.lock
+ "wasmKotlinRestoreYarnLock",
+ "wasmKotlinNpmInstall",
+ "wasmKotlinUpgradePackageLock",
+ "wasmKotlinStorePackageLock",
+ "wasmKotlinUpgradeYarnLock",
+ "wasmKotlinStoreYarnLock",
+
+ // The following tasks have the same output configFile file:
+ // projectBuildDir/js/packages/projectName-wasm-js/webpack.config.js
+ // Remove when https://youtrack.jetbrains.com/issue/KT-70029 / b/361319689 is resolved
+ // and set configFile location for each task
+ "wasmJsBrowserDevelopmentWebpack",
+ "wasmJsBrowserDevelopmentRun",
+ "wasmJsBrowserProductionWebpack",
+ "wasmJsBrowserProductionRun",
+ "jsTestTestDevelopmentExecutableCompileSync",
+
+ // https://youtrack.jetbrains.com/issue/KT-79936
+ // $OUT_DIR/.gradle/nodejs/node-v22.13.0-darwin-arm64.hash
+ "kotlinNodeJsSetup",
+ "kotlinWasmNodeJsSetup",
+ // $OUT_DIR/.gradle/yarn/yarn-v1.22.17.hash
+ "wasmKotlinYarnSetup",
+ "kotlinYarnSetup",
+
+ // $OUT_DIR/.gradle/binaryen/binaryen-version_122.hash
+ "kotlinBinaryenSetup",
+ "kotlinWasmBinaryenSetup",
+ )
+
+fun shouldValidateTaskOutput(task: Task): Boolean {
+ if (!task.enabled) {
+ return false
+ }
+ return !taskNamesKnownToDuplicateOutputs.contains(task.name)
+}
+
+/** Nested input describing each projects tasks and its outputs */
+abstract class TaskOutputProducer {
+
+ @get:Input abstract val taskPath: Property
+
+ @get:Input abstract val taskClass: Property
+
+ @get:Input abstract val validate: Property
+
+ /**
+ * A collection of output paths from various tasks.
+ *
+ * This property intentionally avoids using a [org.gradle.api.file.FileCollection] to prevent
+ * creating a direct task dependency between the producer tasks and the [ListTaskOutputsTask].
+ * By storing the paths as strings, we can inspect the output locations without coupling the
+ * tasks in the execution graph.
+ */
+ @get:Input abstract val outputPaths: ListProperty
+}
diff --git a/buildSrc-fork/private/src/main/kotlin/androidx/build/MavenUploadHelper.kt b/buildSrc-fork/private/src/main/kotlin/androidx/build/MavenUploadHelper.kt
new file mode 100644
index 0000000000000..cc62a8188eb3b
--- /dev/null
+++ b/buildSrc-fork/private/src/main/kotlin/androidx/build/MavenUploadHelper.kt
@@ -0,0 +1,577 @@
+/*
+ * Copyright 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package androidx.build
+
+import androidx.build.ProjectLayoutType.Companion.isJetBrainsFork
+import androidx.build.buildInfo.CreateLibraryBuildInfoFileTask
+import androidx.build.sources.PublishingVariant
+import com.android.build.api.dsl.LibraryExtension
+import com.android.build.gradle.AppPlugin
+import com.android.build.gradle.LibraryPlugin
+import com.android.utils.childrenIterator
+import com.android.utils.forEach
+import com.google.gson.GsonBuilder
+import com.google.gson.JsonObject
+import com.google.gson.stream.JsonWriter
+import java.io.StringWriter
+import org.dom4j.Element
+import org.dom4j.io.XMLWriter
+import org.gradle.api.GradleException
+import org.gradle.api.Project
+import org.gradle.api.XmlProvider
+import org.gradle.api.component.SoftwareComponent
+import org.gradle.api.plugins.JavaPlugin
+import org.gradle.api.provider.Provider
+import org.gradle.api.publish.PublishingExtension
+import org.gradle.api.publish.maven.MavenPom
+import org.gradle.api.publish.maven.MavenPublication
+import org.gradle.api.publish.maven.tasks.GenerateMavenPom
+import org.gradle.api.publish.tasks.GenerateModuleMetadata
+import org.gradle.api.tasks.bundling.Zip
+import org.gradle.kotlin.dsl.configure
+import org.gradle.kotlin.dsl.create
+import org.gradle.kotlin.dsl.findByType
+import org.gradle.work.DisableCachingByDefault
+import org.jetbrains.androidx.build.JetBrainsPublication
+import org.jetbrains.kotlin.gradle.dsl.KotlinMultiplatformExtension
+import org.jetbrains.kotlin.gradle.plugin.KotlinMultiplatformPluginWrapper
+
+fun Project.configureMavenArtifactUpload(
+ androidXExtension: AndroidXExtension,
+ androidXKmpExtension: AndroidXMultiplatformExtension,
+ afterConfigure: () -> Unit,
+) {
+ if (isJetBrainsFork(project) && JetBrainsPublication.shouldPublish(this)) return
+ apply(mapOf("plugin" to "maven-publish"))
+ var registered = false
+ fun registerOnFirstPublishableArtifact(component: SoftwareComponent) {
+ if (!registered) {
+ configureComponentPublishing(
+ androidXExtension,
+ androidXKmpExtension,
+ component,
+ afterConfigure,
+ )
+ Release.register(this, androidXExtension)
+ registered = true
+ }
+ }
+ afterEvaluate {
+ if (!androidXExtension.shouldPublish.get()) {
+ return@afterEvaluate
+ }
+ components.configureEach { component ->
+ if (isValidReleaseComponent(component)) {
+ registerOnFirstPublishableArtifact(component)
+ }
+ }
+ }
+ // validate that all libraries that should be published actually get tasks registered.
+ // named() will throw UnknownTaskException if the task is not registered.
+ gradle.taskGraph.whenReady { graph ->
+ if (releaseTaskShouldBeRegistered(androidXExtension)) {
+ tasks.named(Release.PROJECT_ARCHIVE_ZIP_TASK_NAME)
+ }
+ if (buildInfoTaskShouldBeRegistered(androidXExtension)) {
+ if (!androidXExtension.isIsolatedProjectsEnabled()) {
+ tasks.named(CreateLibraryBuildInfoFileTask.TASK_NAME)
+ }
+ }
+ }
+}
+
+private fun Project.releaseTaskShouldBeRegistered(extension: AndroidXExtension): Boolean {
+ if (plugins.hasPlugin(AppPlugin::class.java)) {
+ return false
+ }
+ if (!extension.shouldRelease.get() && !isSnapshotBuild()) {
+ return false
+ }
+ return extension.shouldPublish.get()
+}
+
+private fun Project.buildInfoTaskShouldBeRegistered(extension: AndroidXExtension): Boolean {
+ if (plugins.hasPlugin(AppPlugin::class.java)) {
+ return false
+ }
+ return extension.shouldRelease.get()
+}
+
+/** Configure publishing for a [SoftwareComponent]. */
+private fun Project.configureComponentPublishing(
+ extension: AndroidXExtension,
+ androidxKmpExtension: AndroidXMultiplatformExtension,
+ component: SoftwareComponent,
+ afterConfigure: () -> Unit,
+) {
+ val androidxGroup = validateCoordinatesAndGetGroup(extension)
+ group = androidxGroup.group
+
+ /*
+ * Provides a set of maven coordinates (groupId:artifactId) of artifacts in AndroidX
+ * that are Android Libraries.
+ */
+ val androidLibrariesSetProvider: Provider> = provider {
+ val androidxAndroidProjects = mutableSetOf()
+ // Check every project is the project map to see if they are an Android Library
+ val projectModules = extension.mavenCoordinatesToProjectPathMap
+ for ((mavenCoordinates, projectPath) in projectModules) {
+ project.findProject(projectPath)?.let { project ->
+ if (project.plugins.hasPlugin(LibraryPlugin::class.java)) {
+ androidxAndroidProjects.add(mavenCoordinates)
+ }
+ if (project.hasAndroidMultiplatformPlugin()) {
+ androidxAndroidProjects.add("$mavenCoordinates-android")
+ }
+ }
+ }
+ androidxAndroidProjects
+ }
+
+ configure {
+ repositories {
+ it.maven { repo -> repo.setUrl(getRepositoryDirectory()) }
+ it.maven { repo -> repo.setUrl(getPerProjectRepositoryDirectory()) }
+ }
+ publications {
+ if (appliesJavaGradlePluginPlugin()) {
+ // The 'java-gradle-plugin' will also add to the 'pluginMaven' publication
+ it.create("pluginMaven")
+ afterConfigure()
+ } else {
+ if (project.isMultiplatformPublicationEnabled()) {
+ afterConfigure()
+ } else {
+ it.create("maven") { from(component) }
+ afterConfigure()
+ }
+ }
+ }
+ publications.withType(MavenPublication::class.java).configureEach { publication ->
+ // Used to add buildId to Gradle module metadata set below
+ publication.withBuildIdentifier()
+ val isKmpAnchor = (publication.name == KMP_ANCHOR_PUBLICATION_NAME)
+ val pomPlatform = androidxKmpExtension.defaultPlatform
+ // b/297355397 If a kmp project has Android as the default platform, there might
+ // externally be legacy projects depending on its .pom
+ // We advertise a stub .aar in this .pom for backwards compatibility and
+ // add a dependency on the actual .aar
+ val addStubAar = isKmpAnchor && pomPlatform == PlatformIdentifier.ANDROID.id
+ val buildDir = project.layout.buildDirectory
+ if (addStubAar) {
+ val minSdk =
+ project.extensions.findByType()?.defaultConfig?.minSdk
+ ?: extensions
+ .findByType()
+ ?.agpKmpExtension
+ ?.minSdk
+ ?: throw GradleException(
+ "Couldn't find valid Android extension to read minSdk from"
+ )
+ // create a unique namespace for this .aar, different from the android artifact
+ val stubNamespace =
+ project.group.toString().replace(':', '.') +
+ "." +
+ project.name.replace('-', '.') +
+ ".anchor"
+ val unpackedStubAarTask =
+ tasks.register("unpackedStubAar", UnpackedStubAarTask::class.java) { aarTask ->
+ aarTask.aarPackage.set(stubNamespace)
+ aarTask.minSdkVersion.set(minSdk)
+ aarTask.outputDir.set(buildDir.dir("intermediates/stub-aar"))
+ }
+ val stubAarTask =
+ tasks.register("stubAar", ZipStubAarTask::class.java) { zipTask ->
+ zipTask.from(unpackedStubAarTask.flatMap { it.outputDir })
+ zipTask.destinationDirectory.set(buildDir.dir("outputs"))
+ zipTask.archiveExtension.set("aar")
+ }
+ publication.artifact(stubAarTask)
+ }
+
+ publication.pom { pom ->
+ if (addStubAar) {
+ pom.packaging = "aar"
+ }
+ addInformativeMetadata(extension, pom)
+ tweakDependenciesMetadata(
+ androidxGroup,
+ pom,
+ androidLibrariesSetProvider,
+ isKmpAnchor,
+ pomPlatform,
+ )
+ }
+ }
+ }
+
+ // Workarounds for https://github.com/gradle/gradle/issues/20011
+ project.tasks.withType(GenerateModuleMetadata::class.java).configureEach { task ->
+ task.doLast {
+ val metadataFile = task.outputFile.asFile.get()
+ val metadata = metadataFile.readText()
+ verifyGradleMetadata(metadata)
+ val sortedMetadata = sortGradleMetadataDependencies(metadata)
+
+ if (metadata != sortedMetadata) {
+ metadataFile.writeText(sortedMetadata)
+ }
+ }
+ }
+ project.tasks.withType(GenerateMavenPom::class.java).configureEach { task ->
+ task.doLast {
+ val pomFile = task.destination
+ val pom = pomFile.readText()
+ val sortedPom = sortPomDependencies(pom)
+
+ if (pom != sortedPom) {
+ pomFile.writeText(sortedPom)
+ }
+ }
+ }
+
+ val buildIdProvider = project.providers.getBuildId()
+ // Workaround for https://github.com/gradle/gradle/issues/31218
+ project.tasks.withType(GenerateModuleMetadata::class.java).configureEach { task ->
+ task.doLast {
+ if (buildIdProvider.isPresent) {
+ val buildId = buildIdProvider.get()
+ val metadata = task.outputFile.asFile.get()
+ val text = metadata.readText()
+ metadata.writeText(
+ text.replace("\"buildId\": .*".toRegex(), "\"buildId:\": \"${buildId}\"")
+ )
+ }
+ }
+ }
+}
+
+/** Looks for a dependencies XML element within [pom] and sorts its contents. */
+fun sortPomDependencies(pom: String): String {
+ // Workaround for using the default namespace in dom4j.
+ val namespaceUris = mapOf("ns" to "http://maven.apache.org/POM/4.0.0")
+ val document = parseXml(pom, namespaceUris)
+
+ // For each element, sort the contained elements in-place.
+ document.rootElement.selectNodes("ns:dependencies").filterIsInstance().forEach {
+ element ->
+ val deps = element.elements()
+ val sortedDeps = deps.toSortedSet(compareBy { it.stringValue }).toList()
+ // Content contains formatting nodes, so to avoid modifying those we replace
+ // each element with the sorted element from its respective index. Note this
+ // will not move adjacent elements, so any comments would remain in their
+ // original order.
+ element.content().replaceAll {
+ val index = sortedDeps.indexOf(it)
+ if (index >= 0) {
+ deps[index]
+ } else {
+ it
+ }
+ }
+ }
+
+ // Write to string. Note that this does not preserve the original indent level, but it
+ // does preserve line breaks -- not that any of this matters for client XML parsing.
+ val stringWriter = StringWriter()
+ XMLWriter(stringWriter).apply {
+ setIndentLevel(2)
+ write(document)
+ close()
+ }
+
+ return stringWriter.toString()
+}
+
+/** Looks for a dependencies JSON element within [metadata] and sorts its contents. */
+fun sortGradleMetadataDependencies(metadata: String): String {
+ val gson = GsonBuilder().create()
+ val jsonObj = gson.fromJson(metadata, JsonObject::class.java)!!
+ jsonObj.getAsJsonArray("variants").forEach { entry ->
+ (entry as? JsonObject)?.getAsJsonArray("dependencies")?.let { jsonArray ->
+ val sortedSet = jsonArray.toSortedSet(compareBy { it.toString() })
+ jsonArray.removeAll { true }
+ sortedSet.forEach { element -> jsonArray.add(element) }
+ }
+ }
+
+ val stringWriter = StringWriter()
+ val jsonWriter = JsonWriter(stringWriter)
+ jsonWriter.setIndent(" ")
+ gson.toJson(jsonObj, jsonWriter)
+ return stringWriter.toString()
+}
+
+/**
+ * Checks the variants field in the metadata file has an entry containing "sourcesElements". All our
+ * publications must be published with a sources variant.
+ */
+fun verifyGradleMetadata(metadata: String) {
+ val gson = GsonBuilder().create()
+ val jsonObj = gson.fromJson(metadata, JsonObject::class.java)!!
+ jsonObj.getAsJsonArray("variants").firstOrNull { variantElement ->
+ variantElement.asJsonObject
+ .get("name")
+ .asString
+ .contains(other = PublishingVariant.SourcesElements.name, ignoreCase = true)
+ }
+ ?: throw Exception(
+ "The ${PublishingVariant.SourcesElements.name} variant must exist in the module file."
+ )
+}
+
+private fun Project.isMultiplatformPublicationEnabled(): Boolean {
+ return extensions.findByType() != null
+}
+
+private fun Project.isValidReleaseComponent(component: SoftwareComponent) =
+ component.name == releaseComponentName()
+
+private fun Project.releaseComponentName() =
+ when {
+ plugins.hasPlugin(KotlinMultiplatformPluginWrapper::class.java) -> "kotlin"
+ plugins.hasPlugin(JavaPlugin::class.java) -> "java"
+ else -> "release"
+ }
+
+private fun Project.validateCoordinatesAndGetGroup(extension: AndroidXExtension): LibraryGroup {
+ val mavenGroup = extension.mavenGroup
+ if (mavenGroup == null) {
+ val groupExplanation = extension.explainMavenGroup().joinToString("\n")
+ throw Exception("You must specify mavenGroup for $path :\n$groupExplanation")
+ }
+ val strippedGroupId = mavenGroup.group.substringAfterLast(".")
+ if (
+ !extension.bypassCoordinateValidation &&
+ mavenGroup.group.startsWith("androidx") &&
+ !name.startsWith(strippedGroupId)
+ ) {
+ throw Exception("Your artifactId must start with '$strippedGroupId'. (currently is $name)")
+ }
+ return mavenGroup
+}
+
+private fun Project.addInformativeMetadata(extension: AndroidXExtension, pom: MavenPom) {
+ pom.name.set(extension.name)
+ pom.description.set(extension.description)
+ pom.url.set(
+ provider {
+ fun defaultUrl() =
+ "https://developer.android.com/jetpack/androidx/releases/" +
+ extension.mavenGroup!!.group.removePrefix("androidx.").replace(".", "-") +
+ "#" +
+ extension.project.version()
+ getAlternativeProjectUrl() ?: defaultUrl()
+ }
+ )
+ pom.inceptionYear.set(extension.inceptionYear)
+ pom.licenses { licenses ->
+ licenses.license { license ->
+ license.name.set(extension.license.name)
+ license.url.set(extension.license.url)
+ license.distribution.set("repo")
+ }
+
+ for (extraLicense in extension.getExtraLicenses()) {
+ licenses.license { license ->
+ license.name.set(provider { extraLicense.name!! })
+ license.url.set(provider { extraLicense.url!! })
+ license.distribution.set("repo")
+ }
+ }
+ }
+ pom.scm { scm ->
+ scm.url.set("https://cs.android.com/androidx/platform/frameworks/support")
+ scm.connection.set(ANDROID_GIT_URL)
+ }
+ pom.organization { org -> org.name.set("The Android Open Source Project") }
+ pom.developers { devs ->
+ devs.developer { dev -> dev.name.set("The Android Open Source Project") }
+ }
+}
+
+private fun tweakDependenciesMetadata(
+ mavenGroup: LibraryGroup,
+ pom: MavenPom,
+ androidLibrariesSetProvider: Provider>,
+ kmpAnchor: Boolean,
+ pomPlatform: String?,
+) {
+ pom.withXml { xml ->
+ // The following code depends on getProjectsMap which is only available late in
+ // configuration at which point Java Library plugin's variants are not allowed to be
+ // modified. TODO remove the use of getProjectsMap and move to earlier configuration.
+ // For more context see:
+ // https://android-review.googlesource.com/c/platform/frameworks/support/+/1144664/8/buildSrc/src/main/kotlin/androidx/build/MavenUploadHelper.kt#177
+ assignSingleVersionDependenciesInGroupForPom(xml, mavenGroup)
+ assignAarDependencyTypes(xml, androidLibrariesSetProvider.get())
+ ensureConsistentJvmSuffix(xml)
+
+ if (kmpAnchor && pomPlatform != null) {
+ insertDefaultMultiplatformDependencies(xml, pomPlatform)
+ }
+ }
+}
+
+// TODO(aurimas): remove this when Gradle bug is fixed.
+// https://github.com/gradle/gradle/issues/3170
+fun assignAarDependencyTypes(xml: XmlProvider, androidLibrariesSet: Set) {
+ val xmlElement = xml.asElement()
+ val dependencies = xmlElement.find { it.nodeName == "dependencies" } as? org.w3c.dom.Element
+
+ dependencies?.getElementsByTagName("dependency")?.forEach { dependency ->
+ val groupId =
+ dependency.find { it.nodeName == "groupId" }?.textContent
+ ?: throw IllegalArgumentException("Failed to locate groupId node")
+ val artifactId =
+ dependency.find { it.nodeName == "artifactId" }?.textContent
+ ?: throw IllegalArgumentException("Failed to locate artifactId node")
+ if (androidLibrariesSet.contains("$groupId:$artifactId")) {
+ dependency.appendElement("type", "aar")
+ }
+ }
+}
+
+fun insertDefaultMultiplatformDependencies(xml: XmlProvider, platformId: String) {
+ val xmlElement = xml.asElement()
+ val groupId =
+ xmlElement.find { it.nodeName == "groupId" }?.textContent
+ ?: throw IllegalArgumentException("Failed to locate groupId node")
+ val artifactId =
+ xmlElement.find { it.nodeName == "artifactId" }?.textContent
+ ?: throw IllegalArgumentException("Failed to locate artifactId node")
+ val version =
+ xmlElement.find { it.nodeName == "version" }?.textContent
+ ?: throw IllegalArgumentException("Failed to locate version node")
+
+ // Find the top-level element or add one if there are no other dependencies.
+ val dependencies =
+ xmlElement.find { it.nodeName == "dependencies" }
+ ?: xmlElement.appendElement("dependencies")
+ dependencies.appendElement("dependency").apply {
+ appendElement("groupId", groupId)
+ appendElement("artifactId", "$artifactId-$platformId")
+ appendElement("version", version)
+ if (platformId == PlatformIdentifier.ANDROID.id) {
+ appendElement("type", "aar")
+ }
+ appendElement("scope", "compile")
+ }
+}
+
+private fun org.w3c.dom.Node.appendElement(
+ tagName: String,
+ textValue: String? = null,
+): org.w3c.dom.Element {
+ val element = ownerDocument.createElement(tagName)
+ appendChild(element)
+
+ if (textValue != null) {
+ val textNode = ownerDocument.createTextNode(textValue)
+ element.appendChild(textNode)
+ }
+
+ return element
+}
+
+private fun org.w3c.dom.Node.find(predicate: (org.w3c.dom.Node) -> Boolean): org.w3c.dom.Node? {
+ val iterator = childrenIterator()
+ while (iterator.hasNext()) {
+ val node = iterator.next()
+ if (predicate(node)) {
+ return node
+ }
+ }
+ return null
+}
+
+/**
+ * Modifies the given .pom to specify that every dependency in refers to a single version
+ * and can't be automatically promoted to a new version. This will replace, for example, a version
+ * string of "1.0" with a version string of "[1.0]"
+ *
+ * Note: this is not enforced in Gradle nor in plain Maven (without the Enforcer plugin)
+ * (https://github.com/gradle/gradle/issues/8297)
+ */
+fun assignSingleVersionDependenciesInGroupForPom(xml: XmlProvider, mavenGroup: LibraryGroup) {
+ if (!mavenGroup.requireSameVersion) {
+ return
+ }
+
+ val dependencies =
+ xml.asElement().find { it.nodeName == "dependencies" } as? org.w3c.dom.Element ?: return
+
+ dependencies.getElementsByTagName("dependency").forEach { dependency ->
+ val groupId =
+ dependency.find { it.nodeName == "groupId" }?.textContent
+ ?: throw IllegalArgumentException("Failed to locate groupId node")
+ if (groupId == mavenGroup.group) {
+ val versionNode =
+ dependency.find { it.nodeName == "version" }
+ ?: throw IllegalArgumentException("Failed to locate version node")
+ val version = versionNode.textContent
+ if (isVersionRange(version)) {
+ throw GradleException("Unsupported version '$version': already is a version range")
+ }
+ val pinnedVersion = "[$version]"
+ versionNode.textContent = pinnedVersion
+ }
+ }
+}
+
+private fun isVersionRange(text: String): Boolean {
+ return text.contains("[") ||
+ text.contains("]") ||
+ text.contains("(") ||
+ text.contains(")") ||
+ text.contains(",")
+}
+
+/**
+ * Ensures that artifactIds are consistent when using configuration caching. A workaround for
+ * https://github.com/gradle/gradle/issues/18369
+ */
+fun ensureConsistentJvmSuffix(xml: XmlProvider) {
+ val dependencies =
+ xml.asElement().find { it.nodeName == "dependencies" } as? org.w3c.dom.Element ?: return
+
+ dependencies.getElementsByTagName("dependency").forEach { dependency ->
+ val artifactId =
+ dependency.find { it.nodeName == "artifactId" }
+ ?: throw IllegalArgumentException("Failed to locate artifactId node")
+ // kotlinx-coroutines-core is only a .pom and only depends on kotlinx-coroutines-core-jvm,
+ // so the two artifacts should be approximately equivalent. However,
+ // when loading from configuration cache, Gradle often returns a different resolution.
+ // We replace it here to ensure consistency and predictability, and
+ // to avoid having to rerun any zip tasks that include it
+ if (artifactId.textContent == "kotlinx-coroutines-core-jvm") {
+ artifactId.textContent = "kotlinx-coroutines-core"
+ }
+ }
+}
+
+private fun Project.appliesJavaGradlePluginPlugin() = pluginManager.hasPlugin("java-gradle-plugin")
+
+private const val ANDROID_GIT_URL =
+ "scm:git:https://android.googlesource.com/platform/frameworks/support"
+
+// Name of KMP root publication
+// https://github.com/JetBrains/kotlin/blob/bf6cb00fa8db7879c323bad863f58a0545c3d655/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/publishing/Publishing.kt#L54
+internal const val KMP_ANCHOR_PUBLICATION_NAME = "kotlinMultiplatform"
+
+@DisableCachingByDefault(because = "Not worth caching")
+internal abstract class ZipStubAarTask : Zip()
diff --git a/buildSrc-fork/private/src/main/kotlin/androidx/build/MaxDepVersions.kt b/buildSrc-fork/private/src/main/kotlin/androidx/build/MaxDepVersions.kt
new file mode 100644
index 0000000000000..e977fcfba03c9
--- /dev/null
+++ b/buildSrc-fork/private/src/main/kotlin/androidx/build/MaxDepVersions.kt
@@ -0,0 +1,42 @@
+/*
+ * Copyright 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package androidx.build
+
+import org.gradle.api.Project
+import org.gradle.api.artifacts.component.ModuleComponentSelector
+
+/**
+ * If useMaxDepVersions is set, iterate through all the dependencies and substitute any androidx
+ * artifact dependency with the local tip of tree version of the library.
+ */
+internal fun Project.configureMaxDepVersions(extension: AndroidXExtension) {
+ if (!usingMaxDepVersions().get()) return
+ val projectModules = extension.mavenCoordinatesToProjectPathMap
+ configurations.configureEach { configuration ->
+ configuration.resolutionStrategy.dependencySubstitution.apply {
+ all { dep ->
+ val requested = dep.requested
+ if (requested is ModuleComponentSelector) {
+ val module = requested.group + ":" + requested.module
+ if (projectModules.containsKey(module)) {
+ dep.useTarget(project(projectModules[module]!!))
+ }
+ }
+ }
+ }
+ }
+}
diff --git a/buildSrc-fork/private/src/main/kotlin/androidx/build/PrintProjectCoordinatesTask.kt b/buildSrc-fork/private/src/main/kotlin/androidx/build/PrintProjectCoordinatesTask.kt
new file mode 100644
index 0000000000000..83d9d18feabc5
--- /dev/null
+++ b/buildSrc-fork/private/src/main/kotlin/androidx/build/PrintProjectCoordinatesTask.kt
@@ -0,0 +1,108 @@
+/*
+ * Copyright 2022 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package androidx.build
+
+import java.io.File
+import org.gradle.api.DefaultTask
+import org.gradle.api.tasks.Internal
+import org.gradle.api.tasks.TaskAction
+import org.gradle.work.DisableCachingByDefault
+
+// This task prints the coordinates (group/artifact/version) of a project
+@DisableCachingByDefault(because = "The purpose of this task is to print information")
+abstract class PrintProjectCoordinatesTask : DefaultTask() {
+
+ fun configureWithAndroidXExtension(androidXExtension: AndroidXExtension) {
+ projectGroup = androidXExtension.mavenGroup
+ groupExplanation = androidXExtension.explainMavenGroup()
+ projectName = project.name
+ version = project.version.toString()
+ projectDir = project.projectDir.relativeTo(project.rootDir)
+ projectPath = project.path
+ }
+
+ @Internal // Task is always out-of-date: no need to track inputs
+ var projectGroup: LibraryGroup? = null
+
+ @Internal // Task is always out-of-date: no need to track inputs
+ var groupExplanation: List? = null
+
+ @Internal // Task is always out-of-date: no need to track inputs
+ var projectName: String? = null
+
+ @Internal // Task is always out-of-date: no need to track inputs
+ var version: String? = null
+
+ @Internal // Task is always out-of-date: no need to track inputs
+ var projectDir: File? = null
+
+ @Internal // Task is always out-of-date: no need to track inputs
+ var projectPath: String? = null
+
+ @TaskAction
+ fun printInformation() {
+ val projectGroup = projectGroup
+ val versionFrom =
+ if (projectGroup?.atomicGroupVersion == null) {
+ "build.gradle: mavenVersion"
+ } else {
+ "group.atomicGroupVersion"
+ }
+
+ val groupExplanation = groupExplanation!!
+ val lines =
+ mutableListOf(listOf("filepath: $projectDir/build.gradle ", "(from settings.gradle)"))
+ // put each component of the explanation on its own line
+ groupExplanation.forEachIndexed { i, component ->
+ if (i == 0) lines.add(listOf("group : ${projectGroup?.group} ", component))
+ else lines.add(listOf("", component))
+ }
+ lines.add(listOf("artifact: $projectName ", "(from project name)"))
+ lines.add(listOf("version : $version ", "(from $versionFrom)"))
+ printTable(lines)
+ }
+
+ private fun printTable(lines: List>) {
+ val columnSizes = getColumnSizes(lines)
+ for (line in lines) {
+ println(formatRow(line, columnSizes))
+ }
+ }
+
+ private fun formatRow(line: List, columnSizes: List): String {
+ var result = ""
+ for (i in line.indices) {
+ val word = line[i]
+ val columnSize = columnSizes[i]
+ // only have to pad columns before the last column
+ result += if (i != line.size - 1) word.padEnd(columnSize) else word
+ }
+ return result
+ }
+
+ private fun getColumnSizes(lines: List>): List {
+ val maxLengths = mutableListOf()
+ for (line in lines) {
+ for (i in line.indices) {
+ val word = line[i]
+ if (maxLengths.size <= i) maxLengths.add(0)
+ if (maxLengths[i] < word.length) maxLengths[i] = word.length
+ }
+ }
+ return maxLengths
+ }
+}
diff --git a/buildSrc-fork/private/src/main/kotlin/androidx/build/ProguardConfiguration.kt b/buildSrc-fork/private/src/main/kotlin/androidx/build/ProguardConfiguration.kt
new file mode 100644
index 0000000000000..9d1cc0ba76ea6
--- /dev/null
+++ b/buildSrc-fork/private/src/main/kotlin/androidx/build/ProguardConfiguration.kt
@@ -0,0 +1,107 @@
+/*
+ * Copyright 2025 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package androidx.build
+
+import com.android.build.api.dsl.ConsumerKeepRules
+import com.android.build.api.dsl.LibraryDefaultConfig
+import java.io.File
+import org.gradle.api.DefaultTask
+import org.gradle.api.Project
+import org.gradle.api.file.ConfigurableFileCollection
+import org.gradle.api.file.DirectoryProperty
+import org.gradle.api.file.RegularFileProperty
+import org.gradle.api.plugins.JavaPluginExtension
+import org.gradle.api.provider.Property
+import org.gradle.api.tasks.Input
+import org.gradle.api.tasks.InputFile
+import org.gradle.api.tasks.InputFiles
+import org.gradle.api.tasks.OutputDirectory
+import org.gradle.api.tasks.PathSensitive
+import org.gradle.api.tasks.PathSensitivity
+import org.gradle.api.tasks.TaskAction
+import org.gradle.work.DisableCachingByDefault
+
+/**
+ * Add a blank consumer proguard rules file to the JAR if the library has not set up an explicit set
+ * of rules.
+ */
+internal fun Project.setUpBlankProguardFileForJarIfNeeded(javaExtension: JavaPluginExtension) {
+ if (project.multiplatformExtension != null) return // skip KMP projects
+ val mainSources = javaExtension.sourceSets.getByName("main")
+ val provider =
+ tasks.register("emptyProguardFileCopy", BlankProguardFileGenerator::class.java) {
+ it.blankProguardFile.set(blankProguardRules())
+ it.outputDirectory.set(layout.buildDirectory.dir("blankProguard"))
+ it.nonGeneratedResources.from(mainSources.resources.sourceDirectories)
+ // unique name like "androidx-arch-core-core-common"
+ it.libraryName.set("androidx${project.path.replace(":", "-")}")
+ }
+ mainSources.output.dir(provider.flatMap { it.outputDirectory })
+}
+
+/**
+ * Add a blank consumer proguard rules file to the AAR if the library has not set up an explicit set
+ * of rules.
+ */
+internal fun Project.setUpBlankProguardFileForAarIfNeeded(config: LibraryDefaultConfig) {
+ if (config.consumerProguardFiles.isEmpty()) {
+ config.consumerProguardFiles.add(blankProguardRules())
+ }
+}
+
+/**
+ * Add a blank consumer proguard rules file to the AAR if the library has not set up an explicit set
+ * of rules.
+ */
+@Suppress("UnstableApiUsage") // b/393137152
+internal fun Project.setUpBlankProguardFileForKmpAarIfNeeded(consumerKeepRules: ConsumerKeepRules) {
+ if (consumerKeepRules.files.isEmpty()) {
+ consumerKeepRules.publish = true
+ consumerKeepRules.files.add(blankProguardRules())
+ }
+}
+
+@DisableCachingByDefault
+abstract class BlankProguardFileGenerator : DefaultTask() {
+ @get:[InputFile PathSensitive(PathSensitivity.NONE)]
+ abstract val blankProguardFile: RegularFileProperty
+
+ @get:[InputFiles PathSensitive(PathSensitivity.RELATIVE)]
+ abstract val nonGeneratedResources: ConfigurableFileCollection
+
+ @get:Input abstract val libraryName: Property
+
+ @get:OutputDirectory abstract val outputDirectory: DirectoryProperty
+
+ @TaskAction
+ fun copyEmptyFile() {
+ outputDirectory.get().asFile.deleteRecursively()
+ val hasExplicitProguardFile =
+ nonGeneratedResources.any { File(it, "META-INF/proguard").exists() }
+ // Check if the library already contains explicit proguard file
+ if (hasExplicitProguardFile) return
+ blankProguardFile
+ .get()
+ .asFile
+ .copyTo(
+ File(outputDirectory.get().asFile, "META-INF/proguard/${libraryName.get()}.pro")
+ )
+ }
+}
+
+private fun Project.blankProguardRules(): File =
+ project.getSupportRootFolder().resolve("buildSrc/blank-proguard-rules/proguard-rules.pro")
diff --git a/buildSrc-fork/private/src/main/kotlin/androidx/build/ProjectConfigValidators.kt b/buildSrc-fork/private/src/main/kotlin/androidx/build/ProjectConfigValidators.kt
new file mode 100644
index 0000000000000..b2b815e4660e5
--- /dev/null
+++ b/buildSrc-fork/private/src/main/kotlin/androidx/build/ProjectConfigValidators.kt
@@ -0,0 +1,122 @@
+/*
+ * Copyright 2023 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package androidx.build
+
+import java.io.File
+import org.gradle.api.GradleException
+import org.gradle.api.Project
+
+/** Validates the project's Maven group against Jetpack guidelines. */
+fun Project.validateProjectMavenGroup(groupId: String) {
+ if (groupId.contains('-')) {
+ throw GradleException(
+ "Invalid Maven group! Found invalid character '-' in Maven group \"$groupId\" for " +
+ "$displayName.\n\nWas this supposed to be a sub-artifact of an existing group, " +
+ "ex. \"x.y:y-z\" rather than \"x.y-z:z\"?"
+ )
+ }
+}
+
+// Translate common phrases and marketing names into Maven name component equivalents.
+private val mavenNameMap =
+ mapOf(
+ "android for cars" to "car",
+ "android wear" to "wear",
+ "compose glimmer" to "glimmer",
+ "internationalization" to "i18n",
+ "kotlin extensions" to "ktx",
+ "lint checks" to "lint",
+ "material components" to "material",
+ "material3 components" to "material3",
+ "workmanager" to "work",
+ "windowmanager" to "window",
+ )
+
+// Allow a small set of common Maven name components that don't need to appear in the project name.
+private val mavenNameAllowlist = setOf("extension", "extensions", "for", "integration", "with")
+
+/** Validates the project's Maven name against Jetpack guidelines. */
+fun Project.validateProjectMavenName(mavenName: String, groupId: String) {
+ // Tokenize the Maven name into components. This is *very* permissive regarding separators, and
+ // we may want to revisit that policy in the future.
+ val nameComponents =
+ mavenName
+ .lowercase()
+ .let { name ->
+ mavenNameMap.entries.fold(name) { newName, entry ->
+ newName.replace(entry.key, entry.value)
+ }
+ }
+ .split(" ", ",", ":", "-")
+ .toMutableList() - mavenNameAllowlist
+
+ // Remaining components *must* appear in the Maven coordinate. Shortening long (>10 char) words
+ // to five letters or more is allowed, as is changing the pluralization of words.
+ nameComponents
+ .find { nameComponent ->
+ !name.contains(nameComponent) &&
+ !groupId.contains(nameComponent) &&
+ !(nameComponent.length > 10 && name.contains(nameComponent.substring(0, 5))) &&
+ !(nameComponent.endsWith("s") && name.contains(nameComponent.dropLast(1)))
+ }
+ ?.let { missingComponent ->
+ throw GradleException(
+ "Invalid Maven name! Found \"$missingComponent\" in Maven name for $displayName, " +
+ "but not project name.\n\nConsider removing \"$missingComponent\" from" +
+ "\"$mavenName\"."
+ )
+ }
+}
+
+private const val GROUP_PREFIX = "androidx."
+
+/** Validates the project structure against Jetpack guidelines. */
+fun Project.validateProjectStructure(groupId: String) {
+ if (!project.isValidateProjectStructureEnabled()) {
+ return
+ }
+
+ val shortGroupId =
+ if (groupId.startsWith(GROUP_PREFIX)) {
+ groupId.substring(GROUP_PREFIX.length)
+ } else {
+ groupId
+ }
+
+ // Fully-qualified Gradle project name should match the Maven coordinate.
+ val expectName = ":${shortGroupId.replace(".",":")}:${project.name}"
+ val actualName = project.path
+ if (expectName != actualName) {
+ throw GradleException(
+ "Invalid project structure! Expected $expectName as project name, found $actualName"
+ )
+ }
+
+ // Project directory should match the Maven coordinate.
+ val expectDir = shortGroupId.replace(".", File.separator) + "${File.separator}${project.name}"
+ // Canonical projectDir is needed because sometimes, at least in tests, on OSX, supportRoot
+ // starts with /var, and projectDir starts with /private/var (which are the same thing)
+ val canonicalProjectDir = project.projectDir.canonicalFile
+ val actualDir =
+ canonicalProjectDir.toRelativeString(project.getSupportRootFolder().canonicalFile)
+ if (expectDir != actualDir) {
+ throw GradleException(
+ "Invalid project structure! Expected $expectDir as project directory, found " +
+ actualDir
+ )
+ }
+}
diff --git a/buildSrc-fork/private/src/main/kotlin/androidx/build/ProjectCreatorTask.kt b/buildSrc-fork/private/src/main/kotlin/androidx/build/ProjectCreatorTask.kt
new file mode 100644
index 0000000000000..a90cb71df01fc
--- /dev/null
+++ b/buildSrc-fork/private/src/main/kotlin/androidx/build/ProjectCreatorTask.kt
@@ -0,0 +1,675 @@
+/*
+ * Copyright 2025 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// This suppression is for usage of UserInputHandler and UserQuestions (from Gradle).
+// For more information, see https://github.com/gradle/gradle/issues/28216
+@file:Suppress("InternalGradleApiUsage")
+
+package androidx.build
+
+import com.google.common.annotations.VisibleForTesting
+import java.io.File
+import java.time.LocalDate
+import org.gradle.api.DefaultTask
+import org.gradle.api.internal.tasks.userinput.UserInputHandler
+import org.gradle.api.internal.tasks.userinput.UserQuestions
+import org.gradle.api.tasks.TaskAction
+import org.gradle.work.DisableCachingByDefault
+import org.tomlj.Toml
+import org.tomlj.TomlParseResult
+import org.tomlj.TomlTable
+
+@DisableCachingByDefault(because = "Interactive task, must run every time")
+abstract class ProjectCreatorTask : DefaultTask() {
+ private val supportDir = project.getSupportRootFolder()
+
+ @TaskAction
+ fun exec() {
+ val spec: ProjectSpec = promptForProjectSpec()
+ val catalogEditor = VersionCatalogEditor(File(supportDir, "libraryversions.toml"), spec)
+ val settingsEditor = GradleSettingsEditor(File(supportDir, "settings.gradle"))
+ val docsTotBuildGradleEditor =
+ DocsTotBuildGradleEditor(File(supportDir, "docs-tip-of-tree/build.gradle"))
+ val projectGenerator = ProjectGenerator()
+
+ catalogEditor.updateLibraryVersionsToml()
+ settingsEditor.updateSettingsGradle(spec)
+ docsTotBuildGradleEditor.updateDocsTotBuildGradle(spec)
+ projectGenerator.createDirectories(spec, catalogEditor.isGroupIdAtomic())
+
+ printTodoList(spec)
+ }
+
+ private fun promptForProjectSpec(): ProjectSpec {
+ // This println here is intentional, it allows any error messages from groupIdIsValid() and
+ // artifactIdIsValid() to be shown right after the respective prompt. For some reason,
+ // without this empty println, those printlns in the validation functions don't get flushed
+ // until after the user tries the prompt for the second time.
+ println()
+ val userInput = services.get(UserInputHandler::class.java)
+
+ var groupId = ""
+ do {
+ groupId =
+ userInput
+ .askUser { interaction: UserQuestions ->
+ interaction.askQuestion(
+ "Enter group id (must start with 'androidx', e.g. androidx.core)",
+ "none",
+ )
+ }
+ .get()
+ } while (!isGroupIdValid(groupId))
+ var artifactId = ""
+ do {
+ artifactId =
+ userInput
+ .askUser { interaction: UserQuestions ->
+ interaction.askQuestion("Enter artifact id (e.g. core-telecom)", "none")
+ }
+ .get()
+ } while (!isArtifactIdValid(groupId, artifactId))
+
+ val projectTypeName =
+ userInput
+ .askUser { interaction: UserQuestions ->
+ interaction.selectOption(
+ "Please choose the type of project you would like to create",
+ ProjectType.entries.map { it.description },
+ ProjectType.ANDROID_LIBRARY.description,
+ )
+ }
+ .get()
+ val projectDescription =
+ userInput
+ .askUser { interaction: UserQuestions ->
+ interaction.askQuestion("Enter project description", "none")
+ }
+ .get()
+
+ val projectType = ProjectType.entries.find { it.description == projectTypeName }
+
+ if (projectType == null) {
+ error("Unknown project type: $projectTypeName")
+ }
+
+ return ProjectSpec(groupId, artifactId, projectType, projectDescription, supportDir)
+ }
+
+ private fun printTodoList(projectSpec: ProjectSpec) {
+ val buildGradlePath = projectSpec.fullArtifactPath.resolve("build.gradle")
+ val ownersFilePath = projectSpec.fullArtifactPath.resolve("OWNERS")
+ val packageDocsPath =
+ getPackageDocumentationFileDir(projectSpec)
+ .resolve(
+ getPackageDocumentationFilename(
+ projectSpec.groupIdWithPrefix,
+ projectSpec.artifactId,
+ )
+ )
+
+ println(
+ """
+ ---
+ Created the project. The following TODOs need to be completed by you:
+
+ 1. Check that the OWNERS file is in the correct place. It is currently at:
+ ${ownersFilePath.path}
+ 2. Add your name (and others) to the OWNERS file:
+ ${ownersFilePath.path}
+ 3. Check that the correct library version is assigned in the build.gradle:
+ ${buildGradlePath.path}
+ 4. Fill out the project/module name in the build.gradle:
+ ${buildGradlePath.path}
+ 5. Update the project/module package documentation:
+ ${packageDocsPath.path}
+ 6. Check the libraryversions.toml file:
+ ${supportDir.resolve("libraryversions.toml").path}
+ """
+ .trimIndent()
+ )
+ }
+}
+
+@VisibleForTesting
+internal class GradleSettingsEditor(val settingsGradleFile: File) {
+ fun updateSettingsGradle(spec: ProjectSpec) {
+ val settingsLines = settingsGradleFile.readLines().toMutableList()
+ val newLine = getNewSettingsGradleLine(spec)
+
+ val insertLine =
+ settingsLines.indexOfFirst { it.contains("includeProject") && it > newLine }
+ if (insertLine != -1) {
+ settingsLines.add(insertLine, newLine)
+ } else {
+ settingsLines.add(newLine)
+ }
+
+ settingsGradleFile.writeText(settingsLines.joinToString("\n") + "\n")
+ }
+
+ private fun getNewSettingsGradleLine(spec: ProjectSpec): String {
+ val buildType = getBuildType(spec)
+ val gradlePath = getGradleProjectCoordinates(spec.groupId, spec.artifactId)
+ return "includeProject(\"$gradlePath\", [BuildType.$buildType])"
+ }
+
+ private fun getBuildType(spec: ProjectSpec): String {
+ return if (isComposeProject(spec.groupId, spec.artifactId)) {
+ "COMPOSE"
+ } else if (spec.projectType == ProjectType.KMP) {
+ "KMP"
+ } else {
+ "MAIN"
+ }
+ }
+}
+
+@VisibleForTesting
+internal class VersionCatalogEditor(val tomlFile: File, val spec: ProjectSpec) {
+
+ /**
+ * Checks if a group ID is atomic using the libraryversions.toml file.
+ *
+ * If one already exists, then this function evaluates the group id and returns the appropriate
+ * atomicity. Otherwise, it returns False.
+ *
+ * Example of an atomic library group: ACTIVITY = { group = "androidx.work", atomicGroupVersion
+ * = "WORK" } Example of a non-atomic library group: WEAR = { group = "androidx.wear" }
+ */
+ fun isGroupIdAtomic(): Boolean {
+ val tomlParseResult: TomlParseResult = Toml.parse(tomlFile.toPath())
+ val groupsTable = tomlParseResult.getTable("groups") ?: return false
+ val groupEntry = groupsTable.getTable(getGroupIdVersionMacro(spec.groupId))
+ return groupEntry?.contains("atomicGroupVersion") == true
+ }
+
+ fun updateLibraryVersionsToml() {
+ val tomlLines = tomlFile.readLines().toMutableList()
+ val tomlParseResult: TomlParseResult = Toml.parse(tomlFile.toPath())
+
+ registerVersion(tomlLines, tomlParseResult, spec.groupId)
+ registerGroup(tomlLines, tomlParseResult, spec.groupIdWithPrefix)
+
+ tomlFile.writeText(tomlLines.joinToString("\n", postfix = "\n"))
+ }
+
+ private fun registerVersion(
+ tomlLines: MutableList,
+ parseResult: TomlParseResult,
+ groupId: String,
+ ) {
+ // Update [versions] section
+
+ val groupIdVersionMacro = getGroupIdVersionMacro(groupId)
+
+ val versionsTable: TomlTable? = parseResult.getTable("versions")
+ val versionExists = versionsTable?.contains(groupIdVersionMacro) == true
+
+ if (!versionExists) {
+ val versionsBlockStart = tomlLines.indexOf("[versions]")
+ val groupsBlockStart = tomlLines.indexOf("[groups]")
+
+ val newVersionLine = "$groupIdVersionMacro = \"1.0.0-alpha01\""
+ var versionInsertIndex = groupsBlockStart // Default insert point
+
+ // Find the correct alphabetical insertion index within the [versions] block
+ for (i in versionsBlockStart + 1 until groupsBlockStart) {
+ val line = tomlLines[i].trim()
+ if (line.isEmpty() || line.startsWith("#") || line.startsWith("[")) continue
+ if (line > newVersionLine) {
+ versionInsertIndex = i
+ break
+ }
+ }
+ tomlLines.add(versionInsertIndex, newVersionLine)
+ println("Added version entry for '$groupIdVersionMacro' in libraryversions.toml.")
+ } else {
+ println(
+ "Version entry for '$groupIdVersionMacro' already exists in libraryversions.toml. Skipping."
+ )
+ }
+ }
+
+ private fun registerGroup(
+ tomlLines: MutableList,
+ parseResult: TomlParseResult,
+ groupId: String,
+ ) {
+ // update [groups] section
+
+ val groupIdVersionMacro = getGroupIdVersionMacro(groupId)
+
+ // Re-find groupsBlockStart as tomlLines might have been modified
+ val newGroupsBlockStart = tomlLines.indexOf("[groups]")
+
+ val groupsTable: TomlTable? = parseResult.getTable("groups")
+ // Check if any key within [groups] has a sub-table with 'group = "$groupId"'
+ val groupExists =
+ groupsTable?.keySet()?.any { key ->
+ val groupSpec = groupsTable.getTable(key)
+ groupSpec?.getString("group") == groupId
+ } == true
+
+ if (!groupExists) {
+ val newGroupLine =
+ """$groupIdVersionMacro = { group = "$groupId", atomicGroupVersion = "versions.$groupIdVersionMacro" }"""
+ var groupInsertIndex = tomlLines.size // Default insert at the end
+
+ // Find the correct alphabetical insertion index within the [groups] block
+ for (i in newGroupsBlockStart + 1 until tomlLines.size) {
+ val line = tomlLines[i].trim()
+ if (line.isEmpty() || line.startsWith("#") || line.startsWith("[")) continue
+ if (line > newGroupLine) {
+ groupInsertIndex = i
+ break
+ }
+ }
+ tomlLines.add(groupInsertIndex, newGroupLine)
+ println("Added group entry for '$groupId' in libraryversions.toml.")
+ } else {
+ println("Group entry for '$groupId' already exists in libraryversions.toml. Skipping.")
+ }
+ }
+}
+
+internal class DocsTotBuildGradleEditor(val docsTotBuildGradleFile: File) {
+ fun updateDocsTotBuildGradle(spec: ProjectSpec) {
+ if (
+ ("test" in spec.groupId ||
+ "test" in spec.artifactId ||
+ "benchmark" in spec.groupId ||
+ "benchmark" in spec.artifactId)
+ ) {
+ println(
+ "Skipping docs-tip-of-tree update for test/benchmark library " +
+ "$spec.groupId:$spec.artifactId. Please add manually if needed."
+ )
+ return
+ }
+
+ val newLine = spec.getNewDocsTotBuildGradleLine() ?: return
+ val docLines = docsTotBuildGradleFile.readLines().toMutableList()
+
+ val dependenciesBlockStart =
+ docLines.indexOfFirst { it.trim().startsWith("dependencies {") }
+ if (dependenciesBlockStart == -1) {
+ error("Error: Could not find 'dependencies {' block in " + docsTotBuildGradleFile.path)
+ }
+
+ val newProjectPart = newLine.split("project")[1]
+ val insertLine =
+ docLines.indexOfFirst {
+ it.contains("project") && it.substringAfter("project") >= newProjectPart
+ }
+
+ if (insertLine != -1) {
+ docLines.add(insertLine, newLine)
+ } else {
+ docLines.add(dependenciesBlockStart + 1, newLine)
+ }
+
+ docsTotBuildGradleFile.writeText(docLines.joinToString("\n", postfix = "\n"))
+ }
+
+ private fun ProjectSpec.getNewDocsTotBuildGradleLine(): String? {
+ if ("sample" in artifactId) {
+ println(
+ "Auto-detected sample project. Please add the sample dependency to the " +
+ "androidx block of the library's build.gradle file."
+ )
+ return null
+ }
+ val gradlePath = getGradleProjectCoordinates(groupId, artifactId)
+ return """ ${if (projectType == ProjectType.KMP) "kmpDocs" else "docs"}(project("$gradlePath"))"""
+ }
+}
+
+@VisibleForTesting
+internal class ProjectGenerator {
+ fun createDirectories(spec: ProjectSpec, isGroupIdAtomic: Boolean) {
+ spec.fullArtifactPath.mkdirs()
+
+ // create src dir
+ createSrcDir(spec)
+
+ // create OWNERS file
+ val ownersFile = File(spec.fullArtifactPath, "OWNERS")
+ ownersFile.writeText("# example@google.com\n")
+
+ // create build.gradle file
+ val buildGradleFile = File(spec.fullArtifactPath, "build.gradle")
+ buildGradleFile.writeText(spec.getBuildGradleText(isGroupIdAtomic))
+
+ // Write current.txt, res-current.txt, and restricted_current.txt
+ for (signatureFileName: String in listOf("current", "res-current", "restricted_current")) {
+ val txtFile = File(spec.fullArtifactPath, "api/$signatureFileName.txt")
+ txtFile.parentFile.mkdirs()
+ txtFile.writeText(
+ if (signatureFileName != "res-current") "// Signature format: 4.0\n" else ""
+ )
+ }
+ }
+
+ private fun createSrcDir(spec: ProjectSpec) {
+ val basePath = if (spec.projectType == ProjectType.KMP) "src/commonMain" else "src/main"
+ val fullPath =
+ "$basePath/${spec.projectType.getLanguage()}/androidx/${
+ spec.groupId.replace(
+ ".",
+ "/",
+ )
+ }"
+
+ val docFile =
+ File(
+ spec.fullArtifactPath,
+ "$fullPath/${getPackageDocumentationFilename(spec.groupId, spec.artifactId)}",
+ )
+ docFile.parentFile.mkdirs()
+ docFile.writeText(spec.toPackageDocsText())
+
+ if (spec.projectType == ProjectType.JAVA) {
+ val packageInfoFile = File(spec.fullArtifactPath, "$fullPath/package-info.java")
+
+ packageInfoFile.writeText(spec.getPackageInfoFileText())
+ }
+
+ if (spec.projectType == ProjectType.KMP) {
+ val testFile =
+ File(
+ spec.fullArtifactPath,
+ "${fullPath.replace("commonMain", "commonTest")}/Test.kt",
+ )
+ testFile.parentFile.mkdirs()
+ testFile.writeText(spec.createTestFileText())
+ }
+ }
+
+ private fun ProjectSpec.getPackageInfoFileText(): String {
+ return """
+ ${getAOSPHeader()}
+
+ package androidx.${groupId}.${artifactId.removePrefix(groupId.split(".").last()).removePrefix("-").replace("-", ".")}
+ """
+ .trimIndent()
+ }
+
+ private fun getAOSPHeader(): String {
+ return """
+ /*
+ * Copyright ${getYear()} The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+ """
+ }
+
+ private fun ProjectSpec.createTestFileText(): String {
+ return """
+ ${getAOSPHeader()}
+ package androidx.${groupId}
+
+ class Test {
+ }
+ """
+ .trimIndent()
+ }
+
+ private fun ProjectSpec.toPackageDocsText(): String {
+ return """
+ # Module root
+
+ $groupId $artifactId
+
+ # Package ${generatePackageName(groupId, artifactId)}
+
+ Insert package level documentation here
+ """
+ .trimIndent()
+ }
+
+ private fun ProjectSpec.getBuildGradleText(isGroupIdAtomic: Boolean): String {
+ return """
+ ${getAOSPHeader()}
+
+ /**
+ * This file was created using the `createProject` gradle task (./gradlew createProject)
+ *
+ * Please use the task when creating a new project, rather than copying an existing project and
+ * modifying its settings.
+ */
+ import androidx.build.SoftwareType
+ ${if (projectType == ProjectType.KMP) "import androidx.build.PlatformIdentifier" else ""}
+
+ plugins {
+ id("AndroidXPlugin")
+ ${getGradlePlugin()}
+ }
+
+ dependencies {
+ // Add dependencies here
+ }
+
+ ${
+ when (projectType) {
+ ProjectType.KMP -> """
+ androidXMultiplatform {
+ ${getMultiplatformBuildGradleText()}
+ }
+ """
+ ProjectType.ANDROID_LIBRARY -> """
+ android {
+ namespace = "${generatePackageName(groupId, artifactId)}"
+ }
+ """
+ ProjectType.JAVA -> """
+ java {
+ sourceCompatibility = JavaVersion.VERSION_1_8
+ targetCompatibility = JavaVersion.VERSION_1_8
+ }
+ """
+ }
+ }
+
+ androidx {
+ name = "${groupId}:${artifactId}"
+ type = SoftwareType.${getLibraryType(artifactId)}
+ ${if (isGroupIdAtomic) "" else "mavenVersion = LibraryVersions.${getGroupIdVersionMacro(groupId)}"}
+ inceptionYear = "${getYear()}"
+ description = "$description"
+ }
+ """
+ .trimIndent()
+ }
+
+ private fun ProjectSpec.getMultiplatformBuildGradleText(): String {
+ return """
+ ${
+ if (isComposeProject(groupId, artifactId)) {
+ """
+ androidLibrary {
+ namespace = "androidx.compose.${artifactId.removePrefix("compose-").replace("-", ".")}"
+ compileSdk { version = release(35) }
+ }
+ jvmStubs()
+ linuxX64Stubs()
+
+ defaultPlatform(PlatformIdentifier.ANDROID)
+ """
+ } else {
+ """
+ ios()
+ js()
+ jvm()
+ linux()
+ mac()
+ mingwX64()
+ tvos()
+ wasmJs()
+ watchos()
+
+ defaultPlatform(PlatformIdentifier.JVM)
+ """
+ }
+ }
+
+ sourceSets {
+ commonMain.dependencies {
+ }
+
+ commonTest.dependencies {
+ }
+ ${if (isComposeProject(groupId, artifactId)) {
+ """
+
+ commonStubsMain.dependsOn(commonMain)
+ jvmStubsMain.dependsOn(commonStubsMain)
+ linuxx64StubsMain.dependsOn(commonStubsMain)
+ """
+ } else { "" }}
+ }
+ """
+ }
+
+ private fun ProjectSpec.getGradlePlugin(): String {
+ if (isComposeProject(groupId, artifactId)) {
+ return """id("AndroidXComposePlugin")"""
+ }
+ return when (this.projectType) {
+ ProjectType.ANDROID_LIBRARY -> """id("com.android.library")"""
+ ProjectType.KMP -> ""
+ ProjectType.JAVA -> """id("java-library")"""
+ }
+ }
+
+ private fun ProjectType.getLanguage(): String {
+ return when (this) {
+ ProjectType.ANDROID_LIBRARY -> "kotlin"
+ ProjectType.KMP -> "kotlin"
+ ProjectType.JAVA -> "java"
+ }
+ }
+
+ private fun getYear(): String = LocalDate.now().year.toString()
+}
+
+private fun getPackageDocumentationFileDir(spec: ProjectSpec): File {
+ val subPath =
+ when (spec.projectType) {
+ ProjectType.ANDROID_LIBRARY -> {
+ "src/main/kotlin/"
+ }
+ ProjectType.KMP -> {
+ "src/commonMain/kotlin/"
+ }
+ ProjectType.JAVA -> {
+ "src/main/java/"
+ }
+ } + spec.groupIdWithPrefix.replace('.', '/')
+ return File(spec.fullArtifactPath, subPath)
+}
+
+@VisibleForTesting
+internal enum class ProjectType(val description: String) {
+ ANDROID_LIBRARY("Android (AAR)"),
+ KMP("KMP (All platforms) (AAR)"),
+ JAVA("Java (JVM - JAR)"),
+}
+
+@VisibleForTesting
+internal data class ProjectSpec(
+ val groupIdWithPrefix: String,
+ val artifactId: String,
+ val projectType: ProjectType,
+ val description: String,
+ val supportRoot: File,
+) {
+ val groupId = groupIdWithPrefix.removePrefix("androidx.")
+
+ val fullArtifactPath =
+ File(supportRoot, groupId.replace('.', '/')).resolve(artifactId.removePrefix("compose-"))
+}
+
+@VisibleForTesting
+internal fun isGroupIdValid(groupId: String): Boolean {
+ if (!groupId.startsWith("androidx.")) {
+ println("Group ID must start with 'androidx'.")
+ return false
+ } else if (
+ listOf("compose", "wear", "xr").any { it == groupId.split(".")[1] } &&
+ groupId.split(".").size == 2
+ ) {
+ println(
+ "New ${groupId.split(".")[1]} projects must be nested inside an existing sub-project"
+ )
+ return false
+ } else {
+ return true
+ }
+}
+
+@VisibleForTesting
+internal fun isArtifactIdValid(groupId: String, artifactId: String): Boolean {
+ val finalGroupWord = groupId.substringAfterLast('.')
+ if (!artifactId.startsWith(finalGroupWord)) {
+ println("Artifact ID must start with the last segment of the Group ID ($finalGroupWord).")
+ return false
+ }
+ return true
+}
+
+private fun isComposeProject(groupId: String, artifactId: String): Boolean =
+ "compose" in groupId || "compose" in artifactId
+
+internal fun generatePackageName(groupId: String, artifactId: String): String {
+ val groupLast = groupId.split('.').last()
+
+ val suffix = artifactId.removePrefix(groupLast).replace('-', '.').trim('.')
+
+ return if (suffix.isEmpty()) groupId else "$groupId.$suffix"
+}
+
+internal fun getGroupIdVersionMacro(groupId: String): String {
+ return groupId.removePrefix("androidx.").replace(".", "_").uppercase()
+}
+
+internal fun getGradleProjectCoordinates(groupId: String, artifactId: String): String {
+ return ":${groupId.removePrefix("androidx.").replace(".", ":")}:${artifactId.removePrefix("compose-")}"
+}
+
+internal fun getLibraryType(artifactId: String): String =
+ when {
+ "sample" in artifactId -> "SAMPLES"
+ "compiler" in artifactId -> "ANNOTATION_PROCESSOR"
+ "lint" in artifactId -> "LINT"
+ "inspection" in artifactId -> "IDE_PLUGIN"
+ else -> "PUBLISHED_LIBRARY"
+ }
+
+internal fun getPackageDocumentationFilename(groupId: String, artifactId: String): String {
+ return "androidx-${groupId.replace('.', '-')}-$artifactId-documentation.md"
+}
diff --git a/buildSrc-fork/private/src/main/kotlin/androidx/build/ProjectExt.kt b/buildSrc-fork/private/src/main/kotlin/androidx/build/ProjectExt.kt
new file mode 100644
index 0000000000000..d03e7746fbc3e
--- /dev/null
+++ b/buildSrc-fork/private/src/main/kotlin/androidx/build/ProjectExt.kt
@@ -0,0 +1,67 @@
+/**
+ * Copyright 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
+ * in compliance with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
+ * or implied. See the License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package androidx.build
+
+import java.io.File
+import java.util.Collections
+import java.util.concurrent.locks.ReentrantLock
+import kotlin.concurrent.withLock
+import org.gradle.api.Project
+import org.gradle.api.Task
+import org.gradle.api.provider.Provider
+import org.gradle.api.tasks.TaskProvider
+
+/** Holder class used for lazily registering tasks using the new Lazy task execution API. */
+data class LazyTaskRegistry(
+ private val names: MutableSet = Collections.synchronizedSet(mutableSetOf())
+) {
+ fun once(name: String, f: () -> T): T? {
+ if (names.add(name)) {
+ return f()
+ }
+ return null
+ }
+
+ companion object {
+ private const val KEY = "AndroidXAutoRegisteredTasks"
+ private val lock = ReentrantLock()
+
+ fun get(project: Project): LazyTaskRegistry {
+ val existing = project.extensions.findByName(KEY) as? LazyTaskRegistry
+ if (existing != null) {
+ return existing
+ }
+ return lock.withLock {
+ project.extensions.findByName(KEY) as? LazyTaskRegistry
+ ?: LazyTaskRegistry().also { project.extensions.add(KEY, it) }
+ }
+ }
+ }
+}
+
+inline fun Project.maybeRegister(
+ name: String,
+ crossinline onConfigure: (T) -> Unit,
+ crossinline onRegister: (TaskProvider) -> Unit,
+): TaskProvider {
+ @Suppress("UNCHECKED_CAST")
+ return LazyTaskRegistry.get(project).once(name) {
+ tasks.register(name, T::class.java) { onConfigure(it) }.also(onRegister)
+ } ?: tasks.named(name) as TaskProvider
+}
+
+internal fun Project.lazyReadFile(fileName: String): Provider {
+ val fileProperty = objects.fileProperty().fileValue(File(getSupportRootFolder(), fileName))
+ return providers.fileContents(fileProperty).asText
+}
diff --git a/buildSrc-fork/private/src/main/kotlin/androidx/build/ProjectParser.kt b/buildSrc-fork/private/src/main/kotlin/androidx/build/ProjectParser.kt
new file mode 100644
index 0000000000000..3f7983b195d2b
--- /dev/null
+++ b/buildSrc-fork/private/src/main/kotlin/androidx/build/ProjectParser.kt
@@ -0,0 +1,79 @@
+/*
+ * Copyright 2023 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package androidx.build
+
+import java.io.File
+import java.util.concurrent.ConcurrentHashMap
+import org.gradle.api.Project
+import org.gradle.api.services.BuildService
+import org.gradle.api.services.BuildServiceParameters
+
+abstract class ProjectParser : BuildService {
+ @Transient val cache: MutableMap = ConcurrentHashMap()
+
+ fun get(buildFile: File): ParsedProject {
+ return cache.getOrPut(key = buildFile) {
+ val text = buildFile.readLines()
+ parseProject(text)
+ }
+ }
+
+ private fun parseProject(fileLines: List): ParsedProject {
+ var softwareType: String? = null
+ var publish: String? = null
+ var specifiesVersion = false
+ fileLines.forEach { line ->
+ if (softwareType == null)
+ softwareType = line.extractVariableValue(" type = SoftwareType.")
+ if (publish == null) publish = line.extractVariableValue(" publish = Publish.")
+ if (line.contains("mavenVersion =")) specifiesVersion = true
+ }
+ val softwareTypeEnum = softwareType?.let { SoftwareType.valueOf(it) } ?: SoftwareType.UNSET
+ return ParsedProject(softwareType = softwareTypeEnum, specifiesVersion = specifiesVersion)
+ }
+
+ data class ParsedProject(val softwareType: SoftwareType, val specifiesVersion: Boolean) {
+ fun shouldPublish(): Boolean = softwareType.publish.shouldPublish()
+
+ fun shouldRelease(): Boolean = softwareType.publish.shouldRelease()
+ }
+}
+
+private fun String.extractVariableValue(prefix: String): String? {
+ val declarationIndex = this.indexOf(prefix)
+ if (declarationIndex >= 0) {
+ val suffix = this.substring(declarationIndex + prefix.length)
+ val spaceIndex = suffix.indexOf(" ")
+ if (spaceIndex > 0) return suffix.substring(0, spaceIndex)
+ return suffix
+ }
+ return null
+}
+
+fun Project.parse(): ProjectParser.ParsedProject {
+ return parseBuildFile(project.buildFile)
+}
+
+fun Project.parseBuildFile(buildFile: File): ProjectParser.ParsedProject {
+ val parserProvider =
+ project.gradle.sharedServices.registerIfAbsent(
+ "ProjectParser",
+ ProjectParser::class.java,
+ ) {}
+ val parser = parserProvider.get()
+ return parser.get(buildFile)
+}
diff --git a/buildSrc-fork/private/src/main/kotlin/androidx/build/ProjectResolver.kt b/buildSrc-fork/private/src/main/kotlin/androidx/build/ProjectResolver.kt
new file mode 100644
index 0000000000000..8fddba25d3581
--- /dev/null
+++ b/buildSrc-fork/private/src/main/kotlin/androidx/build/ProjectResolver.kt
@@ -0,0 +1,54 @@
+/*
+ * Copyright 2022 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package androidx.build
+
+import org.gradle.api.Project
+import org.gradle.api.UnknownProjectException
+
+// Resolves the given project, and if it is not found,
+// throws an exception that mentions the active project subset, if any (MAIN, COMPOSE, ...)
+fun Project.resolveProject(projectSpecification: String): Project {
+ try {
+ return project.project(projectSpecification)
+ } catch (e: UnknownProjectException) {
+ val subset = project.getProjectSubset()
+ val subsetDescription =
+ if (subset == null) {
+ ""
+ } else {
+ " in subset $subset"
+ }
+ throw UnknownProjectException(
+ "Project $projectSpecification not found$subsetDescription",
+ e,
+ )
+ }
+}
+
+/**
+ * Returns the name of the subset of projects participating in the build.
+ *
+ * Project subsets are defined in settings.gradle and allow including only a subset of projects in
+ * the build, to make project configuration run more quickly.
+ */
+fun Project.getProjectSubset(): String? {
+ val envProp = project.providers.environmentVariable("ANDROIDX_PROJECTS")
+ if (envProp.isPresent) {
+ return envProp.get().uppercase()
+ }
+ return null
+}
diff --git a/buildSrc-fork/private/src/main/kotlin/androidx/build/PublishingHelper.kt b/buildSrc-fork/private/src/main/kotlin/androidx/build/PublishingHelper.kt
new file mode 100644
index 0000000000000..8a37514941de5
--- /dev/null
+++ b/buildSrc-fork/private/src/main/kotlin/androidx/build/PublishingHelper.kt
@@ -0,0 +1,41 @@
+/*
+ * Copyright 2023 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package androidx.build
+
+import org.gradle.api.Project
+import org.gradle.api.artifacts.Configuration
+import org.gradle.api.component.AdhocComponentWithVariants
+
+internal fun Project.registerAsComponentForPublishing(gradleVariant: Configuration) =
+ components.configureEach {
+ // Android Library project 'release' component
+ // Java Library project 'java' component
+ if (it.name == "release" || it.name == "java") {
+ it as AdhocComponentWithVariants
+ it.addVariantsFromConfiguration(gradleVariant) {}
+ }
+ }
+
+internal fun Project.registerAsComponentForKmpPublishing(gradleVariant: Configuration) =
+ components.configureEach {
+ // Multiplatform library 'adhocKotlin' component
+ // https://github.com/JetBrains/kotlin/blob/bf6cb00fa8db7879c323bad863f58a0545c3d655/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/dsl/KotlinMultiplatformPublishing.kt#L20
+ if (it.name == "adhocKotlin") {
+ it as AdhocComponentWithVariants
+ it.addVariantsFromConfiguration(gradleVariant) {}
+ }
+ }
diff --git a/buildSrc-fork/private/src/main/kotlin/androidx/build/Release.kt b/buildSrc-fork/private/src/main/kotlin/androidx/build/Release.kt
new file mode 100644
index 0000000000000..326c60e605817
--- /dev/null
+++ b/buildSrc-fork/private/src/main/kotlin/androidx/build/Release.kt
@@ -0,0 +1,227 @@
+/*
+ * Copyright 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package androidx.build
+
+import java.io.FileOutputStream
+import java.util.Calendar
+import java.util.GregorianCalendar
+import java.util.zip.ZipEntry
+import java.util.zip.ZipOutputStream
+import org.gradle.api.DefaultTask
+import org.gradle.api.GradleException
+import org.gradle.api.Project
+import org.gradle.api.file.DirectoryProperty
+import org.gradle.api.file.RegularFileProperty
+import org.gradle.api.tasks.InputDirectory
+import org.gradle.api.tasks.Internal
+import org.gradle.api.tasks.OutputFile
+import org.gradle.api.tasks.PathSensitive
+import org.gradle.api.tasks.PathSensitivity
+import org.gradle.api.tasks.TaskAction
+import org.gradle.api.tasks.TaskProvider
+import org.gradle.work.DisableCachingByDefault
+
+/** Zips all artifacts to publish. */
+@DisableCachingByDefault(because = "Zip tasks are not worth caching according to Gradle")
+abstract class GMavenZipTask : DefaultTask() {
+
+ /** Whether this build adds automatic constraints between projects in the same group */
+ @Internal val shouldAddGroupConstraints = project.shouldAddGroupConstraints()
+
+ /** Repository containing artifacts to include */
+ @get:InputDirectory
+ @get:PathSensitive(PathSensitivity.RELATIVE)
+ abstract val projectRepositoryDir: DirectoryProperty
+
+ /** Zip file to save artifacts to */
+ @get:OutputFile abstract val archiveFile: RegularFileProperty
+
+ @TaskAction
+ fun createZip() {
+ if (!shouldAddGroupConstraints.get() && !isSnapshotBuild()) {
+ throw GradleException(
+ """
+ Cannot publish artifacts without setting -P$ADD_GROUP_CONSTRAINTS=true
+
+ This property is required when building artifacts to publish
+
+ (but this property can reduce remote cache usage so it is disabled by default)
+
+ See AndroidXGradleProperties.kt for more information about this property
+ """
+ .trimIndent()
+ )
+ }
+ val sourceDir = projectRepositoryDir.get().asFile
+ ZipOutputStream(FileOutputStream(archiveFile.get().asFile)).use { zipOut ->
+ zipOut.putNextEntry(
+ // Top-level of the ZIP to align with Maven's expected repository structure
+ ZipEntry("m2repository/").also { it.time = CONSTANT_TIME_FOR_ZIP_ENTRIES }
+ )
+ zipOut.closeEntry()
+
+ sourceDir.walkTopDown().forEach { fileOrDir ->
+ if (fileOrDir == sourceDir) return@forEach
+
+ val relativePath = fileOrDir.relativeTo(sourceDir).invariantSeparatorsPath
+ val entryName =
+ "m2repository/$relativePath" + if (fileOrDir.isDirectory) "/" else ""
+
+ zipOut.putNextEntry(
+ ZipEntry(entryName).also { it.time = CONSTANT_TIME_FOR_ZIP_ENTRIES }
+ )
+ if (fileOrDir.isFile) {
+ fileOrDir.inputStream().use { it.copyTo(zipOut) }
+ }
+ zipOut.closeEntry()
+ }
+ }
+ }
+}
+
+/** Handles creating various release tasks that create zips for the maven upload and local use. */
+object Release {
+ @Suppress("MemberVisibilityCanBePrivate")
+ const val PROJECT_ARCHIVE_ZIP_TASK_NAME = "createProjectZip"
+ private const val FULL_ARCHIVE_TASK_NAME = "createArchive"
+ private const val ALL_ARCHIVES_TASK_NAME = "createAllArchives"
+ const val DEFAULT_PUBLISH_CONFIG = "release"
+ const val PROJECT_ZIPS_FOLDER = "per-project-zips"
+ private const val GLOBAL_ZIP_PREFIX = "top-of-tree-m2repository"
+
+ /**
+ * Registers the project to be included in its group's zip file as well as the global zip files.
+ */
+ fun register(project: Project, androidXExtension: AndroidXExtension) {
+ if (!androidXExtension.shouldPublish.get()) {
+ project.logger.info(
+ "project ${project.name} isn't part of release," +
+ " because its \"publish\" property is explicitly set to Publish.NONE"
+ )
+ return
+ }
+ if (!androidXExtension.shouldRelease.get() && !isSnapshotBuild()) {
+ project.logger.info(
+ "project ${project.name} isn't part of release, because its" +
+ " \"publish\" property is SNAPSHOT_ONLY, but it is not a snapshot build"
+ )
+ return
+ }
+ if (!androidXExtension.versionIsSet) {
+ throw IllegalArgumentException(
+ "Cannot register a project to release if it does not have a mavenVersion set up"
+ )
+ }
+
+ val projectZipTask =
+ getProjectZipTask(project, androidXExtension.isIsolatedProjectsEnabled())
+ val zipTasks =
+ listOfNotNull(
+ projectZipTask,
+ getGlobalFullZipTask(project, androidXExtension.isIsolatedProjectsEnabled()),
+ )
+
+ val publishTask = project.tasks.named("publish")
+ zipTasks.forEach { it.configure { zipTask -> zipTask.dependsOn(publishTask) } }
+ }
+
+ /** Registers an archive task as a dependency of the anchor task */
+ private fun Project.addToAnchorTask(task: TaskProvider) {
+ val archiveAnchorTask: TaskProvider =
+ project.rootProject.maybeRegister(
+ name = ALL_ARCHIVES_TASK_NAME,
+ onConfigure = { archiveTask: VerifyLicenseAndVersionFilesTask ->
+ archiveTask.group = "Distribution"
+ archiveTask.description = "Builds all archives for publishing"
+ archiveTask.repositoryDirectory.set(
+ project.rootProject.getRepositoryDirectory()
+ )
+ },
+ onRegister = {},
+ )
+ archiveAnchorTask.configure { it.dependsOn(task) }
+ }
+
+ /**
+ * Creates and returns the task that includes all projects regardless of their release status.
+ */
+ private fun getGlobalFullZipTask(
+ project: Project,
+ projectIsolationEnabled: Boolean,
+ ): TaskProvider? {
+ if (projectIsolationEnabled) return null
+ return project.rootProject.maybeRegister(
+ name = FULL_ARCHIVE_TASK_NAME,
+ onConfigure = { task: GMavenZipTask ->
+ task.archiveFile.set(
+ project.getDistributionDirectory().file("${getZipName(GLOBAL_ZIP_PREFIX)}.zip")
+ )
+ task.projectRepositoryDir.set(project.getRepositoryDirectory())
+ },
+ onRegister = { taskProvider: TaskProvider ->
+ project.addToAnchorTask(taskProvider)
+ },
+ )
+ }
+
+ private fun getProjectZipTask(
+ project: Project,
+ projectIsolationEnabled: Boolean,
+ ): TaskProvider {
+ val taskProvider =
+ project.tasks.register(PROJECT_ARCHIVE_ZIP_TASK_NAME, GMavenZipTask::class.java) {
+ it.archiveFile.set(
+ project.getDistributionDirectory().file(project.getProjectZipPath())
+ )
+ it.projectRepositoryDir.set(project.getPerProjectRepositoryDirectory())
+ }
+ if (!projectIsolationEnabled) {
+ project.addToAnchorTask(taskProvider)
+ project.addZipToAttestation(
+ taskProvider.map { task ->
+ task.archiveFile
+ .get()
+ .asFile
+ .toRelativeString(project.getDistributionDirectory().get().asFile)
+ }
+ )
+ }
+ return taskProvider
+ }
+}
+
+private fun Project.projectZipPrefix(): String {
+ return "${project.group}-${project.name}"
+}
+
+private fun getZipName(fileNamePrefix: String) = "$fileNamePrefix-all"
+
+fun Project.getProjectZipPath(): String {
+ return Release.PROJECT_ZIPS_FOLDER +
+ "/" +
+ // We pass in a "" because that mimics not passing the group to getParams() inside
+ // the getProjectZipTask function
+ getZipName(projectZipPrefix()) +
+ "-${project.version}.zip"
+}
+
+/**
+ * Strip timestamps from the zip entries to generate consistent output. Set to be ths same as what
+ * Gradle uses:
+ * https://github.com/gradle/gradle/blob/master/platforms/core-runtime/files/src/main/java/org/gradle/api/internal/file/archive/ZipEntryConstants.java
+ */
+private val CONSTANT_TIME_FOR_ZIP_ENTRIES =
+ GregorianCalendar(1980, Calendar.FEBRUARY, 1, 0, 0, 0).timeInMillis
diff --git a/buildSrc-fork/private/src/main/kotlin/androidx/build/Samples.kt b/buildSrc-fork/private/src/main/kotlin/androidx/build/Samples.kt
new file mode 100644
index 0000000000000..0e3e1dca9cfe5
--- /dev/null
+++ b/buildSrc-fork/private/src/main/kotlin/androidx/build/Samples.kt
@@ -0,0 +1,93 @@
+/*
+ * Copyright 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package androidx.build
+
+import org.gradle.api.DefaultTask
+import org.gradle.api.Project
+import org.gradle.api.artifacts.Configuration
+import org.gradle.api.attributes.Category
+import org.gradle.api.attributes.DocsType
+import org.gradle.api.attributes.LibraryElements
+import org.gradle.api.attributes.Usage
+import org.gradle.api.file.ConfigurableFileCollection
+import org.gradle.api.file.RegularFileProperty
+import org.gradle.api.tasks.InputFiles
+import org.gradle.api.tasks.OutputFile
+import org.gradle.api.tasks.PathSensitive
+import org.gradle.api.tasks.PathSensitivity
+import org.gradle.api.tasks.TaskAction
+import org.gradle.kotlin.dsl.named
+import org.gradle.work.DisableCachingByDefault
+
+/**
+ * Used to configure a project that will be providing documentation samples.
+ *
+ * Can only be called once so only one samples library can exist per library b/318840087.
+ */
+internal fun Project.configureSamplesProject() {
+ fun Configuration.setResolveSources() {
+ // While a sample library can have more dependencies than the library it has samples
+ // for, in Studio sample code is not executable or inspectable, so we don't need them.
+ isTransitive = false
+ isCanBeConsumed = false
+ attributes {
+ it.attribute(Usage.USAGE_ATTRIBUTE, project.objects.named(Usage.JAVA_RUNTIME))
+ it.attribute(
+ Category.CATEGORY_ATTRIBUTE,
+ project.objects.named(Category.DOCUMENTATION),
+ )
+ it.attribute(
+ DocsType.DOCS_TYPE_ATTRIBUTE,
+ project.objects.named(DocsType.SOURCES),
+ )
+ it.attribute(
+ LibraryElements.LIBRARY_ELEMENTS_ATTRIBUTE,
+ project.objects.named(LibraryElements.JAR),
+ )
+ }
+ }
+
+ val samplesConfiguration =
+ project.configurations.register("samples") {
+ it.isCanBeConsumed = false
+ it.isCanBeResolved = true
+ it.setResolveSources()
+ }
+
+ project.tasks.register("copySampleSourceJars", LazyInputsCopyTask::class.java) { task ->
+ task.inputJars.from(samplesConfiguration.map { it.incoming.files })
+ val srcJarFilename = "${project.name}-${project.version}-samples-sources.jar"
+ task.destinationJar.set(project.layout.buildDirectory.file(srcJarFilename))
+ }
+}
+
+/**
+ * This is necessary because we need to delay artifact resolution until after configuration. If one
+ * sample is used by multiple libraries (e.g. paging-samples) it is copied several times. This is to
+ * avoid caching failures. There should be a better way that avoids needing this.
+ */
+@DisableCachingByDefault(because = "caching large output files is more expensive than copying")
+abstract class LazyInputsCopyTask : DefaultTask() {
+ @get:[InputFiles PathSensitive(value = PathSensitivity.RELATIVE)]
+ abstract val inputJars: ConfigurableFileCollection
+ @get:OutputFile abstract val destinationJar: RegularFileProperty
+
+ @TaskAction
+ fun copyAction() {
+ inputJars.files.single().copyTo(destinationJar.get().asFile, overwrite = true)
+ }
+}
diff --git a/buildSrc-fork/private/src/main/kotlin/androidx/build/SettingsParser.kt b/buildSrc-fork/private/src/main/kotlin/androidx/build/SettingsParser.kt
new file mode 100644
index 0000000000000..6d038613fb500
--- /dev/null
+++ b/buildSrc-fork/private/src/main/kotlin/androidx/build/SettingsParser.kt
@@ -0,0 +1,70 @@
+/*
+ * Copyright 2022 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package androidx.build
+
+import java.io.File
+
+// NOTE: This class is symlinked to
+// playground-common/playground-plugin/src/main/kotlin/androidx/build
+// Please test playground when modifying it.
+/**
+ * Helper class to parse the settings.gradle file from the main build and extract a list of
+ * projects.
+ *
+ * This is used by Playground projects too, so if it is changed please run `cd room3 && ./gradlew
+ * tasks`
+ */
+object SettingsParser {
+ /**
+ * Match lines that start with includeProject, followed by a require argument for project gradle
+ * path and an optional argument for project file path.
+ */
+ private val includeProjectPattern =
+ Regex(
+ """^[\n\r\s]*includeProject\("(?[a-z0-9-:]*)"(,[\n\r\s]*"(?[a-z0-9-/]+))?.*\).*$""",
+ setOf(RegexOption.MULTILINE, RegexOption.IGNORE_CASE),
+ )
+ .toPattern()
+
+ fun findProjects(settingsFile: File): List