iceraven-browser/app/build.gradle

plugins {
    id "com.jetbrains.python.envs" version "0.0.26"
}

apply plugin: 'com.android.application'
apply plugin: 'kotlin-android'
apply plugin: 'kotlin-android-extensions'
apply plugin: 'jacoco'
apply plugin: 'androidx.navigation.safeargs.kotlin'
apply plugin: 'com.google.android.gms.oss-licenses-plugin'


import com.android.build.OutputFile
import groovy.json.JsonOutput
import org.gradle.internal.logging.text.StyledTextOutput.Style
import org.gradle.internal.logging.text.StyledTextOutputFactory

import static org.gradle.api.tasks.testing.TestResult.ResultType

android {
    compileSdkVersion Config.compileSdkVersion

    if (project.hasProperty("testBuildType")) {
        // Allowing to configure the test build type via command line flag (./gradlew -PtestBuildType=beta ..)
        // in order to run UI tests against other build variants than debug in automation.
        testBuildType project.property("testBuildType")
    }

    defaultConfig {
        applicationId "org.mozilla"
        minSdkVersion Config.minSdkVersion
        targetSdkVersion Config.targetSdkVersion
        versionCode 1
        versionName Config.generateDebugVersionName()
        vectorDrawables.useSupportLibrary = true
        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
        testInstrumentationRunnerArguments clearPackageData: 'true'
        resValue "bool", "IS_DEBUG", "false"
        buildConfigField "boolean", "USE_RELEASE_VERSIONING", "false"
        // This should be the "public" base URL of AMO.
        buildConfigField "String", "AMO_BASE_URL", "\"https://addons.mozilla.org\""
        buildConfigField "String", "AMO_COLLECTION_NAME", "\"7dfae8669acc4312a65e8ba5553036\""
        buildConfigField "String", "AMO_COLLECTION_USER", "\"mozilla\""
        // These add-ons should be excluded for Mozilla Online builds.
        buildConfigField "String[]", "MOZILLA_ONLINE_ADDON_EXCLUSIONS",
                "{" +
                        "\"uBlock0@raymondhill.net\"," +
                        "\"firefox@ghostery.com\"," +
                        "\"jid1-MnnxcxisBPnSXQ@jetpack\"," +
                        "\"adguardadblocker@adguard.com\"," +
                        "\"foxyproxy@eric.h.jung\"," +
                        "\"{73a6fe31-595d-460b-a920-fcc0f8843232}\"," +
                        "\"jid1-BoFifL9Vbdl2zQ@jetpack\"," +
                        "\"woop-NoopscooPsnSXQ@jetpack\"" +
                "}"
        // This should be the base URL used to call the AMO API.
        buildConfigField "String", "AMO_SERVER_URL", "\"https://services.addons.mozilla.org\""
        def deepLinkSchemeValue = "fenix-dev"
        buildConfigField "String", "DEEP_LINK_SCHEME", "\"$deepLinkSchemeValue\""
        manifestPlaceholders = [
                "deepLinkScheme": deepLinkSchemeValue,
                "requestLegacyExternalStorage": true
        ]

        // Build flag for "Mozilla Online" variants. See `Config.isMozillaOnline`.
        if (project.hasProperty("mozillaOnline") || gradle.hasProperty("localProperties.mozillaOnline")) {
            buildConfigField "boolean", "MOZILLA_ONLINE", "true"
        } else {
            buildConfigField "boolean", "MOZILLA_ONLINE", "false"
        }
    }

    def releaseTemplate = {
        // We allow disabling optimization by passing `-PdisableOptimization` to gradle. This is used
        // in automation for UI testing non-debug builds.
        shrinkResources !project.hasProperty("disableOptimization")
        minifyEnabled !project.hasProperty("disableOptimization")
        proguardFiles 'proguard-android-optimize-3.5.0-modified.txt', 'proguard-rules.pro'
        matchingFallbacks = ['release'] // Use on the "release" build type in dependencies (AARs)

        if (gradle.hasProperty("localProperties.autosignReleaseWithDebugKey")) {
            signingConfig signingConfigs.debug
        }

        if (gradle.hasProperty("localProperties.debuggable")) {
            debuggable true
        }
    }

    buildTypes {
        debug {
            shrinkResources false
            minifyEnabled false
            applicationIdSuffix ".fenix.debug"
            resValue "bool", "IS_DEBUG", "true"
            pseudoLocalesEnabled true
            def deepLinkSchemeValue = "fenix-dev"
            buildConfigField "String", "DEEP_LINK_SCHEME", "\"$deepLinkSchemeValue\""
            manifestPlaceholders = [
                    "deepLinkScheme": deepLinkSchemeValue,
                    "requestLegacyExternalStorage": false
            ]
        }
        nightly releaseTemplate >> {
            applicationIdSuffix ".fenix"
            buildConfigField "boolean", "USE_RELEASE_VERSIONING", "true"
            def deepLinkSchemeValue = "fenix-nightly"
            buildConfigField "String", "DEEP_LINK_SCHEME", "\"$deepLinkSchemeValue\""
            manifestPlaceholders = ["deepLinkScheme": deepLinkSchemeValue, "requestLegacyExternalStorage": false]
        }
        beta releaseTemplate >> {
            buildConfigField "boolean", "USE_RELEASE_VERSIONING", "true"
            applicationIdSuffix ".firefox_beta"
            def deepLinkSchemeValue = "fenix-beta"
            buildConfigField "String", "DEEP_LINK_SCHEME", "\"$deepLinkSchemeValue\""
            manifestPlaceholders = [
                    // This release type is meant to replace Firefox (Beta channel) and therefore needs to inherit
                    // its sharedUserId for all eternity. See:
                    // https://searchfox.org/mozilla-central/search?q=moz_android_shared_id&case=false&regexp=false&path=
                    // Shipping an app update without sharedUserId can have
                    // fatal consequences. For example see:
                    //  - https://issuetracker.google.com/issues/36924841
                    //  - https://issuetracker.google.com/issues/36905922
                    "sharedUserId": "org.mozilla.firefox.sharedID",
                    "deepLinkScheme": deepLinkSchemeValue,
                    "requestLegacyExternalStorage": true
            ]
        }
        release releaseTemplate >> {
            buildConfigField "boolean", "USE_RELEASE_VERSIONING", "true"
            applicationIdSuffix ".firefox"
            def deepLinkSchemeValue = "fenix"
            buildConfigField "String", "DEEP_LINK_SCHEME", "\"$deepLinkSchemeValue\""
            manifestPlaceholders = [
                    // This release type is meant to replace Firefox (Release channel) and therefore needs to inherit
                    // its sharedUserId for all eternity. See:
                    // https://searchfox.org/mozilla-central/search?q=moz_android_shared_id&case=false&regexp=false&path=
                    // Shipping an app update without sharedUserId can have
                    // fatal consequences. For example see:
                    //  - https://issuetracker.google.com/issues/36924841
                    //  - https://issuetracker.google.com/issues/36905922
                    "sharedUserId": "org.mozilla.firefox.sharedID",
                    "deepLinkScheme": deepLinkSchemeValue,
                    "requestLegacyExternalStorage": true
            ]
        }
    }

    aaptOptions {
        // All JavaScript code used internally by GeckoView is packaged in a
        // file called omni.ja. If this file is compressed in the APK,
        // GeckoView must uncompress it before it can do anything else which
        // causes a significant delay on startup.
        noCompress 'ja'

        // manifest.template.json is converted to manifest.json at build time.
        // No need to package the template in the APK.
        ignoreAssetsPattern "manifest.template.json"
    }

    testOptions {
        execution 'ANDROIDX_TEST_ORCHESTRATOR'
        unitTests.includeAndroidResources = true
        animationsDisabled = true
    }

    flavorDimensions "engine"

    sourceSets {
        androidTest {
            resources.srcDirs += ['src/androidTest/resources']
        }
        debug {
            java.srcDirs = ['src/geckoNightly/java']
        }
        nightly {
            java.srcDirs = ['src/geckoNightly/java']
        }
        beta {
            java.srcDirs = ['src/migration/java', 'src/geckoBeta/java']
            manifest.srcFile "src/migration/AndroidManifest.xml"
        }
        release {
            java.srcDirs = ['src/migration/java', 'src/geckoRelease/java']
            manifest.srcFile "src/migration/AndroidManifest.xml"
        }
    }

    splits {
        abi {
            enable true

            reset()

            include "x86", "armeabi-v7a", "arm64-v8a", "x86_64"
        }
    }

    compileOptions {
        sourceCompatibility JavaVersion.VERSION_1_8
        targetCompatibility JavaVersion.VERSION_1_8
    }

    lintOptions {
        lintConfig file("lint.xml")
        baseline file("lint-baseline.xml")
    }

    packagingOptions {
        exclude 'META-INF/atomicfu.kotlin_module'
    }

    testOptions {
        unitTests.returnDefaultValues = true

        unitTests.all {
            // We keep running into memory issues when running our tests. With this config we
            // reserve more memory and also create a new process after every 80 test classes. This
            // is a band-aid solution and eventually we should try to find and fix the leaks
            // instead. :)
            maxParallelForks = 2
            forkEvery = 80
            maxHeapSize = "2048m"
            minHeapSize = "1024m"
        }
    }
}

