build.gradle

import org.gradle.internal.os.OperatingSystem

plugins {
    id 'net.ltgt.errorprone' version '0.0.8'
    id 'edu.wpi.first.wpilib.versioning.WPILibVersioningPlugin' version '1.6'
    id "de.undercouch.download" version "3.2.0"
}

allprojects {
    repositories {
        mavenCentral()
    }
}

import de.undercouch.gradle.tasks.download.Download

if (!hasProperty('releaseType')) {
    WPILibVersion {
        releaseType = 'official'
    }
}


ext.buildArm = !project.hasProperty('skipArm')
ext.buildNative = !project.hasProperty('skipNative')
ext.buildx86 = !project.hasProperty('skipx86')

task downloadCompiler(type: Download) {
    src 'http://first.wpi.edu/FRC/roborio/toolchains/FRC-2017-Windows-Toolchain-4.9.3.zip'
    dest buildDir
    overwrite false
    onlyIfNewer true
}

ext.compilerUnzipLocation = "${buildDir}/compiler"

task unzipCompiler(type: Copy) {
    dependsOn downloadCompiler
    
    from zipTree("${buildDir}/FRC-2017-Windows-Toolchain-4.9.3.zip")
    into compilerUnzipLocation
}

if (new File(compilerUnzipLocation).exists()) {
    ext.toolChainPath = "${compilerUnzipLocation}/frc/bin"
}

if (hasProperty('makeDesktop')) {
    println 'Making desktop classifier jar. NOTE: This desktop version should only be used for local testing.' +
            'It will only support the current platform, and will override fetching the latest development version from' +
            ' the maven repo until you manually delete it!'
}

ext.getPlatformPath2 = { targetPlatform ->
    if (targetPlatform.architecture.arm) {
        return 'Linux/arm'
    } else if (targetPlatform.operatingSystem.linux) {
        if (targetPlatform.architecture.amd64) {
            return 'Linux/amd64'
        } else {
            return 'Linux/' + targetPlatform.architecture.name
        }
    } else if (targetPlatform.operatingSystem.windows) {
        if (targetPlatform.architecture.amd64) {
            return 'Windows/amd64'
        } else {
            return 'Windows/' + targetPlatform.architecture.name
        }
    } else if (targetPlatform.operatingSystem.macOsX) {
        if (targetPlatform.architecture.amd64) {
            return 'Mac OS X/x86_64'
        } else {
            return 'Mac OS X/' + targetPlatform.architecture.name
        }
    } else {
        return targetPlatform.operatingSystem.name + '/' + targetPlatform.architecture.name
    }
}

ext.getPlatformPath = { binary ->
    return getPlatformPath2(binary.targetPlatform)
}

apply from: "locations.gradle"

apply from: "properties.gradle"

apply from: "dependencies.gradle"

ext.setupDefines = { project, binaries ->
    binaries.all {
	if (project.hasProperty('debug')) {
	    project.setupDebugDefines(cppCompiler, linker)
	} else {
	    project.setupReleaseDefines(cppCompiler, linker)
	}
        tasks.withType(CppCompile) {
            if (!project.hasProperty('compilerPrefix') && targetPlatform.architecture.name == 'arm-v7') {
                // RoboRio, Link Nothing
            } else {
                // Everything else, link cscore and wpiutil
                project.addWpiUtilStaticLibraryLinks(it, linker, targetPlatform)
                // CsCore not currently supported
                project.addCsCoreStaticLibraryLinks(it, linker, targetPlatform)
            }
            project.addOpenCvLibraryLinks(it, linker, targetPlatform)
        }
    }
}

apply from: "cpp.gradle"

// Empty task for build so that zips will be
// built when running ./gradlew build
task build

task clean(type: Delete) {
    description = "Deletes the build directory"
    group = "Build"
    delete buildDir
}

def outputDir = file("${rootDir}/output")

task copyOutputs(type: Copy) {
    destinationDir = outputDir
    def ntv = project(":native")
    dependsOn ntv.opencvZip
    def arm = project(":arm")
    if (buildArm) {
        dependsOn arm.opencvZip
    }
    from (ntv.opencvZip.outputs) {}
    if (buildArm) {
        from (arm.opencvZip.outputs) {}
    }
    if (project.hasProperty("copywpilibs")) {
        dependsOn ntv.depsZip
        from (ntv.depsZip.outputs) {
            into project.getWpiLibDeps(ntv)
        }
        if (buildArm) {
            dependsOn arm.depsZip
            from (arm.depsZip.outputs) {
                into project.getWpiLibDeps(arm)
            }
        }
    }
}

task copyToNet(type: Copy) {
    destinationDir = file("${rootDir}/src/FRC.OpenCvSharp.DesktopLibraries/Libraries")

    project(':native').model {
        binaries {
            withType(SharedLibraryBinarySpec) { binary ->
                from(binary.sharedLibraryFile) {
                    if (targetPlatform.architecture.amd64) {
                        into 'amd64'
                    } else {
                        into targetPlatform.architecture.name
                    }
                }
            }
        }
    }
}

project(':native').tasks.whenTaskAdded { task ->
    def name = task.name.toLowerCase()
    if (name.contains("sharedlibrary") || name.contains("staticlibrary")) {
        copyToNet.dependsOn task
    }
}

build.dependsOn copyOutputs

clean {
    delete outputDir
}

task wrapper(type: Wrapper) {
    gradleVersion = '3.3'
}