realm-js/react-native/android/build.gradle

buildscript {
    repositories {
        jcenter()
    }
    dependencies {
        classpath 'com.android.tools.build:gradle:1.3.1'
        classpath 'de.undercouch:gradle-download-task:1.2'
    }
}

allprojects {
    repositories {
        mavenLocal()
        jcenter()
        maven {
            // All of React Native (JS, Obj-C sources, Android binaries) is installed from npm
            url "$projectDir/../../tests/react-test-app/node_modules/react-native/android"
        }
    }
}

apply plugin: 'com.android.library'
apply plugin: 'maven'
apply plugin: 'signing'
apply plugin: 'de.undercouch.download'

import de.undercouch.gradle.tasks.download.Download
import org.apache.tools.ant.taskdefs.condition.Os
import org.apache.tools.ant.filters.ReplaceTokens

// We download various C++ open-source dependencies into downloads.
// We then copy both the downloaded code and our custom makefiles and headers into third-party-ndk.
// After that we build native code from src/main/jni with module path pointing at third-party-ndk.


ext.coreVersion = getDependenciesVersion("REALM_CORE_VERSION").trim()
ext.syncVersion = getDependenciesVersion("REALM_SYNC_VERSION").trim()
def currentVersion = getDependenciesVersion("VERSION").trim()
println "Realm Core Version: $ext.coreVersion"
println "Realm Sync Version: $ext.syncVersion"

def downloadsDir = new File("$projectDir/downloads")
def jscDownloadDir = new File("$projectDir/src/main/jni/jsc")
def coreDownloadDir = new File("$projectDir/src/main/jni")
def publishDir = new File("$projectDir/../../android/")
// to build with sync run: ./gradlew assembleDebug -PbuildWithSync=true
ext.buildSync = project.hasProperty('buildWithSync') ? project.getProperty('buildWithSync').toBoolean() : true

task generateVersionClass(type: Copy) {
    from 'src/main/templates/Version.java'
    into 'build/generated-src/main/java/io/realm/react'
    filter(ReplaceTokens, tokens: [version: currentVersion])
    outputs.upToDateWhen { false }
}

task createNativeDepsDirectories {
    downloadsDir.mkdirs()
}

task downloadJSCHeaders(type: Download) {
     def jscAPIBaseURL = 'https://svn.webkit.org/repository/webkit/!svn/bc/174650/trunk/Source/JavaScriptCore/API/'
     def jscHeaderFiles = ['JSBase.h', 'JSContextRef.h', 'JSObjectRef.h', 'JSRetainPtr.h', 'JSStringRef.h', 'JSValueRef.h', 'WebKitAvailability.h']

     def output = new File(jscDownloadDir, 'JavaScriptCore')
     output.mkdirs()
     src(jscHeaderFiles.collect { headerName -> "$jscAPIBaseURL$headerName" })
     onlyIfNewer true
     overwrite false
     dest output
 }

task downloadRealmCore(type: Download) {
    if (project.buildSync) {
        src "https://static.realm.io/downloads/sync/realm-sync-android-${project.syncVersion}.tar.gz"
    } else {
        src "https://static.realm.io/downloads/core/realm-core-android-${project.coreVersion}.tar.gz"
    }
    onlyIfNewer true
    overwrite true
    if (project.buildSync) {
        dest new File(downloadsDir, "realm-core-android-${project.syncVersion}.tar.gz")
    } else {
        dest new File(downloadsDir, "realm-core-android-${project.coreVersion}.tar.gz")
    }
}

task prepareRealmCore(dependsOn: downloadRealmCore, type:Copy) {
    from tarTree(downloadRealmCore.dest)
    into "$coreDownloadDir/core"
    rename { String fileName ->
        fileName.replace("-arm-", "-armeabi-")
    }
}

def getDependenciesVersion(keyName) {
    def inputFile = new File(buildscript.sourceFile.getParent() + "/../../dependencies.list")
    def line
    inputFile.withReader { reader ->
        while ((line = reader.readLine())!=null) {
            def (key, value) = line.tokenize('=')
            if (keyName == key) {
                return value
            }
        }

        throw new GradleException("${keyName} not found in dependencies.list.")
    }
}

