shared/jni/setupBuild.gradle

apply plugin: 'cpp'
apply plugin: 'google-test-test-suite'
apply plugin: 'visual-studio'
apply plugin: 'edu.wpi.first.NativeUtils'
apply plugin: 'edu.wpi.first.GradleJni'
apply plugin: SingleNativeBuild
apply plugin: ExtraTasks

apply from: "${rootDir}/shared/config.gradle"

ext {
    baseId = nativeName
    groupId = "edu.wpi.first.${nativeName}"
}

apply from: "${rootDir}/shared/java/javacommon.gradle"

dependencies {
    if (!project.hasProperty('noWpiutil')) {
        compile project(':wpiutil')
        devCompile project(':wpiutil')
    }
}

project(':').libraryBuild.dependsOn build

ext {
    staticGtestConfigs = [:]
}

staticGtestConfigs["${nativeName}Test"] = []

apply from: "${rootDir}/shared/googletest.gradle"

if (project.hasProperty('niLibraries')) {
    ext {
        chipObjectComponents = ["$nativeName".toString(), "${nativeName}Dev".toString(), "${nativeName}Base".toString(),
                                "${nativeName}JNI".toString(), "${nativeName}JNIShared".toString(), "${nativeName}Test".toString()]
        netCommComponents = ["$nativeName".toString(), "${nativeName}Dev".toString(), "${nativeName}Base".toString(),
                             "${nativeName}JNI".toString(), "${nativeName}JNIShared".toString(), "${nativeName}Test".toString()]
        useNiJava = true
    }

    apply from: "${rootDir}/shared/nilibraries.gradle"
}