android.applicationVariants.all { variant ->

// -------------------------------------------------------------------------------------------------
// Set up kotlin-allopen plugin for writing tests
// -------------------------------------------------------------------------------------------------

    boolean hasTest = gradle.startParameter.taskNames.find { it.contains("test") || it.contains("Test") } != null
    if (hasTest) {
        apply plugin: 'kotlin-allopen'
        allOpen {
            annotation("org.mozilla.fenix.utils.OpenClass")
        }
    }

// -------------------------------------------------------------------------------------------------
// Generate version codes for builds
// -------------------------------------------------------------------------------------------------

    def isDebug = variant.buildType.resValues['IS_DEBUG']?.value ?: false
    def useReleaseVersioning = variant.buildType.buildConfigFields['USE_RELEASE_VERSIONING']?.value ?: false
    def versionName = Config.releaseVersionName(project)

    println("----------------------------------------------")
    println("Variant name:      " + variant.name)
    println("Application ID:    " + [variant.mergedFlavor.applicationId, variant.buildType.applicationIdSuffix].findAll().join())
    println("Build type:        " + variant.buildType.name)
    println("Flavor:            " + variant.flavorName)
    println("Telemetry enabled: " + !isDebug)

    if (useReleaseVersioning) {
        // 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.

        variant.outputs.each { output ->
            def abi = output.getFilter(OutputFile.ABI)
            // We use the same version code generator, that we inherited from Fennec, across all channels - even on
            // channels that never shipped a Fennec build.
            def versionCodeOverride = Config.generateFennecVersionCode(abi)

            println("versionCode for $abi = $versionCodeOverride")

            output.versionNameOverride = versionName
            output.versionCodeOverride = versionCodeOverride
        }
    }

// -------------------------------------------------------------------------------------------------
// BuildConfig: Set variables for Sentry, Crash Reporting, and Telemetry
// -------------------------------------------------------------------------------------------------

    buildConfigField 'String', 'SENTRY_TOKEN', 'null'
    if (!isDebug) {
        buildConfigField 'boolean', 'CRASH_REPORTING', 'true'
        // Reading sentry token from local file (if it exists). In a release task on taskcluster it will be available.
        try {
            def token = new File("${rootDir}/.sentry_token").text.trim()
            buildConfigField 'String', 'SENTRY_TOKEN', '"' + token + '"'
        } catch (FileNotFoundException ignored) {}
    } else {
        buildConfigField 'boolean', 'CRASH_REPORTING', 'false'
    }

    if (!isDebug) {
        buildConfigField 'boolean', 'TELEMETRY', 'true'
    } else {
        buildConfigField 'boolean', 'TELEMETRY', 'false'
    }

    def buildDate = Config.generateBuildDate()
    // Setting buildDate with every build changes the generated BuildConfig, which slows down the
    // build. Only do this for non-debug builds, to speed-up builds produced during local development.
    if (isDebug) {
        buildConfigField 'String', 'BUILD_DATE', '"debug build"'
    } else {
        buildConfigField 'String', 'BUILD_DATE', '"' + buildDate + '"'
    }

// -------------------------------------------------------------------------------------------------
// Adjust: Read token from local file if it exists (Only release builds)
// -------------------------------------------------------------------------------------------------

    print("Adjust token: ")

    if (!isDebug) {
        try {
            def token = new File("${rootDir}/.adjust_token").text.trim()
            buildConfigField 'String', 'ADJUST_TOKEN', '"' + token + '"'
            println "(Added from .adjust_token file)"
        } catch (FileNotFoundException ignored) {
            buildConfigField 'String', 'ADJUST_TOKEN', 'null'
            println("X_X")
        }
    } else {
        buildConfigField 'String', 'ADJUST_TOKEN', 'null'
        println("--")
    }

// -------------------------------------------------------------------------------------------------
// Leanplum: Read token from local file if it exists
// -------------------------------------------------------------------------------------------------

    print("Leanplum token: ")

    try {
        def parts = new File("${rootDir}/.leanplum_token").text.trim().split(":")
        def id = parts[0]
        def key = parts[1]
        buildConfigField 'String', 'LEANPLUM_ID', '"' + id + '"'
        buildConfigField 'String', 'LEANPLUM_TOKEN', '"' + key + '"'
        println "(Added from .leanplum_token file)"
    } catch (FileNotFoundException ignored) {
        buildConfigField 'String', 'LEANPLUM_ID', 'null'
        buildConfigField 'String', 'LEANPLUM_TOKEN', 'null'
        println("X_X")
    }

// -------------------------------------------------------------------------------------------------
// MLS: Read token from local file if it exists
// -------------------------------------------------------------------------------------------------

    print("MLS token: ")

    try {
        def token = new File("${rootDir}/.mls_token").text.trim()
        buildConfigField 'String', 'MLS_TOKEN', '"' + token + '"'
        println "(Added from .mls_token file)"
    } catch (FileNotFoundException ignored) {
        buildConfigField 'String', 'MLS_TOKEN', '""'
        println("X_X")
    }

// -------------------------------------------------------------------------------------------------
// Nimbus: Read endpoint from local.properties of a local file if it exists
// -------------------------------------------------------------------------------------------------

    print("Nimbus endpoint: ")

    if (!isDebug) {
        try {
            def url = new File("${rootDir}/.nimbus").text.trim()
            buildConfigField 'String', 'NIMBUS_ENDPOINT', '"' + url + '"'
            println "(Added from .nimbus file)"
        } catch (FileNotFoundException ignored) {
            buildConfigField 'String', 'NIMBUS_ENDPOINT', 'null'
            println("X_X")
        }
    } else if (gradle.hasProperty("localProperties.nimbus.remote-settings.url")) {
        def url=gradle.getProperty("localProperties.nimbus.remote-settings.url")
        buildConfigField 'String', 'NIMBUS_ENDPOINT', '"' + url + '"'
        println "(Added from local.properties file)"
    } else {
        buildConfigField 'String', 'NIMBUS_ENDPOINT', 'null'
        println("--")
    }

// -------------------------------------------------------------------------------------------------
// BuildConfig: Set flag for official builds; similar to MOZILLA_OFFICIAL in mozilla-central.
// -------------------------------------------------------------------------------------------------

    if (project.hasProperty("official") || gradle.hasProperty("localProperties.official")) {
        buildConfigField 'Boolean', 'MOZILLA_OFFICIAL', 'true'
    } else {
        buildConfigField 'Boolean', 'MOZILLA_OFFICIAL', 'false'
    }
}

