updated public interface

Author: matrixdev

README.md

@@ -46,24 +46,21 @@ androidRust {
     profile = "release"
 
     // default abi targets
-    targets = setOf(Abi.Arm, Abi.Arm64)
+    targets = setOf("arm", "arm64")
 
     // MSRV, plugin will update rust if installed version is lower than requested
-    minimumSupportedRustVersion = SemanticVersion("1.62.1")
+    minimumSupportedRustVersion = "1.62.1"
 
     // "debug" build type specific configuration
     buildType("debug") {
         // use "dev" profile in rust
-        it.profile = "dev"
-
-        // build only Arm64 version
-        it.targets = setOf(Abi.Arm64)
+        profile = "dev"
     }
 
     // "release" build type specific configuration
     buildType("release") {
         // build all supported abi versions
-        it.targets = setOf(Abi.Arm, Abi.Arm64, Abi.X86, Abi.X86_64)
+        targets = setOf("arm", "arm64", "x86", "x86_64")
     }
 }
 ```

plugin/src/main/java/dev/matrix/agp/rust/AndroidRustExtension.kt

@@ -1,18 +1,20 @@
 package dev.matrix.agp.rust
 
 import dev.matrix.agp.rust.utils.Abi
-import dev.matrix.agp.rust.utils.SemanticVersion
 import java.io.File
 
-@Suppress("MemberVisibilityCanBePrivate", "unused")
+@DslMarker
+annotation class AndroidRustDslMarker
+
+@AndroidRustDslMarker
+@Suppress("unused")
 open class AndroidRustExtension {
     lateinit var path: File
 
     var profile = ""
-    var targets = Abi.values().toSet()
-    var minimumSupportedRustVersion: SemanticVersion? = null
-
-    val buildTypes = hashMapOf(
+    var targets = Abi.values().asSequence().map { it.androidName }.toSet()
+    var minimumSupportedRustVersion = ""
+    var buildTypes = hashMapOf(
         "debug" to AndroidRustBuildType().also {
             it.profile = "dev"
         },
@@ -21,21 +23,14 @@ open class AndroidRustExtension {
         },
     )
 
-    fun buildType(name: String, configure: (AndroidRustBuildType) -> Unit) {
+    fun buildType(name: String, configure: AndroidRustBuildType.() -> Unit) {
         configure(buildTypes.getOrPut(name, ::AndroidRustBuildType))
     }
-
-    fun debugBuildType(configure: (AndroidRustBuildType) -> Unit) {
-        buildType("debug", configure)
-    }
-
-    fun releaseBuildType(configure: (AndroidRustBuildType) -> Unit) {
-        buildType("release", configure)
-    }
 }
 
+@AndroidRustDslMarker
 @Suppress("unused")
 open class AndroidRustBuildType {
     var profile = ""
-    var targets: List<Abi>? = null
+    var targets = emptySet<String>()
 }

plugin/src/main/java/dev/matrix/agp/rust/AndroidRustPlugin.kt

@@ -15,12 +15,14 @@ import java.util.*
 // TODO: migrate to variant API with artifacts when JNI will be supported
 // https://developer.android.com/studio/build/extend-agp#access-modify-artifacts
 //
+@Suppress("unused")
 class AndroidRustPlugin : Plugin<Project> {
     override fun apply(project: Project) {
         val extension = project.extensions.create("androidRust", AndroidRustExtension::class.java)
         val androidExtension = project.getAndroidExtension()
         val androidComponents = project.getAndroidComponentsExtension()
         val tasksByBuildType = HashMap<String, ArrayList<TaskProvider<RustBuildTask>>>()
+        val minimumSupportedRustVersion = SemanticVersion(extension.minimumSupportedRustVersion)
 
         androidComponents.finalizeDsl { dsl ->
             val allRustAbiSet = HashSet<Abi>()
@@ -35,7 +37,7 @@ class AndroidRustPlugin : Plugin<Project> {
                 val variantJniLibsDirectory = File(variantBuildDirectory, "jniLibs")
 
                 val rustBuildType = extension.buildTypes[buildType.name]
-                val rustAbiSet = resolveAbiList(project, rustBuildType?.targets ?: extension.targets)
+                val rustAbiSet = resolveAbiList(project, extension.targets, rustBuildType?.targets)
                 allRustAbiSet.addAll(rustAbiSet)
 
                 val cleanTaskName = "cleanRust${buildTypeName}"
@@ -65,7 +67,7 @@ class AndroidRustPlugin : Plugin<Project> {
                 }
             }
 
-            installRustComponentsIfNeeded(project, extension.minimumSupportedRustVersion, allRustAbiSet)
+            installRustComponentsIfNeeded(project, minimumSupportedRustVersion, allRustAbiSet)
         }
 
         androidComponents.onVariants { variant ->
@@ -81,15 +83,24 @@ class AndroidRustPlugin : Plugin<Project> {
         }
     }
 
-    private fun resolveAbiList(project: Project, requested: Collection<Abi>): Collection<Abi> {
-        val injectedBuildAbi = Abi.fromInjectedBuildAbi(project)
-        if (injectedBuildAbi.isEmpty()) {
+    private fun resolveAbiList(
+        project: Project,
+        extension: Collection<String>,
+        buildType: Collection<String>?,
+    ): Collection<Abi> {
+        val requested = when (buildType != null && buildType.isNotEmpty()) {
+            true -> Abi.fromRustNames(buildType)
+            else -> Abi.fromRustNames(extension)
+        }
+
+        val injected = Abi.fromInjectedBuildAbi(project)
+        if (injected.isEmpty()) {
             return requested
         }
 
-        val intersection = requested.intersect(injectedBuildAbi)
+        val intersection = requested.intersect(injected)
         check(intersection.isNotEmpty()) {
-            "ABIs requested by IDE ($injectedBuildAbi) are not supported by the build config ($requested)"
+            "ABIs requested by IDE ($injected) are not supported by the build config ($requested)"
         }
 
         return when {

plugin/src/main/java/dev/matrix/agp/rust/utils/Abi.kt

@@ -2,7 +2,7 @@ package dev.matrix.agp.rust.utils
 
 import org.gradle.api.Project
 
-enum class Abi(
+internal enum class Abi(
     val rustName: String,
     val androidName: String,
     val compilerTriple: String,
@@ -31,7 +31,7 @@ enum class Abi(
         rustTargetTriple = "armv7-linux-androideabi",
     ),
     Arm64(
-        rustName = "aarch64",
+        rustName = "arm64",
         androidName = "arm64-v8a",
         compilerTriple = "aarch64-linux-android",
         binUtilsTriple = "aarch64-linux-android",
@@ -40,13 +40,19 @@ enum class Abi(
 
     @Suppress("unused", "MemberVisibilityCanBePrivate")
     companion object {
-        fun fromRustName(value: String) = values().find { it.rustName == value }
-        fun fromAndroidName(value: String) = values().find { it.androidName == value }
+        fun fromRustName(value: String) = values().find { it.rustName.equals(value, ignoreCase = true) }
+        fun fromAndroidName(value: String) = values().find { it.androidName.equals(value, ignoreCase = true) }
 
         fun fromInjectedBuildAbi(project: Project): Set<Abi> {
             val values = project.properties["android.injected.build.abi"] ?: return emptySet()
             return values.toString().split(",").mapNotNullTo(HashSet()) { fromAndroidName(it.trim()) }
         }
+
+        fun fromRustNames(names: Collection<String>): Set<Abi> {
+            return names.asSequence().map {
+                requireNotNull(fromRustName(it)) { "unsupported abi version string: ${it}" }
+            }.toSet()
+        }
     }
 
     fun cc(apiLevel: Int) = when (Os.isWindows) {

plugin/src/main/java/dev/matrix/agp/rust/utils/Logger.kt

@@ -1,5 +1,5 @@
 package dev.matrix.agp.rust.utils
 
-fun log(message: String) {
+internal fun log(message: String) {
     println("AndroidRust: $message")
 }

plugin/src/main/java/dev/matrix/agp/rust/utils/NullOutputStream.kt

@@ -2,6 +2,6 @@ package dev.matrix.agp.rust.utils
 
 import java.io.OutputStream
 
-object NullOutputStream : OutputStream() {
+internal object NullOutputStream : OutputStream() {
     override fun write(value: Int) = Unit
 }

plugin/src/main/java/dev/matrix/agp/rust/utils/Os.kt

@@ -1,6 +1,6 @@
 package dev.matrix.agp.rust.utils
 
-object Os {
+internal object Os {
     val isWindows: Boolean
         get() {
             return System.getProperty("os.name").orEmpty().startsWith("windows", ignoreCase = true)

plugin/src/main/java/dev/matrix/agp/rust/utils/ProjectExt.kt

@@ -8,27 +8,27 @@ import com.android.build.gradle.LibraryExtension
 import com.android.build.gradle.LibraryPlugin
 import org.gradle.api.Project
 
-fun Project.findAndroidPlugin() = plugins.asSequence()
+internal fun Project.findAndroidPlugin() = plugins.asSequence()
     .mapNotNull { it as? AppPlugin ?: it as? LibraryPlugin }
     .firstOrNull()
 
-fun Project.getAndroidPlugin() = checkNotNull(findAndroidPlugin()) {
+internal fun Project.getAndroidPlugin() = checkNotNull(findAndroidPlugin()) {
     "couldn't find android AppPlugin or LibraryPlugin"
 }
 
-fun Project.findAndroidExtension() = extensions.findByType(AppExtension::class.java)
+internal fun Project.findAndroidExtension() = extensions.findByType(AppExtension::class.java)
     ?: extensions.findByType(LibraryExtension::class.java)
 
-fun Project.getAndroidExtension() = checkNotNull(findAndroidExtension()) {
+internal fun Project.getAndroidExtension() = checkNotNull(findAndroidExtension()) {
     "couldn't find android AppExtension or LibraryExtension"
 }
 
-fun Project.findAndroidComponentsExtension() = when (val it = project.extensions.getByName("androidComponents")) {
+internal fun Project.findAndroidComponentsExtension() = when (val it = project.extensions.getByName("androidComponents")) {
     is LibraryAndroidComponentsExtension -> it
     is ApplicationAndroidComponentsExtension -> it
     else -> null
 }
 
-fun Project.getAndroidComponentsExtension() = checkNotNull(findAndroidComponentsExtension()) {
+internal fun Project.getAndroidComponentsExtension() = checkNotNull(findAndroidComponentsExtension()) {
     "couldn't find android components extension"
 }

plugin/src/main/java/dev/matrix/agp/rust/utils/SemanticVersion.kt

@@ -2,7 +2,7 @@ package dev.matrix.agp.rust.utils
 
 import java.io.Serializable
 
-data class SemanticVersion(
+internal data class SemanticVersion(
     val major: Int,
     val minor: Int,
     val patch: Int,
@@ -24,15 +24,25 @@ data class SemanticVersion(
     }
 }
 
-fun SemanticVersion(version: String?): SemanticVersion {
-    val parts = version.orEmpty().split(".")
+internal fun SemanticVersion(version: String?): SemanticVersion {
+    if (version.isNullOrEmpty()) {
+        return SemanticVersion(0, 0, 0)
+    }
+
+    val parts = version.split(".")
+    val major = requireNotNull(parts.getOrNull(0)?.toIntOrNull()) {
+        "failed to parse 'major' part of the version from '$version'"
+    }
+    val minor = requireNotNull(parts.getOrNull(1)?.toIntOrNull()) {
+        "failed to parse 'minor' part of the version from '$version'"
+    }
+    val patch = requireNotNull(parts.getOrNull(2)?.toIntOrNull()) {
+        "failed to parse 'patch' part of the version from '$version'"
+    }
+
     return SemanticVersion(
-        major = parts.getOrNull(0)?.toIntOrNull() ?: 0,
-        minor = parts.getOrNull(1)?.toIntOrNull() ?: 0,
-        patch = parts.getOrNull(2)?.toIntOrNull() ?: 0,
+        major = major,
+        minor = minor,
+        patch = patch,
     )
 }
-
-fun SemanticVersion?.orEmpty(): SemanticVersion {
-    return this ?: SemanticVersion(0, 0, 0)
-}