build.gradle

buildscript {
    repositories {
        mavenCentral()
        google()
        maven {
            url = "https://plugins.gradle.org/m2/"
        }
    }
    dependencies {
        classpath libs.android.build.gradle
        classpath libs.spotbugs.gradle.plugin
    }
}

plugins {
    id 'org.jmonkeyengine.nativeimage' apply false
}

import org.gradle.api.file.RelativePath

// Set the license for IDEs that understand this
ext.license = file("$rootDir/source-file-header-template.txt")

apply plugin: 'base'
apply from: file('version.gradle')

allprojects {
    repositories {
        mavenCentral()
        google()
    }
    tasks.withType(Jar) {
        duplicatesStrategy = 'include'
    }
}

// This is applied to all sub projects
subprojects {
    if(!project.name.equals('jme3-android-examples')) {
        apply from: rootProject.file('common.gradle')
    } else {
        apply from: rootProject.file('common-android-app.gradle')
    }

    if (!project.name.endsWith("-native") && enableSpotBugs != "false" ) {
        apply plugin: 'com.github.spotbugs'

        // Currently we only warn about issues and try to fix them as we go, but those aren't mission critical.
        spotbugs {
            ignoreFailures = true
            toolVersion = libs.versions.spotbugs.get()
        }

        tasks.withType(com.github.spotbugs.snom.SpotBugsTask ) {
            reports {
                html.required = !project.hasProperty("xml-reports")
                xml.required = project.hasProperty("xml-reports")
            }
        }
    }
}

def nativeImagePluginBuild = gradle.includedBuild('jme3-nativeimage-plugin')
def nativeImagePluginPublishTasks = [
        publish                                      : ':publish',
        publishToMavenLocal                         : ':publishToMavenLocal',
        install                                      : ':install',
        publishAllPublicationsToCentralRepository   : ':publishAllPublicationsToCentralRepository',
        publishAllPublicationsToSNAPSHOTRepository  : ':publishAllPublicationsToSNAPSHOTRepository',
        publishAllPublicationsToDistRepository      : ':publishAllPublicationsToDistRepository'
]

subprojects {
    tasks.configureEach { task ->
        String includedTaskPath = nativeImagePluginPublishTasks[task.name]
        if (includedTaskPath != null) {
            task.dependsOn nativeImagePluginBuild.task(includedTaskPath)
        }
    }
}

tasks.register('run') {
    dependsOn ':jme3-examples:run'
    description = 'Run the jME3 examples'
}

defaultTasks 'run'

def libDist = tasks.register('libDist') {
    dependsOn(subprojects.collect { it.tasks.named('build') })
    description = 'Builds and copies the engine binaries, sources and javadoc to build/libDist'

    doLast {
        File libFolder = mkdir("$buildDir/libDist/lib")
        File sourceFolder = mkdir("$buildDir/libDist/sources")
        File javadocFolder = mkdir("$buildDir/libDist/javadoc")
        subprojects.each {project ->
            if(!project.hasProperty('mainClassName')){
                project.tasks.withType(Jar).each {archiveTask ->
                    String classifier = archiveTask.archiveClassifier.get()
                    String ext = archiveTask.archiveExtension.get()
                    File archiveFile = archiveTask.archiveFile.get().asFile
                    if (classifier == "sources") {
                        copy {
                            from archiveFile
                                into sourceFolder
                                rename {project.name + '-' + classifier + '.' + ext}
                        }
                    } else if (classifier == "javadoc") {
                        copy {
                            from archiveFile
                                into javadocFolder
                                rename {project.name + '-' + classifier + '.' + ext}
                        }
                    } else{
                        copy {
                            from archiveFile
                                into libFolder
                                rename {project.name + '.' + ext}
                        }
                    }
                }
            }
        }
    }
}

tasks.register('createZipDistribution', Zip) {
    dependsOn(tasks.named('dist'), libDist)
    description = 'Package the nightly zip distribution'
    archiveFileName = provider {
        "jME" + jmeFullVersion + ".zip"
    }
    into("/") {
         from {"./dist"}
    }
    into("/sources") {
        from {"$buildDir/libDist/sources"}
    }
}

tasks.register('copyLibs', Copy) {
//    description 'Copies the engine dependencies to build/libDist'
    from {
        subprojects*.configurations*.implementation*.copyRecursive({ !(it instanceof ProjectDependency); })*.resolve()
    }

    into "$buildDir/libDist/lib-ext" //buildDir.path + '/' + libsDirName + '/lib'
}

tasks.register('dist') {
    dependsOn ':jme3-examples:dist', tasks.named('mergedJavadoc')
    description = 'Creates a jME3 examples distribution with all jme3 binaries, sources, javadoc and external libraries under ./dist'
}

def mergedJavadocSubprojects = [
        ":jme3-android",
        ":jme3-core",
        ":jme3-desktop",
        ":jme3-effects",
        ":jme3-ios",
        ":jme3-jbullet",
        ":jme3-jogg",
        ":jme3-lwjgl",
        ":jme3-lwjgl3",
        ":jme3-networking",
        ":jme3-niftygui",
        ":jme3-plugins",
        ":jme3-terrain",
]
tasks.register('mergedJavadoc', Javadoc) {
    description = 'Creates Javadoc from all the projects.'
    title = 'jMonkeyEngine3'
    destinationDir = file("dist/javadoc")

    options.encoding = 'UTF-8'
    if (JavaVersion.current().isJava8Compatible()) {
        options.addStringOption('Xdoclint:none', '-quiet')
    }

    options.overview = file("javadoc-overview.html")
    source = mergedJavadocSubprojects.collect { project(it).sourceSets.main.allJava }
    classpath = files(mergedJavadocSubprojects.collect { project(it).sourceSets.main.compileClasspath })
}

