build.gradle

import org.gradle.internal.os.OperatingSystem

buildscript {
    repositories {
        mavenLocal()
        mavenCentral()
    }
}

plugins {
    id 'java'
    id 'java-library'
    id 'maven-publish'
    id 'maven'
}

repositories {
    mavenLocal()
    mavenCentral()
}
sourceCompatibility = 1.8
targetCompatibility = 1.8

dependencies {
    testImplementation 'org.junit.jupiter:junit-jupiter-api:5.6.0'
    testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.6.0'
    testImplementation 'com.fasterxml.jackson.core:jackson-databind:2.8.9'
}
version = '0.14.0-beta-2'

tasks.withType(JavaCompile) {
    options.encoding = 'UTF-8'
}

test {
    useJUnitPlatform()
    systemProperty "file.encoding", "utf-8"
}

sourceSets {
    main {
        resources {
            if (OperatingSystem.current().isLinux() ||
                    OperatingSystem.current().isMacOsX() ||
                    OperatingSystem.current().isUnix()) {
                srcDirs "src/main/resources", "build/natives/lib/Release", "build/natives/downloads"
            } else if (OperatingSystem.current().isWindows()) {
                srcDirs "src/main/resources", "build/natives/bin/Release", "build/natives/downloads"
            }
        }
    }
}

compileJava {
    if (OperatingSystem.current().isLinux()) {
        def armJavacPath = ""
        def armJavaPath = ""
        def armJdkPath = ""
        if (project.hasProperty('armJdkPath')) {
            armJdkPath = project.getProperties()['armJdkPath'] as String
            armJavacPath = file(armJdkPath + '/bin/javac').absolutePath
            armJavaPath = file(armJdkPath + '/bin/java').absolutePath
        }
        def modifiedJavacFile = new File('armjavac.sh')
        def modifiedJavaFile = new File('armjava.sh')

        def qemuCommand = ""
        if (project.hasProperty("aarch64Build")) {
            qemuCommand = 'qemu-aarch64 -L /usr/aarch64-linux-gnu/ '
        } else if (project.hasProperty("aarch32Build")) {
            qemuCommand = 'qemu-arm -L /usr/arm-linux-gnueabihf/ '
        }

        if (project.hasProperty("aarch64Build") || project.hasProperty("aarch32Build")) {
            if (armJdkPath.isEmpty()) {
                throw new InvalidUserDataException("ARM JDK path not provided.\n" +
                        "Specify the ARM JDK path like this: -ParmJdkPath=<jdk-path>")
            }

            modifiedJavacFile.withWriter {
                writer -> writer.writeLine qemuCommand + armJavacPath + ' "$@"'
            }
            modifiedJavacFile.setExecutable(true)
            modifiedJavaFile.withWriter {
                writer -> writer.writeLine qemuCommand + armJavaPath + ' "$@"'
            }
            modifiedJavaFile.setExecutable(true)

            project.logger.info(qemuCommand + armJavaPath + ' "$@"')

            if (modifiedJavacFile.exists() && modifiedJavaFile.exists()) {
                options.forkOptions.executable = file(modifiedJavacFile.path).absolutePath
                test.executable = file(modifiedJavaFile.path).absolutePath
            }
        }
    }

    System.setProperty("user.dir", project.projectDir.toString())
    options.compilerArgs += ["-h", file("src/main/include")]
    options.encoding = "UTF-8"
}

