virtualx-engine/platform/android/java/build.gradle

buildscript {
    apply from: 'app/config.gradle'

    repositories {
        google()
        mavenCentral()
        maven { url "https://plugins.gradle.org/m2/" }
    }
    dependencies {
        classpath libraries.androidGradlePlugin
        classpath libraries.kotlinGradlePlugin
        classpath 'io.github.gradle-nexus:publish-plugin:1.3.0'
    }
}

plugins {
    id 'io.github.gradle-nexus.publish-plugin'
}

apply from: 'app/config.gradle'
apply from: 'scripts/publish-root.gradle'

ext {
    PUBLISH_VERSION = getGodotPublishVersion()
}

group = ossrhGroupId
version = PUBLISH_VERSION

allprojects {
    repositories {
        google()
        mavenCentral()
    }
}

ext {
    supportedAbis = ["arm32", "arm64", "x86_32", "x86_64"]
    supportedFlavors = ["editor", "template"]
    supportedFlavorsBuildTypes = [
        "editor": ["dev", "debug", "release"],
        "template": ["dev", "debug", "release"]
    ]

    // Used by gradle to specify which architecture to build for by default when running
    // `./gradlew build` (this command is usually used by Android Studio).
    // If building manually on the command line, it's recommended to use the
    // `./gradlew generateGodotTemplates` build command instead after running the `scons` command(s).
    // The {selectedAbis} values must be from the {supportedAbis} values.
    selectedAbis = ["arm64"]
}

def rootDir = "../../.."
def binDir = "$rootDir/bin/"
def androidEditorBuildsDir = "$binDir/android_editor_builds/"

def getSconsTaskName(String flavor, String buildType, String abi) {
    return "compileGodotNativeLibs" + flavor.capitalize() + buildType.capitalize() + abi.capitalize()
}

/**
 * Copy the generated 'android_debug.apk' binary template into the Godot bin directory.
 * Depends on the app build task to ensure the binary is generated prior to copying.
 */
task copyDebugBinaryToBin(type: Copy) {
    dependsOn ':app:assembleDebug'
    from('app/build/outputs/apk/debug')
    into(binDir)
    include('android_debug.apk')
}

/**
 * Copy the generated 'android_dev.apk' binary template into the Godot bin directory.
 * Depends on the app build task to ensure the binary is generated prior to copying.
 */
task copyDevBinaryToBin(type: Copy) {
    dependsOn ':app:assembleDev'
    from('app/build/outputs/apk/dev')
    into(binDir)
    include('android_dev.apk')
}

/**
 * Copy the generated 'android_release.apk' binary template into the Godot bin directory.
 * Depends on the app build task to ensure the binary is generated prior to copying.
 */
task copyReleaseBinaryToBin(type: Copy) {
    dependsOn ':app:assembleRelease'
    from('app/build/outputs/apk/release')
    into(binDir)
    include('android_release.apk')
}

/**
 * Copy the Godot android library archive debug file into the app module debug libs directory.
 * Depends on the library build task to ensure the AAR file is generated prior to copying.
 */
task copyDebugAARToAppModule(type: Copy) {
    dependsOn ':lib:assembleTemplateDebug'
    from('lib/build/outputs/aar')
    into('app/libs/debug')
    include('godot-lib.template_debug.aar')
}

/**
 * Copy the Godot android library archive debug file into the root bin directory.
 * Depends on the library build task to ensure the AAR file is generated prior to copying.
 */
task copyDebugAARToBin(type: Copy) {
    dependsOn ':lib:assembleTemplateDebug'
    from('lib/build/outputs/aar')
    into(binDir)
    include('godot-lib.template_debug.aar')
}

/**
 * Copy the Godot android library archive dev file into the app module dev libs directory.
 * Depends on the library build task to ensure the AAR file is generated prior to copying.
 */
task copyDevAARToAppModule(type: Copy) {
    dependsOn ':lib:assembleTemplateDev'
    from('lib/build/outputs/aar')
    into('app/libs/dev')
    include('godot-lib.template_debug.dev.aar')
}