def cleanMergedJavadoc = tasks.register('cleanMergedJavadoc', Delete) {
    delete file('dist/javadoc')
}

tasks.named('clean') {
    dependsOn cleanMergedJavadoc
}

ext {
    ndkCommandPath  = ""
    ndkExists       = false
}

apply from: 'gradle/jacoco.gradle'

task configureAndroidNDK {
    def ndkBuildFile = "ndk-build"
    // if windows, use ndk-build.cmd instead
    if (System.properties['os.name'].toLowerCase().contains('windows')) {
        ndkBuildFile = "ndk-build.cmd"
    }

    def ndkCandidates = []
    if (System.env.ANDROID_NDK) {
        ndkCandidates << file(System.env.ANDROID_NDK)
    }
    if (System.env.ANDROID_NDK_HOME) {
        ndkCandidates << file(System.env.ANDROID_NDK_HOME)
    }
    if (project.hasProperty('ndkPath') && ndkPath) {
        ndkCandidates << file(ndkPath)
    }

    def localProperties = file('local.properties')
    if (localProperties.isFile()) {
        Properties properties = new Properties()
        localProperties.withInputStream { properties.load(it) }
        if (properties.getProperty('ndk.dir')) {
            ndkCandidates << file(properties.getProperty('ndk.dir'))
        }
        if (properties.getProperty('sdk.dir')) {
            ndkCandidates.addAll(findAndroidNdkDirs(file(properties.getProperty('sdk.dir'))))
        }
    }

    if (System.env.ANDROID_HOME) {
        ndkCandidates.addAll(findAndroidNdkDirs(file(System.env.ANDROID_HOME)))
    }
    if (System.env.ANDROID_SDK_ROOT) {
        ndkCandidates.addAll(findAndroidNdkDirs(file(System.env.ANDROID_SDK_ROOT)))
    }
    ndkCandidates.addAll(findAndroidNdkDirs(file("${System.properties['user.home']}/Android/Sdk")))

    def ndkBuildPath = ndkCandidates.collect { new File(it, ndkBuildFile) }.find { it.isFile() }
    if (ndkBuildPath != null) {
        ndkExists = true
        ndkCommandPath = ndkBuildPath.absolutePath
    }
}

def findAndroidNdkDirs(File sdkDir) {
    def ndkDirs = []
    def nestedSdkDir = new File(sdkDir, 'Sdk')
    if (nestedSdkDir.isDirectory()) {
        ndkDirs.addAll(findAndroidNdkDirs(nestedSdkDir))
    }
    def sideBySideDir = new File(sdkDir, 'ndk')
    if (sideBySideDir.isDirectory()) {
        ndkDirs.addAll(sideBySideDir.listFiles()?.findAll { it.isDirectory() }?.sort { a, b -> b.name <=> a.name } ?: [])
    }
    ndkDirs << new File(sdkDir, 'ndk-bundle')
    return ndkDirs
}

gradle.rootProject.ext.set("usePrebuildNatives", buildNativeProjects!="true");

if (skipPrebuildLibraries != "true" && buildNativeProjects != "true") {
    File nativesSnapshotPropF = file('natives-snapshot.properties')

    if (nativesSnapshotPropF.exists()) {
        def readNativesConfig = {
            Properties nativesSnapshotProp = new Properties()
            nativesSnapshotPropF.withInputStream { nativesSnapshotProp.load(it) }

            String nativesSnapshot = nativesSnapshotProp.getProperty("natives.snapshot")
            if (!nativesSnapshot) {
                throw new GradleException("Missing 'natives.snapshot' in ${nativesSnapshotPropF}")
            }

            [
                snapshot: nativesSnapshot,
                url: PREBUILD_NATIVES_URL.replace('${natives.snapshot}', nativesSnapshot),
                zipFile: layout.buildDirectory.file("${nativesSnapshot}-natives.zip"),
                nativeDir: layout.buildDirectory.dir("native"),
            ]
        }

        def nativesZipFile = providers.provider { readNativesConfig().zipFile.get().asFile }
        def nativesPath = layout.buildDirectory.dir("native")

        def getNativesZipFile = tasks.register('getNativesZipFile') {
            outputs.file(nativesZipFile)
            doFirst {
                def nativesConfig = readNativesConfig()
                File target = nativesConfig.zipFile.get().asFile
                println("Use natives snapshot: ${nativesConfig.url}")
                println("Download natives from ${nativesConfig.url} to ${target}")
                target.getParentFile().mkdirs()
                ant.get(src: nativesConfig.url, dest: target)
            }
        }

        def extractPrebuiltNatives = tasks.register('extractPrebuiltNatives', Sync) {
            dependsOn(getNativesZipFile)
            into(nativesPath)
            from({
                zipTree(readNativesConfig().zipFile.get().asFile)
            }) {
                eachFile { details ->
                    def segments = details.relativePath.segments
                    if (segments.length > 1) {
                        details.path = segments[1..-1].join('/')
                    }
                }
                includeEmptyDirs = false
            }
        }

        tasks.named('assemble') {
            dependsOn extractPrebuiltNatives
        }
    }
}