androidExtensions {
    experimental = true
}

// Generate Kotlin code and markdown docs for the Fenix Glean metrics.
ext.gleanGenerateMarkdownDocs = true
ext.gleanDocsDirectory = "$rootDir/docs"
apply plugin: "org.mozilla.telemetry.glean-gradle-plugin"

configurations {
    // There's an interaction between Gradle's resolution of dependencies with different types
    // (@jar, @aar) for `implementation` and `testImplementation` and with Android Studio's built-in
    // JUnit test runner.  The runtime classpath in the built-in JUnit test runner gets the
    // dependency from the `implementation`, which is type @aar, and therefore the JNA dependency
    // doesn't provide the JNI dispatch libraries in the correct Java resource directories.  I think
    // what's happening is that @aar type in `implementation` resolves to the @jar type in
    // `testImplementation`, and that it wins the dependency resolution battle.
    //
    // A workaround is to add a new configuration which depends on the @jar type and to reference
    // the underlying JAR file directly in `testImplementation`.  This JAR file doesn't resolve to
    // the @aar type in `implementation`.  This works when invoked via `gradle`, but also sets the
    // correct runtime classpath when invoked with Android Studio's built-in JUnit test runner.
    // Success!
    jnaForTest
    // Robolectric, through `com.google.android.apps.common.testing.accessibility.framework`
    // depends on an old version of protobuf that conflict with the Application Services one.
    // See: https://github.com/mozilla/application-services/issues/2952
    all*.exclude group: 'com.google.protobuf', module: 'protobuf-java'
}