/**
 * Copy the Godot android library archive dev file into the root bin directory.
 * Depends on the library build task to ensure the AAR file is generated prior to copying.
 */
task copyDevAARToBin(type: Copy) {
    dependsOn ':lib:assembleTemplateDev'
    from('lib/build/outputs/aar')
    into(binDir)
    include('godot-lib.template_debug.dev.aar')
}

/**
 * Copy the Godot android library archive release file into the app module release libs directory.
 * Depends on the library build task to ensure the AAR file is generated prior to copying.
 */
task copyReleaseAARToAppModule(type: Copy) {
    dependsOn ':lib:assembleTemplateRelease'
    from('lib/build/outputs/aar')
    into('app/libs/release')
    include('godot-lib.template_release.aar')
}

/**
 * Copy the Godot android library archive release file into the root bin directory.
 * Depends on the library build task to ensure the AAR file is generated prior to copying.
 */
task copyReleaseAARToBin(type: Copy) {
    dependsOn ':lib:assembleTemplateRelease'
    from('lib/build/outputs/aar')
    into(binDir)
    include('godot-lib.template_release.aar')
}

/**
 * Generate Godot gradle build template by zipping the source files from the app directory, as well
 * as the AAR files generated by 'copyDebugAAR', 'copyDevAAR' and 'copyReleaseAAR'.
 * The zip file also includes some gradle tools to enable gradle builds from the Godot Editor.
 */
task zipGradleBuild(type: Zip) {
    onlyIf { generateGodotTemplates.state.executed || generateDevTemplate.state.executed }
    doFirst {
        logger.lifecycle("Generating Godot gradle build template")
    }
    from(fileTree(dir: 'app', excludes: ['**/build/**', '**/.gradle/**', '**/*.iml']), fileTree(dir: '.', includes: ['gradlew', 'gradlew.bat', 'gradle/**']))
    include '**/*'
    archiveFileName = 'android_source.zip'
    destinationDirectory = file(binDir)
}

def templateExcludedBuildTask() {
    // We exclude these gradle tasks so we can run the scons command manually.
    def excludedTasks = []
    if (!isAndroidStudio()) {
        logger.lifecycle("Excluding Android studio build tasks")
        for (String flavor : supportedFlavors) {
            String[] supportedBuildTypes = supportedFlavorsBuildTypes[flavor]
            for (String buildType : supportedBuildTypes) {
                for (String abi : selectedAbis) {
                    excludedTasks += ":lib:" + getSconsTaskName(flavor, buildType, abi)
                }
            }
        }
    }
    return excludedTasks
}

def templateBuildTasks() {
    def tasks = []

    // Only build the apks and aar files for which we have native shared libraries.
    for (String target : supportedFlavorsBuildTypes["template"]) {
        File targetLibs = new File("lib/libs/" + target)
        if (targetLibs != null
            && targetLibs.isDirectory()
            && targetLibs.listFiles() != null
            && targetLibs.listFiles().length > 0) {
            String capitalizedTarget = target.capitalize()
            // Copy the generated aar library files to the build directory.
            tasks += "copy" + capitalizedTarget + "AARToAppModule"
            // Copy the generated aar library files to the bin directory.
            tasks += "copy" + capitalizedTarget + "AARToBin"
            // Copy the prebuilt binary templates to the bin directory.
            tasks += "copy" + capitalizedTarget + "BinaryToBin"
        } else {
            logger.lifecycle("No native shared libs for target $target. Skipping build.")
        }
    }

    return tasks
}

def isAndroidStudio() {
    def sysProps = System.getProperties()
    return sysProps != null && sysProps['idea.platform.prefix'] != null
}

task copyEditorReleaseApkToBin(type: Copy) {
    dependsOn ':editor:assembleRelease'
    from('editor/build/outputs/apk/release')
    into(androidEditorBuildsDir)
    include('android_editor-release*.apk')
}

task copyEditorReleaseAabToBin(type: Copy) {
    dependsOn ':editor:bundleRelease'
    from('editor/build/outputs/bundle/release')
    into(androidEditorBuildsDir)
    include('android_editor-release*.aab')
}

