build.gradle

apply plugin: 'com.android.application'
apply from: "$project.rootDir/tools/gradle/versionCode.gradle"

def getGitHash = { ->
    def stdout = new ByteArrayOutputStream()
    exec {
        commandLine 'git', 'rev-parse', '--short', 'HEAD'
        standardOutput = stdout
    }
    return stdout.toString().trim()
}

def getCrashRestartDisabled = { ->
    if (gradle.hasProperty("disableCrashRestart")) {
        return gradle.disableCrashRestart
    }
    return "false"
}

def getDevApplicationIdSufix = { ->
    if (gradle.hasProperty("simultaneousDevProduction")) {
        return gradle.simultaneousDevProduction == "true" ? ".dev" : ""
    }
    return ""
}

def getUseDebugSigningOnRelease = { ->
    if (gradle.hasProperty("useDebugSigningOnRelease")) {
        return gradle.useDebugSigningOnRelease == "true"
    }
    return false
}

android {
    compileSdkVersion build_versions.target_sdk
    defaultConfig {
        applicationId "org.mozilla.vrbrowser"
        minSdkVersion build_versions.min_sdk
        targetSdkVersion build_versions.target_sdk
        versionCode 1
        versionName "1.1.4"
        buildConfigField "String", "GIT_HASH", "\"${getGitHash()}\""
        buildConfigField "Boolean", "DISABLE_CRASH_RESTART", getCrashRestartDisabled()
        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
        externalNativeBuild {
            cmake {
                cppFlags "-std=c++14 -fexceptions -frtti -Werror" +
                         " -I" + file("src/main/cpp").absolutePath +
                         " -I" + file("src/main/cpp/vrb/include").absolutePath
                arguments "-DANDROID_STL=c++_shared"
            }
        }

        javaCompileOptions {
            annotationProcessorOptions {
                arguments = ["room.schemaLocation": "$projectDir/schemas".toString()]
            }
        }
    }

    if (gradle.hasProperty('taskclusterBuild')) {
        project.archivesBaseName = "FirefoxReality-$defaultConfig.versionName-$generatedVersionCode"
        defaultConfig.versionCode = generatedVersionCode
    } else {
        project.archivesBaseName = "FirefoxReality"
    }

    compileOptions {
        sourceCompatibility JavaVersion.VERSION_1_8
        targetCompatibility JavaVersion.VERSION_1_8
    }

    buildTypes {
        release {
            minifyEnabled true
            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
            signingConfig getUseDebugSigningOnRelease() ? debug.signingConfig : release.signingConfig
        }
        debug {
            applicationIdSuffix getDevApplicationIdSufix()
            pseudoLocalesEnabled true
        }
    }

    externalNativeBuild {
        cmake {
            path "CMakeLists.txt"
        }
    }

    dataBinding {
        enabled = true
    }

    lintOptions {
        disable "LogUsage", "ExtraTranslation"
    }

    packagingOptions {
        pickFirst '/lib/*/libgvr.so'
    }

    flavorDimensions "platform", "abi"

    productFlavors {
        // Supported platforms
        googlevr {
            dimension "platform"
            externalNativeBuild {
                cmake {
                    cppFlags " -I" + file("${project.rootDir}/gvr-android-sdk/libraries/headers").absolutePath +
                            " -DVRBROWSER_GOOGLEVR"
                    arguments "-DVR_SDK_LIB=googlevr-lib", "-DGOOGLEVR=ON"
                }
            }
        }

        oculusvr {
            dimension "platform"
            externalNativeBuild {
                cmake {
                    cppFlags " -I" + file("${project.rootDir}/third_party/ovr_mobile/VrApi/Include").absolutePath +
                            " -I" + file("${project.rootDir}/app/src/oculusvr/cpp").absolutePath +
                            " -DOCULUSVR"
                    arguments "-DVR_SDK_LIB=oculusvr-lib", "-DOCULUSVR=ON"
                }
            }
        }
        svr {
            dimension "platform"
            externalNativeBuild {
                cmake {
                    cppFlags " -I" + file("${project.rootDir}/third_party/svr/public").absolutePath +
                            " -I" + file("${project.rootDir}/app/src/svr/cpp").absolutePath +
                            " -DSNAPDRAGONVR"
                    arguments "-DVR_SDK_LIB=svr-lib", "-DSNAPDRAGONVR=ON"
                }
            }
        }
        wavevr {
            dimension "platform"
            externalNativeBuild {
                cmake {
                    cppFlags " -I" + file("${project.rootDir}/third_party/wavesdk/build/wvr_client/include").absolutePath
                    arguments "-DVR_SDK_LIB=wavevr-lib", "-DWAVEVR=ON"
                }
            }
        }
        noapi {
            dimension "platform"
            externalNativeBuild {
                cmake {
                    cppFlags " -DVRBROWSER_NO_VR_API"
                    arguments "-DNOAPI=ON"
                }
            }
        }

        // Supported ABIs
        arm {
            dimension "abi"
            ndk {
                abiFilters "armeabi-v7a"
            }
        }

        arm64 {
            dimension "abi"
            ndk {
                abiFilters "arm64-v8a"
            }
        }

        x86 {
            dimension "abi"
            ndk {
                abiFilters "x86"
            }
        }
    }

    variantFilter { variant ->
        def needed = variant.name in [
                'googlevrArmDebug',
                'googlevrArmRelease',
                'googlevrArm64Debug',
                'googlevrArm64Release',
                'oculusvrArmDebug',
                'oculusvrArmRelease',
                'oculusvrArm64Debug',
                'oculusvrArm64Release',
                'svrArmDebug',
                'svrArmRelease',
                'svrArm64Debug',
                'svrArm64Release',
                'wavevrArmDebug',
                'wavevrArmRelease',
                'noapiArmDebug',
                'noapiArmRelease',
                'noapiArm64Debug',
                'noapiArm64Release',
                'noapiX86Debug',
                'noapiX86Release'
        ]
        variant.setIgnore(!needed)
    }


    sourceSets {
        main {
            java.srcDirs = [
                    'app',
                    'src/common/shared',
                    'src/main/cpp/vrb/android/java'
            ]
        }

        release {
            manifest.srcFile getUseDebugSigningOnRelease() ? "src/debug/AndroidManifest.xml"
                                                           : manifest.srcFile

        }

        googlevr {
            java.srcDirs = [
                    'src/googlevr/java'
            ]
        }

        oculusvr {
            java.srcDirs = [
                    'src/oculusvr/java'
            ]
        }

        oculusvrArmRelease {
            manifest.srcFile getUseDebugSigningOnRelease() ? "src/oculusvrArmDebug/AndroidManifest.xml"
                                                           :  manifest.srcFile
        }

        oculusvrArm64Debug {
            manifest.srcFile "src/oculusvrArmDebug/AndroidManifest.xml"
        }

        oculusvrArm64Release {
            manifest.srcFile getUseDebugSigningOnRelease() ? "src/oculusvrArmDebug/AndroidManifest.xml"
                                                           : "src/oculusvrArmRelease/AndroidManifest.xml"
        }

        svr {
            java.srcDirs = [
                    'src/svr/java'
            ]
            jniLibs.srcDirs = ["${project.rootDir}/third_party/svr/libs"]
        }

        wavevr {
            java.srcDirs = [
                    'src/wavevr/java'
            ]
            res.srcDirs = [
                    'src/wavevr/res'
            ]
            jniLibs.srcDirs = ["${project.rootDir}/third_party/wavesdk/build/wvr_client/jni"]
        }
        noapi {
            java.srcDirs = [
                    'src/noapi/java'
            ]
        }
    }
}

