godot/platform/android/java/editor/build.gradle

// Gradle build config for Godot Engine's Android port.
plugins {
    id 'com.android.application'
    id 'org.jetbrains.kotlin.android'
    id 'base'
}

ext {
    // Retrieve the build number from the environment variable; default to 0 if none is specified.
    // The build number is added as a suffix to the version code for upload to the Google Play store.
    getEditorBuildNumber = { ->
        int buildNumber = 0
        String versionStatus = System.getenv("GODOT_VERSION_STATUS")
        if (versionStatus != null && !versionStatus.isEmpty()) {
            try {
                buildNumber = Integer.parseInt(versionStatus.replaceAll("[^0-9]", ""))
            } catch (NumberFormatException ignored) {
                buildNumber = 0
            }
        }

        return buildNumber
    }
    // Value by which the Godot version code should be offset by to make room for the build number
    editorBuildNumberOffset = 100

    // Return the keystore file used for signing the release build.
    getGodotKeystoreFile = { ->
        def keyStore = System.getenv("GODOT_ANDROID_SIGN_KEYSTORE")
        if (keyStore == null || keyStore.isEmpty()) {
            return null
        }
        return file(keyStore)
    }

    // Return the key alias used for signing the release build.
    getGodotKeyAlias = { ->
        def kAlias = System.getenv("GODOT_ANDROID_KEYSTORE_ALIAS")
        return kAlias
    }

    // Return the password for the key used for signing the release build.
    getGodotSigningPassword = { ->
        def signingPassword = System.getenv("GODOT_ANDROID_SIGN_PASSWORD")
        return signingPassword
    }

    // Returns true if the environment variables contains the configuration for signing the release
    // build.
    hasReleaseSigningConfigs = { ->
        def keystoreFile = getGodotKeystoreFile()
        def keyAlias = getGodotKeyAlias()
        def signingPassword = getGodotSigningPassword()

        return keystoreFile != null && keystoreFile.isFile()
            && keyAlias != null && !keyAlias.isEmpty()
            && signingPassword != null && !signingPassword.isEmpty()
    }
}

def generateVersionCode() {
    int libraryVersionCode = getGodotLibraryVersionCode()
    return (libraryVersionCode * editorBuildNumberOffset) + getEditorBuildNumber()
}

def generateVersionName() {
    String libraryVersionName = getGodotLibraryVersionName()
    int buildNumber = getEditorBuildNumber()
    return buildNumber == 0 ? libraryVersionName : libraryVersionName + ".$buildNumber"
}

