jMonkeyEngine/build.gradle

import java.nio.file.Files;
import java.nio.file.StandardCopyOption;

buildscript {
    repositories {
        google()
        jcenter()
    }
    dependencies {
        classpath 'com.android.tools.build:gradle:3.1.4'
        classpath 'com.jfrog.bintray.gradle:gradle-bintray-plugin:1.8.4'
        classpath 'me.tatarka:gradle-retrolambda:3.7.1'
    }
}

allprojects {
    repositories {
        google()
        jcenter()
    }
}

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

apply plugin: 'me.tatarka.retrolambda'

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

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

defaultTasks 'run'

task libDist(dependsOn: subprojects.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.ext.mainClass == ''){
                project.tasks.withType(Jar).each {archiveTask ->
                    if(archiveTask.classifier == "sources"){
                        copy {
                            from archiveTask.archivePath
                                into sourceFolder
                                rename {project.name + '-' + archiveTask.classifier +'.'+ archiveTask.extension}
                        }
                    } else if(archiveTask.classifier == "javadoc"){
                        copy {
                            from archiveTask.archivePath
                                into javadocFolder
                                rename {project.name + '-' + archiveTask.classifier +'.'+ archiveTask.extension}
                        }
                    } else{
                        copy {
                            from archiveTask.archivePath
                                into libFolder
                                rename {project.name + '.' + archiveTask.extension}
                        }
                    }
                }
            }
        }
    }
}

task createZipDistribution(type:Zip,dependsOn:["dist","libDist"], description:"Package the nightly zip distribution"){
    archiveName "jME" + jmeFullVersion + ".zip"
    into("/") {
         from {"./dist"}
    }
    into("/sources") {
        from {"$buildDir/libDist/sources"}
    }
}

task copyLibs(type: Copy){
//    description 'Copies the engine dependencies to build/libDist'
    from {
        subprojects*.configurations*.compile*.copyRecursive({ !(it instanceof ProjectDependency); })*.resolve()
    }

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

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

task mergedJavadoc(type: Javadoc, description: 'Creates Javadoc from all the projects.') {
    title = 'jMonkeyEngine3'
    destinationDir = mkdir("dist/javadoc")

    options.encoding = 'UTF-8'

    // Allows Javadoc to be generated on Java 8 despite doclint errors.
    if (JavaVersion.current().isJava8Compatible()) {
        options.addStringOption('Xdoclint:none', '-quiet')
    }

    options.overview = file("javadoc-overview.html")
    // Note: The closures below are executed lazily.
    source subprojects.collect {project ->
        project.sourceSets*.allJava
    }
    classpath = files(subprojects.collect {project ->
            project.sourceSets*.compileClasspath})
    //    source {
    //        subprojects*.sourceSets*.main*.allSource
    //    }
    classpath.from {
        subprojects*.configurations*.compile*.copyRecursive({ !(it instanceof ProjectDependency); })*.resolve()
    }
}

clean.dependsOn('cleanMergedJavadoc')
task cleanMergedJavadoc(type: Delete) {
    delete file('dist/javadoc')
}

task mergedSource(type: Copy){

}

ext {
    ndkCommandPath  = ""
    ndkExists       = false
}

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"
    }

    // ndkPath is defined in the root project gradle.properties file
    String ndkBuildPath = ndkPath + File.separator + ndkBuildFile
    //Use the environment variable for the NDK location if defined
    if (System.env.ANDROID_NDK != null) {
        ndkBuildPath = System.env.ANDROID_NDK + File.separator + ndkBuildFile
    }

    if (new File(ndkBuildPath).exists()) {
        ndkExists = true
        ndkCommandPath = ndkBuildPath
    }
}

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

if (skipPrebuildLibraries != "true" && buildNativeProjects != "true") {
    String rootPath = rootProject.projectDir.absolutePath

    Properties nativesSnasphotProp = new Properties()
    File nativesSnasphotPropF = new File("${rootPath}/natives-snapshot.properties");

    if (nativesSnasphotPropF.exists()) {

        nativesSnasphotPropF.withInputStream { nativesSnasphotProp.load(it) }

        String nativesSnasphot = nativesSnasphotProp.getProperty("natives.snapshot");
        String nativesUrl = PREBUILD_NATIVES_URL.replace('${natives.snapshot}', nativesSnasphot)
        println "Use natives snapshot: " + nativesUrl

        String nativesZipFile = "${rootPath}" + File.separator + "build" + File.separator + nativesSnasphot + "-natives.zip"
        String nativesPath = "${rootPath}" + File.separator + "build" + File.separator + "native"


        task getNativesZipFile {
            outputs.file nativesZipFile
            doFirst {
                File target = file(nativesZipFile);
                println("Download natives from " + nativesUrl + " to " + nativesZipFile);
                target.getParentFile().mkdirs();
                ant.get(src: nativesUrl, dest: target);
            }
        }

        task extractPrebuiltNatives {
            inputs.file nativesZipFile
            outputs.dir nativesPath
            dependsOn getNativesZipFile

            doFirst {
                for (File src : zipTree(nativesZipFile)) {
                    String srcRel = src.getAbsolutePath().substring((int) (nativesZipFile.length() + 1));
                    srcRel = srcRel.substring(srcRel.indexOf(File.separator) + 1);

                    File dest = new File(nativesPath + File.separator + srcRel);
                    boolean doCopy = !(dest.exists() && dest.lastModified() > src.lastModified())
                    if (doCopy) {
                        println("Copy " + src + " " + dest);
                        dest.getParentFile().mkdirs();
                        Files.copy(src.toPath(), dest.toPath(), StandardCopyOption.REPLACE_EXISTING);
                    }
                }
            }
        }

        assemble.dependsOn extractPrebuiltNatives
    }
}


//class IncrementalReverseTask extends DefaultTask {
//    @InputDirectory
//    def File inputDir
//
//    @OutputDirectory
//    def File outputDir
//
//    @Input
//    def inputProperty
//
//    @TaskAction
//    void execute(IncrementalTaskInputs inputs) {
//        println inputs.incremental ? "CHANGED inputs considered out of date" : "ALL inputs considered out of date"
//        inputs.outOfDate { change ->
//            println "out of date: ${change.file.name}"
//            def targetFile = new File(outputDir, change.file.name)
//            targetFile.text = change.file.text.reverse()
//        }
//
//        inputs.removed { change ->
//            println "removed: ${change.file.name}"
//            def targetFile = new File(outputDir, change.file.name)
//            targetFile.delete()
//        }
//    }
//}

//allprojects {
//    tasks.withType(JavaExec) {
//        enableAssertions = true // false by default
//    }
//    tasks.withType(Test) {
//        enableAssertions = true // true by default
//    }
//}

wrapper {
    gradleVersion = '5.6.4'
}


retrolambda {
  javaVersion JavaVersion.VERSION_1_7
  incremental true
    jvmArgs '-noverify'
}