dependencies {
    jnaForTest Deps.jna
    testImplementation files(configurations.jnaForTest.copyRecursive().files)

    debugImplementation Deps.mozilla_browser_engine_gecko_nightly

    nightlyImplementation Deps.mozilla_browser_engine_gecko_nightly
    betaImplementation Deps.mozilla_browser_engine_gecko_beta
    releaseImplementation Deps.mozilla_browser_engine_gecko_release

    implementation Deps.kotlin_stdlib
    implementation Deps.kotlin_coroutines
    implementation Deps.kotlin_coroutines_android
    testImplementation Deps.kotlin_coroutines_test
    implementation Deps.androidx_appcompat
    implementation Deps.androidx_constraintlayout
    implementation Deps.androidx_coordinatorlayout

    implementation Deps.sentry

    implementation Deps.leanplum_core
    implementation Deps.leanplum_fcm

    implementation Deps.mozilla_concept_base
    implementation Deps.mozilla_concept_engine
    implementation Deps.mozilla_concept_menu
    implementation Deps.mozilla_concept_push
    implementation Deps.mozilla_concept_storage
    implementation Deps.mozilla_concept_sync
    implementation Deps.mozilla_concept_toolbar
    implementation Deps.mozilla_concept_tabstray

    implementation Deps.mozilla_browser_awesomebar
    implementation Deps.mozilla_feature_downloads
    implementation Deps.mozilla_browser_domains
    implementation Deps.mozilla_browser_icons
    implementation Deps.mozilla_browser_menu
    implementation Deps.mozilla_browser_menu2
    implementation Deps.mozilla_browser_search
    implementation Deps.mozilla_browser_session
    implementation Deps.mozilla_browser_session_storage
    implementation Deps.mozilla_browser_state
    implementation Deps.mozilla_browser_storage_sync
    implementation Deps.mozilla_browser_tabstray
    implementation Deps.mozilla_browser_thumbnails
    implementation Deps.mozilla_browser_toolbar

    implementation Deps.mozilla_support_extensions
    implementation Deps.mozilla_feature_addons

    implementation Deps.mozilla_feature_accounts
    implementation Deps.mozilla_feature_app_links
    implementation Deps.mozilla_feature_autofill
    implementation Deps.mozilla_feature_awesomebar
    implementation Deps.mozilla_feature_contextmenu
    implementation Deps.mozilla_feature_customtabs
    implementation Deps.mozilla_feature_downloads
    implementation Deps.mozilla_feature_intent
    implementation Deps.mozilla_feature_media
    implementation Deps.mozilla_feature_prompts
    implementation Deps.mozilla_feature_push
    implementation Deps.mozilla_feature_privatemode
    implementation Deps.mozilla_feature_pwa
    implementation Deps.mozilla_feature_qr
    implementation Deps.mozilla_feature_search
    implementation Deps.mozilla_feature_session
    implementation Deps.mozilla_feature_syncedtabs
    implementation Deps.mozilla_feature_toolbar
    implementation Deps.mozilla_feature_tabs
    implementation Deps.mozilla_feature_findinpage
    implementation Deps.mozilla_feature_logins
    implementation Deps.mozilla_feature_site_permissions
    implementation Deps.mozilla_feature_readerview
    implementation Deps.mozilla_feature_tab_collections
    implementation Deps.mozilla_feature_recentlyclosed
    implementation Deps.mozilla_feature_top_sites
    implementation Deps.mozilla_feature_share
    implementation Deps.mozilla_feature_accounts_push
    implementation Deps.mozilla_feature_webauthn
    implementation Deps.mozilla_feature_webcompat
    implementation Deps.mozilla_feature_webnotifications
    implementation Deps.mozilla_feature_webcompat_reporter

    implementation Deps.mozilla_service_digitalassetlinks
    implementation Deps.mozilla_service_sync_autofill
    implementation Deps.mozilla_service_sync_logins
    implementation Deps.mozilla_service_firefox_accounts
    implementation Deps.mozilla_service_glean
    implementation Deps.mozilla_service_location
    implementation Deps.mozilla_service_nimbus

    implementation Deps.mozilla_support_base
    implementation Deps.mozilla_support_images
    implementation Deps.mozilla_support_ktx
    implementation Deps.mozilla_support_rustlog
    implementation Deps.mozilla_support_utils
    implementation Deps.mozilla_support_locale

    implementation Deps.mozilla_support_migration

    implementation Deps.mozilla_ui_colors
    implementation Deps.mozilla_ui_icons
    implementation Deps.mozilla_lib_publicsuffixlist
    implementation Deps.mozilla_ui_widgets
    implementation Deps.mozilla_ui_tabcounter

    implementation Deps.mozilla_lib_crash
    implementation Deps.mozilla_lib_push_firebase
    implementation Deps.mozilla_lib_dataprotect
    debugImplementation Deps.leakcanary

    implementation Deps.androidx_legacy
    implementation Deps.androidx_biometric
    implementation Deps.androidx_paging
    implementation Deps.androidx_preference
    implementation Deps.androidx_fragment
    implementation Deps.androidx_navigation_fragment
    implementation Deps.androidx_navigation_ui
    implementation Deps.androidx_recyclerview
    implementation Deps.androidx_lifecycle_livedata
    implementation Deps.androidx_lifecycle_runtime
    implementation Deps.androidx_lifecycle_viewmodel
    implementation Deps.androidx_core
    implementation Deps.androidx_core_ktx
    implementation Deps.androidx_transition
    implementation Deps.androidx_work_ktx
    implementation Deps.google_material

    implementation Deps.adjust
    implementation Deps.installreferrer // Required by Adjust

    implementation Deps.google_ads_id // Required for the Google Advertising ID

    implementation Deps.google_play_store // Required for in-app reviews

    androidTestImplementation Deps.uiautomator
// Removed pending AndroidX fixes
    androidTestImplementation "tools.fastlane:screengrab:2.0.0"
//    androidTestImplementation "br.com.concretesolutions:kappuccino:1.2.1"

    androidTestImplementation Deps.espresso_core, {
        exclude group: 'com.android.support', module: 'support-annotations'
    }

    androidTestImplementation(Deps.espresso_contrib) {
        exclude module: 'appcompat-v7'
        exclude module: 'support-v4'
        exclude module: 'support-annotations'
        exclude module: 'recyclerview-v7'
        exclude module: 'design'
        exclude module: 'espresso-core'
    }

    androidTestImplementation Deps.androidx_test_core
    androidTestImplementation Deps.espresso_idling_resources
    androidTestImplementation Deps.espresso_intents

    androidTestImplementation Deps.tools_test_runner
    androidTestImplementation Deps.tools_test_rules
    androidTestUtil Deps.orchestrator
    androidTestImplementation Deps.espresso_core, {
        exclude group: 'com.android.support', module: 'support-annotations'
    }

    androidTestImplementation Deps.androidx_junit
    androidTestImplementation Deps.androidx_work_testing
    androidTestImplementation Deps.mockwebserver
    testImplementation Deps.mozilla_support_test
    testImplementation Deps.mozilla_support_test_libstate
    testImplementation Deps.androidx_junit
    testImplementation Deps.androidx_work_testing
    testImplementation (Deps.robolectric) {
        exclude group: 'org.apache.maven'
    }

    testImplementation 'org.apache.maven:maven-ant-tasks:2.1.3'
    implementation Deps.mozilla_support_rusthttp

    testImplementation Deps.mockk

    // For the initial release of Glean 19, we require consumer applications to
    // depend on a separate library for unit tests. This will be removed in future releases.
    testImplementation "org.mozilla.telemetry:glean-forUnitTests:${project.ext.glean_version}"

    lintChecks project(":mozilla-lint-rules")
}

