0.3.3-0-pre.3

Android/gradle/sasedev-rust-android.gradle

@@ -0,0 +1,192 @@
+// file: Android/gradle/sasedev-rust-android.gradle
+// version: 1
+
+import java.util.Collections
+import java.util.zip.ZipFile
+import javax.inject.Inject
+import org.gradle.process.ExecOperations
+
+abstract class BuildSasedevRustAndroidTask extends DefaultTask {
+    @InputFile
+    @PathSensitive(PathSensitivity.RELATIVE)
+    abstract RegularFileProperty getSdl3Aar()
+
+    @InputFiles
+    @PathSensitive(PathSensitivity.RELATIVE)
+    abstract ConfigurableFileCollection getRustInputs()
+
+    @Input
+    abstract Property<String> getGameFeature()
+
+    @Input
+    abstract Property<String> getAbi()
+
+    @Input
+    abstract Property<Integer> getAndroidApi()
+
+    @Input
+    abstract Property<String> getNdkVersion()
+
+    @Internal
+    abstract DirectoryProperty getRepositoryRoot()
+
+    @OutputDirectory
+    abstract DirectoryProperty getOutputDirectory()
+
+    @Inject
+    abstract ExecOperations getExecOperations()
+
+    @TaskAction
+    void buildNative() {
+        def selectedAbi = abi.get()
+        def selectedFeature = gameFeature.get()
+        def aar = sdl3Aar.get().asFile
+        def repository = repositoryRoot.get().asFile
+        def output = outputDirectory.get().asFile
+        def runtimeDirectory = new File(output, selectedAbi)
+        def linkDirectory = new File(temporaryDir, "link")
+
+        project.delete(output)
+        project.delete(linkDirectory)
+        runtimeDirectory.mkdirs()
+        linkDirectory.mkdirs()
+
+        byte[] sdl3Payload
+        new ZipFile(aar).withCloseable { archive ->
+            def candidates = [
+                "prefab/modules/SDL3/libs/android.${selectedAbi}/libSDL3.so",
+                "jni/${selectedAbi}/libSDL3.so",
+            ]
+            def entry = candidates.collect { candidate -> archive.getEntry(candidate) }.find { candidate -> candidate != null }
+            if (entry == null) {
+                def suffix = "/libs/android.${selectedAbi}/libSDL3.so"
+                def fallback = Collections.list(archive.entries()).findAll { candidate ->
+                    !candidate.directory && candidate.name.endsWith(suffix)
+                }
+                if (fallback.size() != 1) {
+                    throw new GradleException(
+                        "SDL3 shared library for ABI ${selectedAbi} is missing from ${aar}; " +
+                        "expected Prefab member ${candidates[0]}"
+                    )
+                }
+                entry = fallback[0]
+            }
+            sdl3Payload = archive.getInputStream(entry).withCloseable { stream -> stream.bytes }
+        }
+
+        def linkLibrary = new File(linkDirectory, "libSDL3.so")
+        def runtimeLibrary = new File(runtimeDirectory, "libSDL3.so")
+        linkLibrary.bytes = sdl3Payload
+        runtimeLibrary.bytes = sdl3Payload
+
+        def androidHome = System.getenv("ANDROID_HOME") ?: System.getenv("ANDROID_SDK_ROOT")
+        if (!androidHome) {
+            throw new GradleException("ANDROID_HOME or ANDROID_SDK_ROOT is required to resolve the project NDK")
+        }
+        def configuredNdk = new File(androidHome, "ndk/${ndkVersion.get()}")
+        if (!configuredNdk.isDirectory()) {
+            throw new GradleException("configured Android NDK is missing: ${configuredNdk}")
+        }
+
+        def inheritedRustFlags = System.getenv("RUSTFLAGS")?.trim()
+        def linkFlag = "-Lnative=${linkDirectory}"
+        def rustFlags = inheritedRustFlags ? "${inheritedRustFlags} ${linkFlag}" : linkFlag
+
+        execOperations.exec { spec ->
+            spec.workingDir(repository)
+            spec.environment("ANDROID_NDK_HOME", configuredNdk.absolutePath)
+            spec.environment("CARGO_NDK_PLATFORM", androidApi.get().toString())
+            spec.environment("RUSTFLAGS", rustFlags)
+            spec.commandLine(
+                "cargo",
+                "ndk",
+                "-t",
+                selectedAbi,
+                "-o",
+                output.absolutePath,
+                "build",
+                "-p",
+                "game-android-entrypoint",
+                "--no-default-features",
+                "--features",
+                selectedFeature,
+            )
+        }
+
+        def rustLibrary = new File(runtimeDirectory, "libgame_android_entrypoint.so")
+        if (!runtimeLibrary.isFile()) {
+            throw new GradleException("missing staged SDL3 Android library: ${runtimeLibrary}")
+        }
+        if (!rustLibrary.isFile()) {
+            throw new GradleException("missing Rust Android library after cargo-ndk build: ${rustLibrary}")
+        }
+    }
+}
+
+if (!project.ext.has("sasedevRustGameFeature")) {
+    throw new GradleException("sasedevRustGameFeature must select exactly one Cargo game feature")
+}
+if (!project.ext.has("sasedevRustAndroidAbis")) {
+    throw new GradleException("sasedevRustAndroidAbis must declare at least one Android ABI")
+}
+if (!project.ext.has("sasedevRustAndroidApi")) {
+    throw new GradleException("sasedevRustAndroidApi must declare the Rust Android API level")
+}
+
+def selectedGameFeature = project.ext.sasedevRustGameFeature as String
+def selectedAbis = (project.ext.sasedevRustAndroidAbis as List).collect { configuredAbi -> configuredAbi as String }
+def selectedAndroidApi = project.ext.sasedevRustAndroidApi as Integer
+def configuredSdl3AarName = providers.gradleProperty("sdl3AarName").get()
+def configuredNdkVersion = providers.gradleProperty("androidNdkVersion").get()
+def repositoryDirectory = rootProject.projectDir.parentFile
+
+def supportedAbis = ["arm64-v8a", "armeabi-v7a", "x86_64", "x86"] as Set
+if (selectedAbis.isEmpty()) {
+    throw new GradleException("sasedevRustAndroidAbis must not be empty")
+}
+if (selectedAbis.toSet().size() != selectedAbis.size()) {
+    throw new GradleException("sasedevRustAndroidAbis must not contain duplicates: ${selectedAbis}")
+}
+def unsupportedAbis = selectedAbis.findAll { configuredAbi -> !supportedAbis.contains(configuredAbi) }
+if (!unsupportedAbis.isEmpty()) {
+    throw new GradleException("unsupported Rust Android ABI(s): ${unsupportedAbis.join(', ')}")
+}
+
+androidComponents {
+    onVariants(selector().withBuildType("debug")) { variant ->
+        selectedAbis.each { selectedAbi ->
+            def variantSuffix = variant.name.substring(0, 1).toUpperCase() + variant.name.substring(1)
+            def abiSuffix = selectedAbi
+                .split(/[^A-Za-z0-9]+/)
+                .findAll { segment -> !segment.isEmpty() }
+                .collect { segment -> segment.substring(0, 1).toUpperCase() + segment.substring(1) }
+                .join("")
+            def nativeTask = tasks.register(
+                "build${variantSuffix}SasedevRust${abiSuffix}",
+                BuildSasedevRustAndroidTask,
+            ) {
+                sdl3Aar.set(rootProject.layout.projectDirectory.file("libs/${configuredSdl3AarName}"))
+                rustInputs.from(rootProject.file("../Cargo.toml"))
+                rustInputs.from(rootProject.file("../.cargo/config.toml"))
+                rustInputs.from(rootProject.fileTree("../crates") {
+                    include "**/*.rs"
+                    include "**/Cargo.toml"
+                    include "**/build.rs"
+                })
+                gameFeature.set(selectedGameFeature)
+                abi.set(selectedAbi)
+                androidApi.set(selectedAndroidApi)
+                ndkVersion.set(configuredNdkVersion)
+                repositoryRoot.set(repositoryDirectory)
+                outputDirectory.set(layout.buildDirectory.dir("generated/sasedevNative/${variant.name}/${selectedAbi}/jniLibs"))
+            }
+
+            if (variant.sources.jniLibs == null) {
+                throw new GradleException("AGP variant ${variant.name} does not expose jniLibs sources")
+            }
+            variant.sources.jniLibs.addGeneratedSourceDirectory(nativeTask) { task ->
+                task.outputDirectory
+            }
+        }
+    }
+}