android {
    compileSdkVersion versions.compileSdk
    buildToolsVersion versions.buildTools
    ndkVersion versions.ndkVersion

    namespace = "org.godotengine.editor"

    defaultConfig {
        // The 'applicationId' suffix allows to install Godot 3.x(v3) and 4.x(v4) on the same device
        applicationId "org.godotengine.editor.v4"
        versionCode generateVersionCode()
        versionName generateVersionName()
        minSdkVersion versions.minSdk
        targetSdkVersion versions.targetSdk

        missingDimensionStrategy 'products', 'editor'
        manifestPlaceholders += [
            editorAppName: "Godot Engine 4",
            editorBuildSuffix: ""
        ]

        ndk { debugSymbolLevel 'NONE' }

        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"

        // The following argument makes the Android Test Orchestrator run its
        // "pm clear" command after each test invocation. This command ensures
        // that the app's state is completely cleared between tests.
        testInstrumentationRunnerArguments clearPackageData: 'true'
    }

    testOptions {
        execution 'ANDROIDX_TEST_ORCHESTRATOR'
    }

    base {
        archivesName = "android_editor"
    }

    compileOptions {
        sourceCompatibility versions.javaVersion
        targetCompatibility versions.javaVersion
    }

    kotlinOptions {
        jvmTarget = versions.javaVersion
    }

    signingConfigs {
        release {
            storeFile getGodotKeystoreFile()
            storePassword getGodotSigningPassword()
            keyAlias getGodotKeyAlias()
            keyPassword getGodotSigningPassword()
        }
    }

    buildFeatures {
        buildConfig = true
    }

    buildTypes {
        dev {
            initWith debug
            applicationIdSuffix ".dev"
            manifestPlaceholders += [editorBuildSuffix: " (dev)"]
        }

        debug {
            initWith release
            applicationIdSuffix ".debug"
            manifestPlaceholders += [editorBuildSuffix: " (debug)"]
            signingConfig signingConfigs.debug
        }

        release {
            if (hasReleaseSigningConfigs()) {
                signingConfig signingConfigs.release
            }
        }
    }

    packagingOptions {
        // Debug symbols are kept for development within Android Studio.
        if (shouldNotStrip()) {
            jniLibs {
                keepDebugSymbols += '**/*.so'
            }
        }
    }

    flavorDimensions = ["android_distribution"]
    productFlavors {
        android {
            dimension "android_distribution"
            missingDimensionStrategy 'products', 'editor'
        }
        horizonos {
            dimension "android_distribution"
            missingDimensionStrategy 'products', 'editor'
            ndk {
                //noinspection ChromeOsAbiSupport
                abiFilters "arm64-v8a"
            }
            applicationIdSuffix ".meta"
            versionNameSuffix "-meta"
            targetSdkVersion 32
        }
        picoos {
            dimension "android_distribution"
            missingDimensionStrategy 'products', 'editor'
            ndk {
                //noinspection ChromeOsAbiSupport
                abiFilters "arm64-v8a"
            }
            applicationIdSuffix ".pico"
            versionNameSuffix "-pico"
            minSdkVersion 29
            targetSdkVersion 32
        }
    }
}

dependencies {
    implementation fileTree(dir: "libs", include: ["*.jar", "*.aar"])

    implementation "androidx.fragment:fragment:$versions.fragmentVersion"
    implementation project(":lib")

    implementation "androidx.window:window:1.3.0"
    implementation "androidx.core:core-splashscreen:$versions.splashscreenVersion"
    implementation "androidx.constraintlayout:constraintlayout:2.2.1"
    implementation "org.bouncycastle:bcprov-jdk15to18:1.78"

    implementation "org.khronos.openxr:openxr_loader_for_android:$versions.openxrLoaderVersion"

    // Android XR dependencies
    androidImplementation "org.godotengine:godot-openxr-vendors-androidxr:$versions.openxrVendorsVersion"
    // Meta dependencies
    horizonosImplementation "org.godotengine:godot-openxr-vendors-meta:$versions.openxrVendorsVersion"
    // Pico dependencies
    picoosImplementation "org.godotengine:godot-openxr-vendors-pico:$versions.openxrVendorsVersion"

    // Android instrumented test dependencies
    androidTestImplementation "androidx.test.ext:junit:$versions.junitVersion"
    androidTestImplementation "androidx.test.espresso:espresso-core:$versions.espressoCoreVersion"
    androidTestImplementation "org.jetbrains.kotlin:kotlin-test:$versions.kotlinTestVersion"
    androidTestImplementation "androidx.test:runner:$versions.testRunnerVersion"
    androidTestUtil "androidx.test:orchestrator:$versions.testOrchestratorVersion"
}

/*
 * Older versions of our vendor plugin include a loader that we no longer need.
 * This code ensures those are removed.
 */
tasks.withType( com.android.build.gradle.internal.tasks.MergeNativeLibsTask) {
    doFirst {
        externalLibNativeLibs.each { jniDir ->
            if (jniDir.getCanonicalPath().contains("godot-openxr-") || jniDir.getCanonicalPath().contains("godotopenxr")) {
                // Delete the 'libopenxr_loader.so' files from the vendors plugin so we only use the version from the
                // openxr loader dependency.
                File armFile = new File(jniDir, "arm64-v8a/libopenxr_loader.so")
                if (armFile.exists()) {
                    armFile.delete()
                }
                File x86File = new File(jniDir, "x86_64/libopenxr_loader.so")
                if (x86File.exists()) {
                    x86File.delete()
                }
            }
        }
    }
}