if (project.hasProperty("coverage")) {
    tasks.withType(Test).configureEach {
        jacoco.includeNoLocationClasses = true
    }

    android.applicationVariants.all { variant ->
        tasks.register("jacoco${variant.name.capitalize()}TestReport", JacocoReport) {
            dependsOn "test${variant.name.capitalize()}UnitTest"

            reports {
                xml.enabled = true
                html.enabled = true
            }

            def fileFilter = ['**/R.class', '**/R$*.class', '**/BuildConfig.*', '**/Manifest*.*',
                              '**/*Test*.*', 'android/**/*.*', '**/*$[0-9].*']
            def kotlinDebugTree = fileTree(dir: "$project.buildDir/tmp/kotlin-classes/${variant.name}", excludes: fileFilter)
            def javaDebugTree = fileTree(dir: "$project.buildDir/intermediates/classes/${variant.flavorName}/${variant.buildType.name}",
                    excludes: fileFilter)
            def mainSrc = "$project.projectDir/src/main/java"

            sourceDirectories.setFrom(files([mainSrc]))
            classDirectories.setFrom(files([kotlinDebugTree, javaDebugTree]))
            executionData.setFrom(fileTree(dir: project.buildDir, includes: [
                "jacoco/test${variant.name.capitalize()}UnitTest.exec",
                'outputs/code-coverage/connected/*coverage.ec'
            ]))
        }
    }

    android {
        buildTypes {
            debug {
                testCoverageEnabled true
            }
        }
    }
}

