feat: updated engine version to 4.4-rc1

engine/platform/android/java/build.gradle

@@ -18,16 +18,19 @@ allprojects {
         mavenCentral()
         gradlePluginPortal()
         maven { url "https://plugins.gradle.org/m2/" }
+        maven { url "https://s01.oss.sonatype.org/content/repositories/snapshots/"}
     }
 }
 
 ext {
     supportedAbis = ["arm32", "arm64", "x86_32", "x86_64"]
     supportedFlavors = ["editor", "template"]
+    supportedAndroidDistributions = ["android", "horizonos", "picoos"]
     supportedFlavorsBuildTypes = [
         "editor": ["dev", "debug", "release"],
         "template": ["dev", "debug", "release"]
     ]
+    supportedEditions = ["standard", "mono"]
 
     // Used by gradle to specify which architecture to build for by default when running
     // `./gradlew build` (this command is usually used by Android Studio).
@@ -35,122 +38,23 @@ ext {
     // `./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/"
+    rootDir = "../../.."
+    binDir = "$rootDir/bin/"
+    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 }
+    onlyIf { generateGodotTemplates.state.executed || generateGodotMonoTemplates.state.executed || generateDevTemplate.state.executed }
     doFirst {
         logger.lifecycle("Generating Godot gradle build template")
     }
@@ -191,99 +95,158 @@ def templateExcludedBuildTask() {
 /**
  * Generates the build tasks for the given flavor
  * @param flavor Must be one of the supported flavors ('template' / 'editor')
+ * @param edition Must be one of the supported editions ('standard' / 'mono')
+ * @param androidDistro Must be one of the supported Android distributions ('android' / 'horizonos' / 'picoos')
  */
-def generateBuildTasks(String flavor = "template") {
+def generateBuildTasks(String flavor = "template", String edition = "standard", String androidDistro = "android") {
     if (!supportedFlavors.contains(flavor)) {
         throw new GradleException("Invalid build flavor: $flavor")
     }
+    if (!supportedAndroidDistributions.contains(androidDistro)) {
+        throw new GradleException("Invalid Android distribution: $androidDistro")
+    }
+    if (!supportedEditions.contains(edition)) {
+        throw new GradleException("Invalid build edition: $edition")
+    }
+    if (edition == "mono" && flavor != "template") {
+        throw new GradleException("'mono' edition only supports the 'template' flavor.")
+    }
 
-    def tasks = []
+    String capitalizedAndroidDistro = androidDistro.capitalize()
+    def buildTasks = []
 
-    // Only build the apks and aar files for which we have native shared libraries unless we intend
+    // Only build the binary files for which we have native shared libraries unless we intend
     // to run the scons build tasks.
     boolean excludeSconsBuildTasks = excludeSconsBuildTasks()
     boolean isTemplate = flavor == "template"
     String libsDir = isTemplate ? "lib/libs/" : "lib/libs/tools/"
     for (String target : supportedFlavorsBuildTypes[flavor]) {
         File targetLibs = new File(libsDir + target)
+
+        String targetSuffix = target
+        if (target == "dev") {
+            targetSuffix = "debug.dev"
+        }
+
         if (!excludeSconsBuildTasks || (targetLibs != null
             && targetLibs.isDirectory()
             && targetLibs.listFiles() != null
             && targetLibs.listFiles().length > 0)) {
+
             String capitalizedTarget = target.capitalize()
+            String capitalizedEdition = edition.capitalize()
             if (isTemplate) {
-                // 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"
+                // Copy the Godot android library archive file into the app module libs directory.
+                // Depends on the library build task to ensure the AAR file is generated prior to copying.
+                String copyAARTaskName = "copy${capitalizedTarget}AARToAppModule"
+                if (tasks.findByName(copyAARTaskName) != null) {
+                    buildTasks += tasks.getByName(copyAARTaskName)
+                } else {
+                    buildTasks += tasks.create(name: copyAARTaskName, type: Copy) {
+                        dependsOn ":lib:assembleTemplate${capitalizedTarget}"
+                        from('lib/build/outputs/aar')
+                        include("godot-lib.template_${targetSuffix}.aar")
+                        into("app/libs/${target}")
+                    }
+                }
+
+                // Copy the Godot android library archive file into the root bin directory.
+                // Depends on the library build task to ensure the AAR file is generated prior to copying.
+                String copyAARToBinTaskName = "copy${capitalizedTarget}AARToBin"
+                if (tasks.findByName(copyAARToBinTaskName) != null) {
+                    buildTasks += tasks.getByName(copyAARToBinTaskName)
+                } else {
+                    buildTasks += tasks.create(name: copyAARToBinTaskName, type: Copy) {
+                        dependsOn ":lib:assembleTemplate${capitalizedTarget}"
+                        from('lib/build/outputs/aar')
+                        include("godot-lib.template_${targetSuffix}.aar")
+                        into(binDir)
+                    }
+                }
+
+                // Copy the generated binary template into the Godot bin directory.
+                // Depends on the app build task to ensure the binary is generated prior to copying.
+                String copyBinaryTaskName = "copy${capitalizedEdition}${capitalizedTarget}BinaryToBin"
+                if (tasks.findByName(copyBinaryTaskName) != null) {
+                    buildTasks += tasks.getByName(copyBinaryTaskName)
+                } else {
+                    buildTasks += tasks.create(name: copyBinaryTaskName, type: Copy) {
+                        String filenameSuffix = edition == "mono" ? "${edition}${capitalizedTarget}" : target
+                        dependsOn ":app:assemble${capitalizedEdition}${capitalizedTarget}"
+                        from("app/build/outputs/apk/${edition}/${target}")
+                        into(binDir)
+                        include("android_${filenameSuffix}.apk")
+                    }
+                }
             } else {
                 // Copy the generated editor apk to the bin directory.
-                tasks += "copyEditor${capitalizedTarget}ApkToBin"
+                String copyEditorApkTaskName = "copyEditor${capitalizedAndroidDistro}${capitalizedTarget}ApkToBin"
+                if (tasks.findByName(copyEditorApkTaskName) != null) {
+                    buildTasks += tasks.getByName(copyEditorApkTaskName)
+                } else {
+                    buildTasks += tasks.create(name: copyEditorApkTaskName, type: Copy) {
+                        dependsOn ":editor:assemble${capitalizedAndroidDistro}${capitalizedTarget}"
+                        from("editor/build/outputs/apk/${androidDistro}/${target}")
+                        into(androidEditorBuildsDir)
+                        include("android_editor-${androidDistro}-${target}*.apk")
+                    }
+                }
+
                 // Copy the generated editor aab to the bin directory.
-                tasks += "copyEditor${capitalizedTarget}AabToBin"
+                String copyEditorAabTaskName = "copyEditor${capitalizedAndroidDistro}${capitalizedTarget}AabToBin"
+                if (tasks.findByName(copyEditorAabTaskName) != null) {
+                    buildTasks += tasks.getByName(copyEditorAabTaskName)
+                } else {
+                    buildTasks += tasks.create(name: copyEditorAabTaskName, type: Copy) {
+                        dependsOn ":editor:bundle${capitalizedAndroidDistro}${capitalizedTarget}"
+                        from("editor/build/outputs/bundle/${androidDistro}${capitalizedTarget}")
+                        into(androidEditorBuildsDir)
+                        include("android_editor-${androidDistro}-${target}*.aab")
+                    }
+                }
             }
         } else {
             logger.lifecycle("No native shared libs for target $target. Skipping build.")
         }
     }
 
-    return tasks
-}
-
-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')
+    return buildTasks
 }
 
 /**
- * Generate the Godot Editor Android apk.
+ * Generate the Godot Editor binaries for Android devices.
  *
  * Note: Unless the 'generateNativeLibs` argument is specified, 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.
+ * The task will only build the binaries for which the shared libraries is available.
  */
 task generateGodotEditor {
     gradle.startParameter.excludedTaskNames += templateExcludedBuildTask()
-    dependsOn = generateBuildTasks("editor")
+    dependsOn = generateBuildTasks("editor", "standard", "android")
+}
+
+/**
+ * Generate the Godot Editor binaries for HorizonOS devices.
+ *
+ * Note: Unless the 'generateNativeLibs` argument is specified, the Godot 'tools' shared libraries
+ * must have been generated (via scons) prior to running this gradle task.
+ * The task will only build the binaries for which the shared libraries is available.
+ */
+task generateGodotHorizonOSEditor {
+    gradle.startParameter.excludedTaskNames += templateExcludedBuildTask()
+    dependsOn = generateBuildTasks("editor", "standard", "horizonos")
+}
+
+/**
+ * Generate the Godot Editor binaries for PicoOS devices.
+ *
+ * Note: Unless the 'generateNativeLibs` argument is specified, the Godot 'tools' shared libraries
+ * must have been generated (via scons) prior to running this gradle task.
+ * The task will only build the binaries for which the shared libraries is available.
+ */
+task generateGodotPicoOSEditor {
+    gradle.startParameter.excludedTaskNames += templateExcludedBuildTask()
+    dependsOn = generateBuildTasks("editor", "standard", "picoos")
 }
 
 /**
@@ -296,6 +259,17 @@ task generateGodotTemplates {
     finalizedBy 'zipGradleBuild'
 }
 
+/**
+ * Master task used to coordinate the tasks defined above to generate the set of Godot templates
+ * for the 'mono' edition of the engine.
+ */
+task generateGodotMonoTemplates {
+    gradle.startParameter.excludedTaskNames += templateExcludedBuildTask()
+    dependsOn = generateBuildTasks("template", "mono")
+
+    finalizedBy 'zipGradleBuild'
+}
+
 /**
  * Generates the same output as generateGodotTemplates but with dev symbols
  */
@@ -354,6 +328,9 @@ task cleanGodotTemplates(type: Delete) {
     delete("$binDir/android_debug.apk")
     delete("$binDir/android_dev.apk")
     delete("$binDir/android_release.apk")
+    delete("$binDir/android_monoDebug.apk")
+    delete("$binDir/android_monoDev.apk")
+    delete("$binDir/android_monoRelease.apk")
     delete("$binDir/android_source.zip")
     delete("$binDir/godot-lib.template_debug.aar")
     delete("$binDir/godot-lib.template_debug.dev.aar")