def getNdkBuildName() {
    if (Os.isFamily(Os.FAMILY_WINDOWS)) {
        return "ndk-build.cmd"
    } else {
        return "ndk-build"
    }
}

def findNdkBuildFullPath() {
    // we allow to provide full path to ndk-build tool
    if (hasProperty('ndk.command')) {
        return property('ndk.command')
    }
    // or just a path to the containing directory
    if (hasProperty('ndk.path')) {
        def ndkDir = property('ndk.path')
        return new File(ndkDir, getNdkBuildName()).getAbsolutePath()
    }
    if (System.getenv('ANDROID_NDK') != null) {
        def ndkDir = System.getenv('ANDROID_NDK')
        return new File(ndkDir, getNdkBuildName()).getAbsolutePath()
    }
    def ndkDir = android.hasProperty('plugin') ? android.plugin.ndkFolder :
            plugins.getPlugin('com.android.library').sdkHandler.getNdkFolder()
    if (ndkDir) {
        return new File(ndkDir, getNdkBuildName()).getAbsolutePath()
    }
    return null
}

def checkNdkVersion(ndkBuildFullPath) {
    def ndkPath = new File(ndkBuildFullPath).getParent()
    def detectedNdkVersion
    def releaseFile = new File(ndkPath, 'RELEASE.TXT')
    def propertyFile = new File(ndkPath, 'source.properties')
    if (releaseFile.isFile()) {
        detectedNdkVersion = releaseFile.text.trim().split()[0].split('-')[0]
    } else if (propertyFile.isFile()) {
        detectedNdkVersion = getValueFromPropertiesFile(propertyFile, 'Pkg.Revision')
        if (detectedNdkVersion == null) {
            throw new GradleException("Failed to obtain the NDK version information from ${ndkPath}/source.properties")
        }
    } else {
        throw new GradleException("Neither ${releaseFile.getAbsolutePath()} nor ${propertyFile.getAbsolutePath()} is a file.")
    }
    if (detectedNdkVersion != project.ndkVersion) {
        throw new GradleException("Your NDK version: ${detectedNdkVersion}."
                + " Realm JNI must be compiled with the version ${project.ndkVersion} of NDK.")
    }
}

static def getValueFromPropertiesFile(File propFile, String key) {
    if (!propFile.isFile() || !propFile.canRead()) {
        return null
    }
    def prop = new Properties()
    def reader = propFile.newReader()
    try {
        prop.load(reader)
    } finally {
        reader.close()
    }
    return prop.get(key)
}

def getNdkBuildFullPath() {
    def ndkBuildFullPath = findNdkBuildFullPath()
    if (ndkBuildFullPath == null) {
        throw new GradleScriptException(
            "ndk-build binary cannot be found, check if you've set " +
            "\$ANDROID_NDK environment variable correctly or if ndk.dir is " +
            "setup in local.properties",
            null)
    }
    if (!new File(ndkBuildFullPath).canExecute()) {
        throw new GradleScriptException(
            "ndk-build binary " + ndkBuildFullPath + " doesn't exist or isn't executable.\n" +
            "Check that the \$ANDROID_NDK environment variable, or ndk.dir in local.proerties, is set correctly.\n" +
            "(On Windows, make sure you escape backslashes in local.properties or use forward slashes, e.g. C:\\\\ndk or C:/ndk rather than C:\\ndk)",
            null)
    }

    checkNdkVersion(ndkBuildFullPath);

    return ndkBuildFullPath
}

task buildReactNdkLib(dependsOn: [downloadJSCHeaders,prepareRealmCore], type: Exec) {
    inputs.file('src/main/jni')
    outputs.dir("$buildDir/realm-react-ndk/all")
    commandLine getNdkBuildFullPath(),
            '-e',
            project.buildSync ? 'BUILD_TYPE_SYNC=1' : 'BUILD_TYPE_SYNC=0',
            'NDK_PROJECT_PATH=null',
            "NDK_APPLICATION_MK=$projectDir/src/main/jni/Application.mk",
            'NDK_OUT=' + temporaryDir,
            "NDK_LIBS_OUT=$buildDir/realm-react-ndk/all",
            '-C', file('src/main/jni').absolutePath,
            'NDK_LOG=1',
            'NDK_DEBUG=' + (DEBUG_BUILD.toBoolean() ? '1' : '0'),
            '--jobs', Runtime.runtime.availableProcessors(),
            'V=1'
}