// -------------------------------------------------------------------------------------------------
// Task for printing APK information for the requested variant
// Usage: "./gradlew printVariants
// -------------------------------------------------------------------------------------------------
tasks.register('printVariants') {
    doLast {
        def variants = android.applicationVariants.collect { variant -> [
            apks: variant.outputs.collect { output -> [
                abi: output.getFilter(com.android.build.VariantOutput.FilterType.ABI),
                fileName: output.outputFile.name
            ]},
            build_type: variant.buildType.name,
            name: variant.name,
        ]}
        // AndroidTest is a special case not included above
        variants.add([
            apks: [[
                abi: 'noarch',
                fileName: 'app-debug-androidTest.apk',
            ]],
            build_type: 'androidTest',
            name: 'androidTest',
        ])
        println 'variants: ' + JsonOutput.toJson(variants)
    }
}

task buildTranslationArray {
    // This isn't running as a task, instead the array is build when the gradle file is parsed.
    // https://github.com/mozilla-mobile/fenix/issues/14175
    def foundLocales = new StringBuilder()
    foundLocales.append("new String[]{")

    fileTree("src/main/res").visit { FileVisitDetails details ->
        if(details.file.path.endsWith("${File.separator}strings.xml")){
            def languageCode = details.file.parent.tokenize(File.separator).last().replaceAll('values-','').replaceAll('-r','-')
            languageCode = (languageCode == "values") ? "en-US" : languageCode
            foundLocales.append("\"").append(languageCode).append("\"").append(",")
        }
    }

    foundLocales.append("}")
    def foundLocalesString = foundLocales.toString().replaceAll(',}','}')
    android.defaultConfig.buildConfigField "String[]", "SUPPORTED_LOCALE_ARRAY", foundLocalesString
}