model {
    components {
        "${nativeName}Base"(NativeLibrarySpec) {
            if (project.hasProperty('setBaseName')) {
                baseName = setBaseName
            }
            sources {
                cpp {
                    source {
                        srcDirs 'src/main/native/cpp'
                        include '**/*.cpp'
                        exclude '**/jni/*.cpp'
                    }
                    exportedHeaders {
                        srcDir 'src/main/native/include'
                        if (project.hasProperty('generatedHeaders')) {
                            srcDir generatedHeaders
                        }
                        include '**/*.h'
                    }
                }
            }
            binaries.all {
                if (it instanceof SharedLibraryBinarySpec) {
                    it.buildable = false
                    return
                }
                if (!project.hasProperty('noWpiutil')) {
                    lib project: ':wpiutil', library: 'wpiutil', linkage: 'shared'
                }
                if (project.hasProperty('splitSetup')) {
                    splitSetup(it)
                }
            }
        }
        "${nativeName}"(NativeLibrarySpec) {
            if (project.hasProperty('setBaseName')) {
                baseName = setBaseName
            }
            sources {
                cpp {
                    source {
                        srcDirs "${rootDir}/shared/singlelib"
                        include '**/*.cpp'
                    }
                    exportedHeaders {
                        srcDir 'src/main/native/include'
                        if (project.hasProperty('generatedHeaders')) {
                            srcDir generatedHeaders
                        }
                    }
                }
            }
            if (!project.hasProperty('noWpiutil')) {
                binaries.all {
                    lib project: ':wpiutil', library: 'wpiutil', linkage: 'shared'
                }
            }
            appendDebugPathToBinaries(binaries)
        }
        "${nativeName}JNIShared"(JniNativeLibrarySpec) {
            if (project.hasProperty('setBaseName')) {
                baseName = setBaseName + 'jni'
            } else {
                baseName = nativeName + 'jni'
            }

            enableCheckTask true
            javaCompileTasks << compileJava
            jniCrossCompileOptions << JniCrossCompileOptions(nativeUtils.wpi.platforms.roborio)
            jniCrossCompileOptions << JniCrossCompileOptions(nativeUtils.wpi.platforms.raspbian)
            jniCrossCompileOptions << JniCrossCompileOptions(nativeUtils.wpi.platforms.aarch64bionic)
            sources {
                cpp {
                    source {
                        srcDirs 'src/main/native/cpp'
                        include '**/jni/*.cpp'
                    }
                    exportedHeaders {
                        srcDir 'src/main/native/include'
                        if (project.hasProperty('generatedHeaders')) {
                            srcDir generatedHeaders
                        }
                        include '**/*.h'
                    }

                }
            }
            binaries.all {
                if (it instanceof StaticLibraryBinarySpec) {
                    it.buildable = false
                    return
                }
                lib library: "${nativeName}", linkage: 'shared'
                if (!project.hasProperty('noWpiutil')) {
                    lib project: ':wpiutil', library: 'wpiutil', linkage: 'shared'
                }
                if (project.hasProperty('jniSplitSetup')) {
                    jniSplitSetup(it)
                }
            }
        }
        "${nativeName}JNI"(JniNativeLibrarySpec) {
            if (project.hasProperty('setBaseName')) {
                baseName = setBaseName + 'jni'
            } else {
                baseName = nativeName + 'jni'
            }

            enableCheckTask true
            javaCompileTasks << compileJava
            jniCrossCompileOptions << JniCrossCompileOptions(nativeUtils.wpi.platforms.roborio)
            jniCrossCompileOptions << JniCrossCompileOptions(nativeUtils.wpi.platforms.raspbian)
            jniCrossCompileOptions << JniCrossCompileOptions(nativeUtils.wpi.platforms.aarch64bionic)
            sources {
                cpp {
                    source {
                        srcDirs 'src/main/native/cpp'
                        include '**/jni/*.cpp'
                    }
                    exportedHeaders {
                        srcDir 'src/main/native/include'
                        if (project.hasProperty('generatedHeaders')) {
                            srcDir generatedHeaders
                        }
                        include '**/*.h'
                    }
                }
            }
            binaries.all {
                if (it instanceof StaticLibraryBinarySpec) {
                    it.buildable = false
                    return
                }
                if (!project.hasProperty('noWpiutil')) {
                    lib project: ':wpiutil', library: 'wpiutil', linkage: 'static'
                }
                if (project.hasProperty('jniSplitSetup')) {
                    jniSplitSetup(it)
                }
            }
        }
        // By default, a development executable will be generated. This is to help the case of
        // testing specific functionality of the library.
        "${nativeName}Dev"(NativeExecutableSpec) {
            targetBuildTypes 'debug'
            sources {
                cpp {

                    source {
                        srcDirs 'src/dev/native/cpp'
                        include '**/*.cpp'
                    }
                    exportedHeaders {
                        srcDir 'src/main/native/include'
                        if (project.hasProperty('generatedHeaders')) {
                            srcDir generatedHeaders
                        }
                    }
                }
            }
            binaries.all {
                lib library: nativeName, linkage: 'shared'
                lib library: "${nativeName}JNIShared", linkage: 'shared'
                if (!project.hasProperty('noWpiutil')) {
                    lib project: ':wpiutil', library: 'wpiutil', linkage: 'shared'
                }
            }
        }
    }
    testSuites {
        "${nativeName}Test"(GoogleTestTestSuiteSpec) {
            for(NativeComponentSpec c : $.components) {
                if (c.name == nativeName) {
                    testing c
                    break
                }
            }
            sources {
                cpp {
                    source {
                        srcDirs 'src/test/native/cpp'
                        include '**/*.cpp'
                    }
                    exportedHeaders {
                        srcDirs 'src/test/native/include', 'src/main/native/cpp'
                        if (project.hasProperty('generatedHeaders')) {
                            srcDir generatedHeaders
                        }
                    }
                }
            }
        }
    }
    binaries {
        withType(GoogleTestTestSuiteBinarySpec) {
            lib library: nativeName, linkage: 'shared'
            if (!project.hasProperty('noWpiutil')) {
                lib project: ':wpiutil', library: 'wpiutil', linkage: 'shared'
            }
        }
    }
    tasks {
        def c = $.components
        project.tasks.create('runCpp', Exec) {
            group = 'WPILib'
            description = "Run the ${nativeName}Dev executable"
            def found = false
            def systemArch = getCurrentArch()
            c.each {
                if (it in NativeExecutableSpec && it.name == "${nativeName}Dev") {
                    it.binaries.each {
                        if (!found) {
                            def arch = it.targetPlatform.name
                            if (arch == systemArch) {
                                dependsOn it.tasks.install
                                commandLine it.tasks.install.runScriptFile.get().asFile.toString()
                                def filePath = it.tasks.install.installDirectory.get().toString() + File.separatorChar + 'lib'
                                test.dependsOn it.tasks.install
                                test.systemProperty 'java.library.path', filePath
                                test.environment 'LD_LIBRARY_PATH', filePath
                                test.workingDir filePath
                                run.dependsOn it.tasks.install
                                run.systemProperty 'java.library.path', filePath
                                run.environment 'LD_LIBRARY_PATH', filePath
                                run.workingDir filePath

                                found = true
                            }
                        }
                    }
                }
            }
        }
    }
}

ext.getJniSpecClass = {
    return JniNativeLibrarySpec
}

tasks.withType(RunTestExecutable) {
    args "--gtest_output=xml:test_detail.xml"
    outputs.dir outputDir
}

apply from: "${rootDir}/shared/jni/publish.gradle"