task copyEditorDebugApkToBin(type: Copy) {
    dependsOn ':editor:assembleDebug'
    from('editor/build/outputs/apk/debug')
    into(androidEditorBuildsDir)
    include('android_editor-debug.apk')
}

task copyEditorDebugAabToBin(type: Copy) {
    dependsOn ':editor:bundleDebug'
    from('editor/build/outputs/bundle/debug')
    into(androidEditorBuildsDir)
    include('android_editor-debug.aab')
}

task copyEditorDevApkToBin(type: Copy) {
    dependsOn ':editor:assembleDev'
    from('editor/build/outputs/apk/dev')
    into(androidEditorBuildsDir)
    include('android_editor-dev.apk')
}

task copyEditorDevAabToBin(type: Copy) {
    dependsOn ':editor:bundleDev'
    from('editor/build/outputs/bundle/dev')
    into(androidEditorBuildsDir)
    include('android_editor-dev.aab')
}

/**
 * Generate the Godot Editor Android apk.
 *
 * Note: The Godot 'tools' shared libraries must have been generated (via scons) prior to running
 * this gradle task. The task will only build the apk(s) for which the shared libraries is
 * available.
 */
task generateGodotEditor {
    gradle.startParameter.excludedTaskNames += templateExcludedBuildTask()

    def tasks = []

    for (String target : supportedFlavorsBuildTypes["editor"]) {
        File targetLibs = new File("lib/libs/tools/" + target)
        if (targetLibs != null
            && targetLibs.isDirectory()
            && targetLibs.listFiles() != null
            && targetLibs.listFiles().length > 0) {
            tasks += "copyEditor${target.capitalize()}ApkToBin"
            tasks += "copyEditor${target.capitalize()}AabToBin"
        }
    }

    dependsOn = tasks
}

/**
 * Master task used to coordinate the tasks defined above to generate the set of Godot templates.
 */
task generateGodotTemplates {
    gradle.startParameter.excludedTaskNames += templateExcludedBuildTask()
    dependsOn = templateBuildTasks()

    finalizedBy 'zipGradleBuild'
}

/**
 * Generates the same output as generateGodotTemplates but with dev symbols
 */
task generateDevTemplate {
    // add parameter to set symbols to true
    gradle.startParameter.projectProperties += [doNotStrip: true]

    gradle.startParameter.excludedTaskNames += templateExcludedBuildTask()
    dependsOn = templateBuildTasks()

    finalizedBy 'zipGradleBuild'
}

task clean(type: Delete) {
    dependsOn 'cleanGodotEditor'
    dependsOn 'cleanGodotTemplates'
}

/**
 * Clean the generated editor artifacts.
 */
task cleanGodotEditor(type: Delete) {
    // Delete the generated native tools libs
    delete("lib/libs/tools")

    // Delete the library generated AAR files
    delete("lib/build/outputs/aar")

    // Delete the generated binary apks
    delete("editor/build/outputs/apk")

    // Delete the generated aab binaries
    delete("editor/build/outputs/bundle")

    // Delete the Godot editor apks & aabs in the Godot bin directory
    delete(androidEditorBuildsDir)
}

/**
 * Clean the generated template artifacts.
 */
task cleanGodotTemplates(type: Delete) {
    // Delete the generated native libs
    delete("lib/libs")

    // Delete the library generated AAR files
    delete("lib/build/outputs/aar")

    // Delete the app libs directory contents
    delete("app/libs")

    // Delete the generated binary apks
    delete("app/build/outputs/apk")

    // Delete the Godot templates in the Godot bin directory
    delete("$binDir/android_debug.apk")
    delete("$binDir/android_dev.apk")
    delete("$binDir/android_release.apk")
    delete("$binDir/android_source.zip")
    delete("$binDir/godot-lib.template_debug.aar")
    delete("$binDir/godot-lib.template_debug.dev.aar")
    delete("$binDir/godot-lib.template_release.aar")

    // Cover deletion for the libs using the previous naming scheme
    delete("$binDir/godot-lib.debug.aar")
    delete("$binDir/godot-lib.dev.aar")
    delete("$binDir/godot-lib.release.aar")
}