afterEvaluate {

    // Format test output. Ported from AC #2401
    tasks.withType(Test).configureEach {
        systemProperty "robolectric.logging", "stdout"
        systemProperty "logging.test-mode", "true"

        testLogging.events = []

        def out = services.get(StyledTextOutputFactory).create("tests")

        beforeSuite { descriptor ->
            if (descriptor.getClassName() != null) {
                out.style(Style.Header).println("\nSUITE: " + descriptor.getClassName())
            }
        }

        beforeTest { descriptor ->
            out.style(Style.Description).println("  TEST: " + descriptor.getName())
        }

        onOutput { descriptor, event ->
            logger.lifecycle("    " + event.message.trim())
        }

        afterTest { descriptor, result ->
            switch (result.getResultType()) {
                case ResultType.SUCCESS:
                    out.style(Style.Success).println("  SUCCESS")
                    break

                case ResultType.FAILURE:
                    out.style(Style.Failure).println("  FAILURE")
                    logger.lifecycle("", result.getException())
                    break

                case ResultType.SKIPPED:
                    out.style(Style.Info).println("  SKIPPED")
                    break
            }
            logger.lifecycle("")
        }
    }
}

if (gradle.hasProperty('localProperties.dependencySubstitutions.geckoviewTopsrcdir')) {
    if (gradle.hasProperty('localProperties.dependencySubstitutions.geckoviewTopobjdir')) {
        ext.topobjdir = gradle."localProperties.dependencySubstitutions.geckoviewTopobjdir"
    }
    ext.topsrcdir = gradle."localProperties.dependencySubstitutions.geckoviewTopsrcdir"
    apply from: "${topsrcdir}/substitute-local-geckoview.gradle"
}

