add support for com.android.fused-library (#999)

* add support for com.android.fused-library

* api dump

* fix tests

Author: gabrielittner

README.md

@@ -19,6 +19,7 @@ default configuration and allows the most customization.
 The output of the following Gradle plugins is supported to be published with this plugin:
 
 - `com.android.library`
+- `com.android.fused-library`
 - `org.jetbrains.kotlin.jvm`
 - `org.jetbrains.kotlin.multiplatform`
 - `java`

docs/what.md

@@ -103,6 +103,46 @@ the specified variant instead of publishing all of them.
     }
     ```
 
+
+## Android Fused Library
+
+For projects using the `com.android.fused-library` plugin.
+
+=== "build.gradle"
+
+    ```groovy
+    import com.vanniktech.maven.publish.AndroidSingleVariantLibrary
+
+    mavenPublishing {
+      configure(new AndroidFusedLibrary())
+    }
+    ```
+
+=== "build.gradle.kts"
+
+    ```kotlin
+    import com.vanniktech.maven.publish.AndroidFusedLibrary
+
+    mavenPublishing {
+      configure(AndroidFusedLibrary())
+    }
+    ```
+
+!!! warning
+
+    Support for Android fused libraries is considered experimental and might break
+    with future Android Gradle plugin updates.
+
+!!! warning
+
+    Signing is currently unsupported for Android fused libraries.
+
+!!! info
+
+    Configuring source and javadoc publishing is currently not possible and the
+    plugin will always publush empty jars for them.
+
+
 ## Java Library
 
 For projects using the `java-library` plugin.

plugin/api/plugin.api

@@ -1,3 +1,11 @@
+public final class com/vanniktech/maven/publish/AndroidFusedLibrary : com/vanniktech/maven/publish/Platform {
+	public fun <init> ()V
+	public fun equals (Ljava/lang/Object;)Z
+	public fun getJavadocJar ()Lcom/vanniktech/maven/publish/JavadocJar;
+	public fun getSourcesJar ()Z
+	public fun hashCode ()I
+}
+
 public final class com/vanniktech/maven/publish/AndroidMultiVariantLibrary : com/vanniktech/maven/publish/Platform {
 	public fun <init> ()V
 	public fun <init> (Z)V

plugin/src/integrationTest/kotlin/com/vanniktech/maven/publish/MavenPublishPluginPlatformTest.kt

@@ -683,6 +683,38 @@ class MavenPublishPluginPlatformTest {
     assertThat(result).javadocJar().isSigned()
   }
 
+  @TestParameterInjectorTest
+  fun androidFusedLibraryProject(
+    @TestParameter(valuesProvider = AgpVersionProvider::class) agpVersion: AgpVersion,
+  ) {
+    agpVersion.assumeSupportedJdkAndGradleVersion(gradleVersion)
+    assume().that(agpVersion).isAtLeast(AgpVersion.AGP_ALPHA)
+
+    val project = androidFusedLibraryProjectSpec(agpVersion)
+    // TODO: signing plugin currently unsupported
+    val result = project.run(fixtures, testProjectDir, testOptions.copy(signing = TestOptions.Signing.NO_SIGNING))
+
+    assertThat(result).outcome().succeeded()
+    assertThat(result).artifact("aar").exists()
+    // TODO: signing plugin currently unsupported
+    // assertThat(result).artifact("aar").isSigned()
+    assertThat(result).pom().exists()
+    // TODO: signing plugin currently unsupported
+    // assertThat(result).pom().isSigned()
+    assertThat(result).pom().matchesExpectedPom("aar")
+    assertThat(result).module().exists()
+    // TODO: signing plugin currently unsupported
+    // assertThat(result).module().isSigned()
+    assertThat(result).sourcesJar().exists()
+    // TODO: signing plugin currently unsupported
+    // assertThat(result).sourcesJar().isSigned()
+    // TODO: actual sources jar currently unsupported
+    // assertThat(result).sourcesJar().containsAllSourceFiles()
+    assertThat(result).javadocJar().exists()
+    // TODO: signing plugin currently unsupported
+    // assertThat(result).javadocJar().isSigned()
+  }
+
   @TestParameterInjectorTest
   fun javaPlatformProject() {
     val project = javaPlatformProjectSpec()

plugin/src/integrationTest/kotlin/com/vanniktech/maven/publish/MavenPublishPluginSpecialCaseTest.kt

@@ -180,7 +180,7 @@ class MavenPublishPluginSpecialCaseTest {
     val resultSpec = project.copy(
       group = "com.example.test2",
       // the project name is used as default value for the artifact id
-      artifactId = "default-root-project-name",
+      artifactId = "module",
       version = "3.2.1",
     )
     val actualResult = result.copy(projectSpec = resultSpec)

plugin/src/integrationTest/kotlin/com/vanniktech/maven/publish/ProjectSpecRunner.kt

@@ -2,6 +2,7 @@ package com.vanniktech.maven.publish
 
 import java.nio.file.Files
 import java.nio.file.Path
+import kotlin.io.path.absolutePathString
 import kotlin.io.path.copyTo
 import kotlin.io.path.createDirectories
 import kotlin.io.path.invariantSeparatorsPathString
@@ -10,15 +11,16 @@ import org.gradle.testkit.runner.GradleRunner
 
 fun ProjectSpec.run(fixtures: Path, temp: Path, options: TestOptions): ProjectResult {
   val project = temp.resolve("project").apply { createDirectories() }
+  val module = project.resolve("module").apply { createDirectories() }
   val repo = temp.resolve("repo").apply { createDirectories() }
 
-  writeBuildFile(project.resolve("build.gradle"), repo, options)
+  writeBuildFile(module.resolve("build.gradle"), repo, options)
   writeSettingFile(project.resolve("settings.gradle"))
   writeGradleProperties(project.resolve("gradle.properties"), options)
-  writeSourceFiles(fixtures, project)
+  writeSourceFiles(fixtures, module)
   fixtures.resolve("test-secring.gpg").copyTo(project.resolve("test-secring.gpg"))
 
-  val task = ":publishAllPublicationsToTestFolderRepository"
+  val task = ":module:publishAllPublicationsToTestFolderRepository"
   val arguments = mutableListOf(task, "--stacktrace")
   if (supportsConfigCaching()) {
     arguments.add("--configuration-cache")
@@ -35,7 +37,7 @@ fun ProjectSpec.run(fixtures: Path, temp: Path, options: TestOptions): ProjectRe
     result = result,
     task = task,
     projectSpec = this,
-    project = project,
+    project = module,
     repo = repo,
   )
 }
@@ -178,6 +180,7 @@ private fun writeSettingFile(path: Path) {
 
     rootProject.name = "default-root-project-name"
 
+    include(":module")
     """.trimIndent(),
   )
 }
@@ -191,6 +194,7 @@ private fun ProjectSpec.writeGradleProperties(path: Path, options: TestOptions)
       appendLine("kotlin.mpp.androidSourceSetLayoutVersion1.nowarn=true")
       appendLine("org.jetbrains.dokka.experimental.gradle.pluginMode=V2Enabled")
       appendLine("org.jetbrains.dokka.experimental.gradle.pluginMode.noWarn=true")
+      appendLine("android.experimental.fusedLibrarySupport=true")
       appendLine()
 
       if (options.config == TestOptions.Config.PROPERTIES) {
@@ -226,7 +230,7 @@ private fun ProjectSpec.writeGradleProperties(path: Path, options: TestOptions)
         TestOptions.Signing.GPG_KEY -> {
           appendLine("signing.keyId=B89C4055")
           appendLine("signing.password=test")
-          appendLine("signing.secretKeyRingFile=test-secring.gpg")
+          appendLine("signing.secretKeyRingFile=${path.parent.absolutePathString()}/test-secring.gpg")
         }
         TestOptions.Signing.IN_MEMORY_KEY -> {
           appendLine(

plugin/src/integrationTest/kotlin/com/vanniktech/maven/publish/ProjectSpecs.kt

@@ -13,6 +13,7 @@ val kotlinJvmPlugin = PluginSpec("org.jetbrains.kotlin.jvm")
 val kotlinMultiplatformPlugin = PluginSpec("org.jetbrains.kotlin.multiplatform")
 val kotlinAndroidPlugin = PluginSpec("org.jetbrains.kotlin.android")
 val androidLibraryPlugin = PluginSpec("com.android.library")
+val androidFusedLibraryPlugin = PluginSpec("com.android.fused-library")
 val gradlePluginPublishPlugin = PluginSpec("com.gradle.plugin-publish")
 val dokkaPlugin = PluginSpec("org.jetbrains.dokka", "1.8.10")
 val dokka2Plugin = PluginSpec("org.jetbrains.dokka", "2.0.0-Beta")
@@ -269,6 +270,26 @@ fun androidLibraryKotlinProjectSpec(agpVersion: AgpVersion, kotlinVersion: Kotli
   )
 }
 
+fun androidFusedLibraryProjectSpec(version: AgpVersion) = ProjectSpec(
+  plugins = listOf(
+    androidFusedLibraryPlugin.copy(version = version.value),
+  ),
+  group = "com.example",
+  artifactId = "test-artifact",
+  version = "1.0.0",
+  properties = defaultProperties,
+  sourceFiles = listOf(
+    SourceFile("main", "java", "com/vanniktech/maven/publish/test/JavaTestClass.java"),
+  ),
+  basePluginConfig = "configure(new AndroidFusedLibrary())",
+  buildFileExtra = """
+    androidFusedLibrary {
+        namespace = "com.test.library"
+        minSdk = 29
+    }
+  """.trimIndent(),
+)
+
 fun javaPlatformProjectSpec() = ProjectSpec(
   plugins = listOf(
     javaPlatformPlugin,

plugin/src/main/kotlin/com/vanniktech/maven/publish/MavenPublishBaseExtension.kt

@@ -403,6 +403,9 @@ public abstract class MavenPublishBaseExtension @Inject constructor(
         val variant = project.findOptionalProperty("ANDROID_VARIANT_TO_PUBLISH") ?: "release"
         configure(AndroidSingleVariantLibrary(variant, sourcesJar, javadocJar))
       }
+      project.plugins.hasPlugin("com.android.fused-library") -> {
+        configure(AndroidFusedLibrary())
+      }
       project.plugins.hasPlugin("com.gradle.plugin-publish") ->
         configure(GradlePublishPlugin())
       project.plugins.hasPlugin("java-gradle-plugin") ->

plugin/src/main/kotlin/com/vanniktech/maven/publish/MavenPublishPlugin.kt

@@ -26,6 +26,9 @@ public open class MavenPublishPlugin : Plugin<Project> {
         baseExtension.configureBasedOnAppliedPlugins()
       }
     }
+    project.plugins.withId("com.android.fused-library") {
+      baseExtension.configureBasedOnAppliedPlugins()
+    }
 
     project.afterEvaluate {
       // will no-op if it was already called

plugin/src/main/kotlin/com/vanniktech/maven/publish/Platform.kt

@@ -4,6 +4,7 @@ import com.android.build.api.dsl.LibraryExtension
 import com.vanniktech.maven.publish.tasks.JavadocJar.Companion.javadocJarTask
 import com.vanniktech.maven.publish.workaround.addTestFixturesSourcesJar
 import com.vanniktech.maven.publish.workaround.fixTestFixturesMetadata
+import org.gradle.api.Incubating
 import org.gradle.api.Project
 import org.gradle.api.plugins.JavaPluginExtension
 import org.gradle.api.provider.Provider
@@ -250,6 +251,42 @@ public data class AndroidMultiVariantLibrary @JvmOverloads constructor(
   }
 }
 
+/**
+ * To be used for `com.android.fused-library` projects. Applying this creates a publication for the library with
+ * empty source and javadoc jars.
+ *
+ * Equivalent Gradle set up:
+ * ```
+ * publishing {
+ *   publications {
+ *     register<MavenPublication>("maven") {
+ *       from(components["fusedLibraryComponent"])
+ *     }
+ *   }
+ * }
+ * ```
+ */
+@Incubating
+public class AndroidFusedLibrary : Platform() {
+  override val sourcesJar: Boolean = false
+  override val javadocJar: JavadocJar = JavadocJar.Empty()
+
+  override fun configure(project: Project) {
+    check(project.plugins.hasPlugin("com.android.fused-library")) {
+      "Calling configure(AndroidFusedLibrary(...)) requires the com.android.fused-library plugin to be applied"
+    }
+
+    project.mavenPublications {
+      it.withJavadocJar(javadocJar, project, configureArchives = true)
+      it.withJavaSourcesJar(sourcesJar, project, configureArchives = true)
+    }
+  }
+
+  override fun equals(other: Any?): Boolean = other is AndroidFusedLibrary
+
+  override fun hashCode(): Int = this::class.hashCode()
+}
+
 /**
  * To be used for `org.jetbrains.kotlin.multiplatform` projects. Uses the default publications that gets created by
  * that plugin, including the automatically created `-sources` jars. Depending on the passed parameters for [javadocJar],
@@ -459,21 +496,31 @@ public sealed interface JavadocJar {
 
 private const val PUBLICATION_NAME = "maven"
 
-private fun MavenPublication.withJavaSourcesJar(enabled: Boolean, project: Project) {
+private fun MavenPublication.withJavaSourcesJar(enabled: Boolean, project: Project, configureArchives: Boolean = false) {
   if (enabled) {
     project.extensions.getByType(JavaPluginExtension::class.java).withSourcesJar()
   } else {
     val task = project.tasks.register("emptySourcesJar", Jar::class.java) {
       it.archiveClassifier.set("sources")
+      if (configureArchives) {
+        it.archiveBaseName.set(project.name)
+        it.destinationDirectory.set(project.layout.buildDirectory.dir("libs"))
+      }
     }
     artifact(task)
   }
 }
 
-private fun MavenPublication.withJavadocJar(javadocJar: JavadocJar, project: Project) {
+private fun MavenPublication.withJavadocJar(javadocJar: JavadocJar, project: Project, configureArchives: Boolean = false) {
   val task = project.javadocJarTask(name, javadocJar)
   if (task != null) {
     artifact(task)
+
+    if (configureArchives) {
+      task.configure {
+        it.destinationDirectory.set(project.layout.buildDirectory.dir("libs"))
+      }
+    }
   }
 }