task compileJNI {
    dependsOn compileJava
    outputs.upToDateWhen { false }
    doLast {
        def nativeDir = new File(project.projectDir.toString() + '/build/natives')

        if (!nativeDir.exists()) {
            nativeDir.mkdirs()
        }

        String architecture = ""

        // determine CPU architecture name and windows generator name
        String generator = ""
        String osArch = System.getProperty("os.arch")

        if (osArch in ["arm", "aarch32"] || project.hasProperty("aarch32Build")) {
            architecture = "aarch32"
            generator = "ARM"
        } else if (osArch in ["arm64", "aarch64"] || project.hasProperty("aarch64Build")) {
            architecture = "aarch64"
            generator = "ARM64"
        } else if (osArch.endsWith("86")) {
            architecture = "x86"
            generator = "Win32"
        } else if (osArch in ["amd64", "x86_64"]) {
            architecture = "amd64"
            generator = "x64"
        }

        String buildConcurrency = "-j " + Runtime.getRuntime().availableProcessors().toString()
        // this property will not be used for android builds, as android builds use ninja instead of make
        if (project.hasProperty("j")) {
            buildConcurrency = "-j " + project['j'].toString()
        }

        if (OperatingSystem.current().isLinux()) {
            if (project.hasProperty("androidBuild") && project.hasProperty("androidSDKPath")) {
                invokeAndroidBuild(nativeDir) // ANDROID BUILD
            } else if (project.hasProperty("androidBuild") || project.hasProperty("androidSDKPath")) {
                throw new GradleException("Both properties, androidBuild and androidSDKPath need to be defined.")
            } else { // LINUX BUILD
                invokeLinuxBuild(nativeDir, architecture, buildConcurrency)
            }
        } else if (OperatingSystem.current().isMacOsX()) { // MAC OS BUILD
            invokeMacOSBuild(nativeDir, architecture, buildConcurrency)
        } else if (OperatingSystem.current().isWindows()) { // WINDOWS BUILD
            invokeWindowsBuild(nativeDir, architecture, generator, buildConcurrency)
        } else {
            throw new GradleException(String.format("Operating System not supported: %s", OperatingSystem.current().getName()))
        }
    }
}

def invokeAndroidBuild(File nativeDir) {
    def androidArchitectures = ["arm64-v8a", "x86_64", "armeabi-v7a", "x86"] as String[]
    def androidSDKPath = project.getProperties()['androidSDKPath'].toString()

    logger.info(String.format("Executing Android build. Architectures: %s", Arrays.toString(androidArchitectures)))

    for (arch in androidArchitectures) {
        exec {
            commandLine 'cmake', '-B' + nativeDir.getPath(), '-S.', '-GNinja', '-DANDROID_ABI=' + arch, '-DANDROID_NDK=' + androidSDKPath + '/ndk/22.0.7026061', '-DCMAKE_BUILD_TYPE=Release', '-DCMAKE_MAKE_PROGRAM=' + androidSDKPath + '/cmake/3.10.2.4988404/bin/ninja', '-DCMAKE_TOOLCHAIN_FILE=' + androidSDKPath + '/ndk/22.0.7026061/build/cmake/android.toolchain.cmake', '-DANDROID_NATIVE_API_LEVEL=23', '-DANDROID_TOOLCHAIN=clang'
        }
        exec {
            commandLine 'cmake', '--build', nativeDir.getPath(), '--config', 'Release'
        }
        exec {
            commandLine 'rm', nativeDir.getPath() + '/CMakeCache.txt'
        }
        renamePlatformArtifactsDirectoryAccordingToArchitecture(nativeDir, arch)
    }
}

def invokeMacOSBuild(File nativeDir, String architecture, String buildConcurrency) {
    logger.info(String.format("Executing macOS build. Architecture: %s", architecture))
    exec {
        commandLine 'cmake', '-B' + nativeDir.getPath(), '-S.'
    }
    exec {
        commandLine 'cmake', '--build', nativeDir.getPath(), '--config', 'Release', buildConcurrency
    }
    renamePlatformArtifactsDirectoryAccordingToArchitecture(nativeDir, architecture)
}

def invokeLinuxBuild(File nativeDir, String architecture, String buildConcurrency) {
    logger.info(String.format("Executing Linux build. Architecture: %s", architecture))
    def isCMakeToolchainFileRequired = architecture in ["aarch64", "aarch32", "x86"] || project.hasProperty("aarch64Build") || project.hasProperty("aarch32Build")
    def cmakeToolchain = ""
    if (isCMakeToolchainFileRequired) {
        cmakeToolchain = "-DCMAKE_TOOLCHAIN_FILE=./linux-" + architecture + "-toolchain.cmake"
    }
    exec {
        commandLine 'cmake', '-B' + nativeDir.getPath(), '-S.', cmakeToolchain
    }
    exec {
        commandLine 'cmake', '--build', nativeDir.getPath(), '--config', 'Release', buildConcurrency
    }
    renamePlatformArtifactsDirectoryAccordingToArchitecture(nativeDir, architecture)
}

def invokeWindowsBuild(File nativeDir, String architecture, String generator, String buildConcurrency) {
    logger.info(String.format("Executing Windows build. Architecture: %s", architecture))
    exec {
        commandLine 'cmake', '-B' + nativeDir.getPath(), '-S.', '-A', generator
    }
    exec {
        commandLine 'cmake', '--build', nativeDir.getPath(), '--config', 'Release', buildConcurrency
    }
    renamePlatformArtifactsDirectoryAccordingToArchitecture(nativeDir, architecture)
}