if (gradle.hasProperty('localProperties.autoPublish.android-components.dir')) {
    ext.acSrcDir = gradle."localProperties.autoPublish.android-components.dir"
    apply from: "../${acSrcDir}/substitute-local-ac.gradle"
}

if (gradle.hasProperty('localProperties.autoPublish.application-services.dir')) {
    ext.appServicesSrcDir = gradle."localProperties.autoPublish.application-services.dir"
    apply from: "../${appServicesSrcDir}/build-scripts/substitute-local-appservices.gradle"
}

// Define a reusable task for updating the versions of our built-in web extensions. We automate this
// to make sure we never forget to update the version, either in local development or for releases.
// In both cases, we want to make sure the latest version of all extensions (including their latest
// changes) are installed on first start-up.
// We're using the A-C version here as we want to uplift all built-in extensions to A-C (Once that's
// done we can also remove the task below):
// https://github.com/mozilla-mobile/android-components/issues/7249
ext.updateExtensionVersion = { task, extDir ->
    configure(task) {
        from extDir
        include 'manifest.template.json'
        rename { 'manifest.json' }
        into extDir

        def values = ['version': AndroidComponents.VERSION + "." + new Date().format('MMddHHmmss')]
        inputs.properties(values)
        expand(values)
    }
}

tasks.register("updateAdsExtensionVersion", Copy) { task ->
    updateExtensionVersion(task, 'src/main/assets/extensions/ads')
}

tasks.register("updateCookiesExtensionVersion", Copy) { task ->
    updateExtensionVersion(task, 'src/main/assets/extensions/cookies')
}

preBuild.dependsOn "updateAdsExtensionVersion"
preBuild.dependsOn "updateCookiesExtensionVersion"