allwpilib/java/java.gradle

import org.gradle.internal.os.OperatingSystem

apply plugin: 'java'
apply plugin: 'net.ltgt.errorprone'

repositories {
    mavenCentral()
}

configurations.errorprone {
    resolutionStrategy.force 'com.google.errorprone:error_prone_core:2.0.9'
}

def generatedJNIHeaderLoc = "${buildDir}/include"

sourceSets {
    main {
        java {
            srcDirs = ["${rootDir}/java/src"]
        }
    }
}

jar {
    description = 'Generates CameraServer jar, with the JNI shared libraries embedded'
    baseName = 'cameraserver'
    classifier = "$buildPlatform"
    duplicatesStrategy = 'exclude'

    dependsOn { classes }
    model {
        binaries {
            withType(SharedLibraryBinarySpec) { binary ->
                from(file(binary.sharedLibraryFile)) {
                    into getPlatformPath(binary)
                }
            }
        }
    }
}

project.tasks.whenTaskAdded { task ->
    if (isArm) {
        if (task.name == 'cameraserverSharedLibrary') jar.dependsOn task
    } else {
        if (task.name == 'cameraserverX64SharedLibrary' || task.name == 'cameraserverX86SharedLibrary')
            jar.dependsOn task
    }
}

task cameraserverJavaSource(type: Jar, dependsOn: classes) {
    description = 'Generates the source jar for CameraServer java'
    group = 'WPILib'
    baseName = 'cameraserver'
    classifier = "sources"
    duplicatesStrategy = 'exclude'

    from sourceSets.main.allJava
}

task cameraserverJavadoc(type: Jar, dependsOn: javadoc) {
    description = 'Generates the javadoc jar for CameraServer java'
    group = 'WPILib'
    baseName = 'cameraserver'
    classifier = "javadoc"
    duplicatesStrategy = 'exclude'

    from javadoc.destinationDir
}

build.dependsOn cameraserverJavaSource
build.dependsOn cameraserverJavadoc

/**
 * Generates the JNI headers
 */
task jniHeadersCameraServer {
    description = 'Generates JNI headers from edu.wpi.cameraserver.*'
    group = 'WPILib'
    def outputFolder = file(generatedJNIHeaderLoc)
    inputs.files sourceSets.main.output
    outputs.file outputFolder
    doLast {
        outputFolder.mkdirs()
        exec {
            executable org.gradle.internal.jvm.Jvm.current().getExecutable('javah')
            args '-d', outputFolder
            args '-classpath', sourceSets.main.output.classesDir
            args 'edu.wpi.cameraserver.CameraServerJNI'
        }
    }
}

clean {
    delete generatedJNIHeaderLoc
}

compileJava {
    options.compilerArgs << '-Xlint:unchecked'
}

javadoc {
    options.addStringOption('Xdoclint:none', '-quiet')
}

// This creates a lambda that the main build.gradle can access, which sets up the JNI includes for the
// target build platform. This lambda is exposed as a property in the main build.gradle.
ext.setupJniIncludes = { binaries ->
    def platformSpecificIncludeFlag = { loc, cppCompiler ->
        if (OperatingSystem.current().isWindows()) {
            cppCompiler.args "/I$loc"
        } else {
            cppCompiler.args '-I', loc
        }
    }
    binaries.all {
        tasks.withType(CppCompile) {
            if (buildPlatform == 'arm') {
                cppCompiler.args '-I', file("${rootDir}/java/arm-linux").absolutePath
                cppCompiler.args '-I', file("${rootDir}/java/arm-linux/linux").absolutePath
            } else {
                def jdkLocation = org.gradle.internal.jvm.Jvm.current().javaHome
                platformSpecificIncludeFlag("${jdkLocation}/include", cppCompiler)

                if (targetPlatform.operatingSystem.macOsX) {
                    platformSpecificIncludeFlag("${jdkLocation}/include/darwin", cppCompiler)
                } else if (targetPlatform.operatingSystem.linux) {
                    platformSpecificIncludeFlag("${jdkLocation}/include/linux", cppCompiler)
                } else if (targetPlatform.operatingSystem.windows) {
                    platformSpecificIncludeFlag("${jdkLocation}/include/win32", cppCompiler)
                } else if (targetPlatform.operatingSystem.freeBSD) {
                    platformSpecificIncludeFlag("${jdkLocation}/include/freebsd", cppCompiler)
                } else if (file("$jdkLocation/include/darwin").exists()) {
                    // TODO: As of Gradle 2.8, targetPlatform.operatingSystem.macOsX returns false
                    // on El Capitan. We therefore manually test for the darwin folder and include it
                    // if it exists
                    platformSpecificIncludeFlag("${jdkLocation}/include/darwin", cppCompiler)
                }
            }

            jniHeadersCameraServer.outputs.files.each { file ->
                if (buildPlatform == 'arm') {
                    cppCompiler.args '-I', file.getPath()
                } else {
                    platformSpecificIncludeFlag(file.getPath(), cppCompiler)
                }
            }

            dependsOn jniHeadersCameraServer
        }
    }
}