def renamePlatformArtifactsDirectoryAccordingToArchitecture(File nativeDir, String architecture) {
    def platformArtifactsDirectoryPath = ""
    def artifactsDirectoryPath = "lib/Release/"

    // determine path for directory created after cmake build, eg: build/natives/lib/Release/Linux
    if (OperatingSystem.current().isLinux()) {
        if (project.hasProperty("androidBuild") && project.hasProperty("androidSDKPath")) {
            platformArtifactsDirectoryPath = artifactsDirectoryPath + "Android"
        } else {
            platformArtifactsDirectoryPath = artifactsDirectoryPath + "Linux"
        }
    } else if (OperatingSystem.current().isWindows()) {
        platformArtifactsDirectoryPath = "bin/Release/Windows"
    } else {
        // do not rename artifacts directory for OSes other than windows & linux
        return
    }
    def platformArtifactsDirectory = new File(nativeDir, platformArtifactsDirectoryPath)
    System.out.println(platformArtifactsDirectory.getPath())

    // determine renamed path, including the architecture for the build, eg: build/natives/lib/Release/Linux-amd64
    def architectureArtifactsDirectoryPath = ""
    if (OperatingSystem.current().isLinux() && project.hasProperty("androidBuild") && project.hasProperty("androidSDKPath")) {
        // naming pattern for android is different, eg:  build/natives/lib/Release/arm64-v8a
        // so, handle that separately
        architectureArtifactsDirectoryPath = artifactsDirectoryPath + architecture
    } else {
        architectureArtifactsDirectoryPath = platformArtifactsDirectoryPath + "-" + architecture
    }
    def architectureArtifactsDirectory = new File(nativeDir, architectureArtifactsDirectoryPath)

    // if build has been rerun, delete the existing artifacts
    if (architectureArtifactsDirectory.exists()) {
        architectureArtifactsDirectory.deleteDir()
    }

    // rename the directory created after cmake build to include architecture in the directory name
    if (platformArtifactsDirectory.exists()) {
        platformArtifactsDirectory.renameTo(architectureArtifactsDirectory)
    }
}

clean.doFirst {
    delete fileTree('src/main/include') {
        include 'io_opentimeline_*.h'
    }
}

processResources {
    dependsOn compileJNI
}

tasks.withType(Test) {
    if (OperatingSystem.current().isLinux()) {
        systemProperty "java.library.path", "build/natives/lib/Release/Linux"
    } else if (OperatingSystem.current().isMacOsX()) {
        systemProperty "java.library.path", "build/natives/lib/Release/Darwin"
    } else if (OperatingSystem.current().isWindows()) {
        systemProperty "java.library.path", "build\\natives\\bin\\Release\\Windows"
    }
    testLogging.showStandardStreams = false
}

task sourcesJar(type: Jar, dependsOn: classes) {
    classifier = 'sources'
    from sourceSets.main.allSource
}

javadoc.failOnError = false
javadoc {
    options.overview = "overview.html" // relative to source root
}
task javadocJar(type: Jar, dependsOn: javadoc) {
    classifier = 'javadoc'
    from javadoc.destinationDir
}

artifacts {
    archives sourcesJar
    archives javadocJar
}

task createPom {
    pom {
        project {
            groupId 'io.opentimeline'
            artifactId 'opentimelineio'
            version version.toString()
            description 'OpenTimelineIO is an interchange format and API for editorial cut information. OTIO is not a container format for media, rather it contains information about the order and length of cuts and references to external media.'
            url 'opentimeline.io'
            name 'OpenTimelineIO'
            licenses {
                license {
                    name "Modified Apache 2.0 License"
                    url "https://github.com/PixarAnimationStudios/OpenTimelineIO/blob/master/LICENSE.txt"
                    distribution "repo"
                }
            }
            developers {
                developer {
                    id "OpenTimelineIO"
                    name "Contributors to the OpenTimelineIO project"
                    email "otio-discussion@lists.aswf.io"
                }
            }
            scm {
                url "https://github.com/PixarAnimationStudios/OpenTimelineIO"
            }
        }
    }.writeTo("build/pom/opentimelineio-" + version.toString() + ".pom")
}