task cleanReactNdkLib(type: Exec) {
    commandLine getNdkBuildFullPath(),
            '-C', file('src/main/jni').absolutePath,
            'clean'
}

task packageReactNdkLibs(dependsOn: buildReactNdkLib, type: Copy) {
    from "$buildDir/realm-react-ndk/all"
    exclude '**/libjsc.so'
    exclude '**/gdbserver'
    exclude '**/gdb.setup'
    into "$buildDir/realm-react-ndk/exported"
}

android {
    compileSdkVersion 23
    buildToolsVersion "25.0.2"

    defaultConfig {
        minSdkVersion 16
        targetSdkVersion 23
    }

    sourceSets.main {
        java.srcDir "$buildDir/generated-src/main/java"
        jni.srcDirs = []
        jniLibs.srcDir "$buildDir/realm-react-ndk/exported"
        res.srcDirs = ['src/main/res/devsupport', 'src/main/res/shell']
    }

    tasks.withType(JavaCompile) {
        compileTask -> compileTask.dependsOn generateVersionClass, packageReactNdkLibs
    }

    clean.dependsOn cleanReactNdkLib

    lintOptions {
        abortOnError false
    }
}

task publishAndroid(dependsOn: [generateVersionClass, packageReactNdkLibs], type: Sync) {
    // Copy task can only have one top level
    into "$publishDir"

    // copy java source
    into ('/src/main') {
      from "$projectDir/src/main", "$buildDir/generated-src/main"
      exclude '**/jni/**', '**/templates/**'
    }

    // add compiled shared object
    into ('/src/main/jniLibs') {
        from "$buildDir/realm-react-ndk/exported/"
    }

    // copy gradle wrapper files
    FileTree gradleWrapper = fileTree(projectDir).include('gradlew*').include('gradle/**')
    into ('/') {
        from gradleWrapper
    }

    // copy and rename template build.gradle
    into ('/') {
      from "$projectDir/publish_android_template"
      rename { String fileName ->
          'build.gradle'
      }
    }

    // copy analytics script
    into ('/') {
      from "$projectDir/analytics_template"
      rename { String fileName ->
          'analytics.gradle'
      }
    }
}

// publishing into maven local

def configureRealmReactNativePom(def pom) {
    pom.project {
        name POM_NAME
        artifactId POM_ARTIFACT_ID
        packaging POM_PACKAGING
        description POM_DESCRIPTION
        url 'https://github.com/realm/realm-js'

        issueManagement {
            system 'github'
            url 'https://github.com/realm/realm-js/issues'
        }

        scm {
            url 'scm:https://github.com/realm/realm-js'
            connection 'scm:git@github.com:realm/realm-js.git'
            developerConnection 'scm:git@github.com:realm/realm-js.git'
        }

        licenses {
            license {
                name 'The Apache Software License, Version 2.0'
                url 'http://www.apache.org/licenses/LICENSE-2.0.txt'
                distribution 'repo'
            }
        }
    }
}

afterEvaluate { project ->
    task androidSourcesJar(type: Jar) {
        classifier = 'sources'
        from android.sourceSets.main.java.srcDirs
        include '**/*.java'
    }

    android.libraryVariants.all { variant ->
        def name = variant.name.capitalize()
        task "jar${name}"(type: Jar, dependsOn: variant.javaCompile) {
            from variant.javaCompile.destinationDir
        }
    }

    artifacts {
        archives androidSourcesJar
    }

    version = currentVersion
    group = GROUP

    signing {
        required { false }
        sign configurations.archives
    }

    task installArchives(type: Upload) {
        configuration = configurations.archives
        repositories.mavenDeployer {
            beforeDeployment {
                MavenDeployment deployment -> signing.signPom(deployment)
            }

            repository url: "file://${System.properties['user.home']}/.m2/repository"
            configureRealmReactNativePom pom
        }
    }
}

dependencies {
    compile fileTree(dir: 'libs', include: ['*.jar'])
    compile 'org.nanohttpd:nanohttpd:2.2.0'
    compile 'com.facebook.react:react-native:+'  // From node_modules
}