configurations {
    armImplementation
    x86Implementation
}

dependencies {
    implementation fileTree(include: ['*.jar'], dir: 'libs')

    // Common
    // implementation deps.google_vr.sdk_audio
    implementation deps.room.runtime
    annotationProcessor deps.room.compiler
    implementation deps.lifecycle.runtime
    implementation deps.lifecycle.extensions
    implementation deps.support.cardview
    implementation deps.support.app_compat
    implementation deps.support.annotations
    implementation deps.constraint_layout

    // Android Components
    implementation deps.mozilla_speech
    implementation deps.android_components.telemetry
    implementation deps.android_components.browser_errorpages
    implementation deps.android_components.browser_search
    implementation deps.android_components.browser_domains
    implementation deps.android_components.ui_autocomplete

    // SQLite helper to handle DBs from assets
    implementation deps.sqlite.sqlite

    // Testing
    testImplementation deps.junit
    androidTestImplementation deps.atsl.runner
    androidTestImplementation deps.espresso.core
    testImplementation deps.room.testing

    // Daydream
    googlevrImplementation deps.google_vr.sdk_base

    // ODG
    svrImplementation fileTree(dir: "${project.rootDir}/third_party/svr/", include: ['*.jar'])
}

if (findProject(':servo')) {
    dependencies {
      oculusvrImplementation project(':servo')
      googlevrImplementation project(':servo')
    }
}

if (findProject(':wavesdk')) {
    dependencies {
        wavevrImplementation project(':wavesdk')
    }
}

if (findProject(':geckoview-local')) {
    dependencies {
        implementation project(':geckoview-local')
        implementation deps.snakeyaml
    }
} else {
    dependencies {
        // To see what the latest geckoview-nightly version is go here:
        // https://maven.mozilla.org/?prefix=maven2/org/mozilla/geckoview/geckoview-nightly-armeabi-v7a/
        armImplementation deps.gecko_view.nightly_armv7a
        arm64Implementation deps.gecko_view.nightly_arm64
        x86Implementation deps.gecko_view.nightly_x86
    }
}


// -------------------------------------------------------------------------------------------------
//  Dynamically set versionCode (See tools/build/versionCode.gradle
// -------------------------------------------------------------------------------------------------

android.applicationVariants.all { variant ->
    def buildType = variant.buildType.name
    if (gradle.hasProperty('taskclusterBuild')) {
        def versionCode = generatedVersionCode

        // The Google Play Store does not allow multiple APKs for the same app that all have the
        // same version code. Therefore we need to have different version codes for our ARM and x86
        // builds.
        // Our generated version code has a length of 8 (See tools/gradle/versionCode.gradle).
        // We will prefix our ARM builds with 1 and our x86 builds with 2. Our x86 builds need a
        // higher version code to avoid installing ARM builds on an x86 device with ARM
        // compatibility mode.
        def multiplier = 100000000

        // Currently only support arm7
        if (variant.flavorName.contains("X86")) {
            versionCode = versionCode + (3 * multiplier)
        } else if (variant.flavorName.contains("Aarch64")) {
            versionCode = versionCode + (2 * multiplier)
        } else if (variant.flavorName.contains("Arm")) {
            versionCode = versionCode + (1 * multiplier)
        }

        variant.outputs.each { output ->
            output.versionCodeOverride = versionCode
        }
    }

    println("----------------------------------------------")
    println("Build type:   " + buildType)
    println("Flavor:       " + variant.flavorName)
    println("Version code: " + variant.mergedFlavor.versionCode)
}