зеркало из https://github.com/mozilla/gecko-dev.git
565 строки
25 KiB
Groovy
565 строки
25 KiB
Groovy
buildDir "${topobjdir}/gradle/build/mobile/android/app"
|
|
|
|
apply plugin: 'com.android.application'
|
|
apply plugin: 'checkstyle'
|
|
apply plugin: 'findbugs'
|
|
|
|
if (mozconfig.substs.MOZILLA_OFFICIAL) {
|
|
apply plugin: 'com.getkeepsafe.dexcount'
|
|
}
|
|
|
|
apply from: "${topsrcdir}/mobile/android/gradle/product_flavors.gradle"
|
|
|
|
if (mozconfig.substs.MOZILLA_OFFICIAL) {
|
|
dexcount {
|
|
format = "tree"
|
|
}
|
|
}
|
|
|
|
android {
|
|
compileSdkVersion project.ext.compileSdkVersion
|
|
|
|
useLibrary 'android.test.runner'
|
|
useLibrary 'android.test.base'
|
|
useLibrary 'android.test.mock'
|
|
|
|
defaultConfig {
|
|
targetSdkVersion project.ext.targetSdkVersion
|
|
minSdkVersion project.ext.minSdkVersion
|
|
manifestPlaceholders = project.ext.manifestPlaceholders
|
|
|
|
applicationId mozconfig.substs.ANDROID_PACKAGE_NAME
|
|
testApplicationId 'org.mozilla.roboexample.test'
|
|
testInstrumentationRunner 'org.mozilla.gecko.FennecInstrumentationTestRunner'
|
|
// Used by Robolectric based tests; see TestRunner.
|
|
buildConfigField 'String', 'BUILD_DIR', "\"${project.buildDir}\""
|
|
|
|
vectorDrawables.useSupportLibrary = true
|
|
multiDexEnabled true
|
|
}
|
|
|
|
aaptOptions {
|
|
// The omnijar is already a compressed file itself and Gecko expects it to be
|
|
// STORED within the APK rather than DEFLATED.
|
|
noCompress 'ja'
|
|
}
|
|
|
|
compileOptions {
|
|
sourceCompatibility JavaVersion.VERSION_1_8
|
|
targetCompatibility JavaVersion.VERSION_1_8
|
|
}
|
|
|
|
dexOptions {
|
|
javaMaxHeapSize "4g"
|
|
jumboMode = true
|
|
}
|
|
|
|
lintOptions {
|
|
abortOnError true
|
|
}
|
|
|
|
buildTypes {
|
|
// We have the following difficult situation. Minification (Proguard) is only available per
|
|
// Android-Gradle `buildType`. Instrumentation (Robocop) is only available for exactly one
|
|
// `buildType` (see Android-Gradle `testBuildType`, which defaults to "debug"). Local
|
|
// developers expect to build and run tests against the "debug" build type. Automation
|
|
// needs to produce an instrumentation (Robocop) APK against a Fennec APK that will ship.
|
|
// (This is very unusual; usually, instrumentation tests do _not_ run against a shipping
|
|
// APK.)
|
|
//
|
|
// Given these constraints, we should not change `testBuildType` to avoid confusing local
|
|
// developers. Also, we should not Proguard any "debug" builds, because we don't want local
|
|
// developers to incur the cost of Proguard. However, we still need to find a way to
|
|
// Proguard a shipping APK and produce an instrumentation (Robocop APK) against it. To
|
|
// achieve this, we make "debug" builds Proguard in automation alone. This does have the
|
|
// unfortunate side effect of Proguarding the instrumentation (Robocop) APK, but nothing
|
|
// uses runtime inspection or class-loading with that APK, so it shouldn't be a problem.
|
|
def configureMinifyClosure = {
|
|
// Bug 1229269: we can't yet shrinkResources effectively. Be sure
|
|
// to use -stripped.ap_ after enabling this.
|
|
// shrinkResources true
|
|
minifyEnabled true
|
|
proguardFile "${topsrcdir}/mobile/android/config/proguard/proguard.cfg"
|
|
testProguardFile "${topsrcdir}/mobile/android/config/proguard/proguard-robocop.cfg"
|
|
}
|
|
release configureMinifyClosure
|
|
if (mozconfig.substs.MOZILLA_OFFICIAL) {
|
|
debug configureMinifyClosure
|
|
}
|
|
|
|
def isDebuggable = (!mozconfig.substs.MOZILLA_OFFICIAL) || (mozconfig.substs.NIGHTLY_BUILD && mozconfig.substs.MOZ_DEBUG)
|
|
debug {
|
|
debuggable isDebuggable
|
|
multiDexKeepProguard file("${topsrcdir}/mobile/android/config/proguard/debug-robocop-keeps.cfg")
|
|
}
|
|
release {
|
|
debuggable isDebuggable
|
|
}
|
|
}
|
|
|
|
project.configureProductFlavors.delegate = it
|
|
project.configureProductFlavors()
|
|
|
|
flavorDimensions "geckoBinaries"
|
|
|
|
sourceSets {
|
|
main {
|
|
aidl {
|
|
srcDir "${topsrcdir}/mobile/android/base/aidl"
|
|
}
|
|
|
|
java {
|
|
srcDir "${topsrcdir}/mobile/android/base/java"
|
|
srcDir "${topsrcdir}/mobile/android/services/src/main/java"
|
|
|
|
if (mozconfig.substs.MOZ_ANDROID_MLS_STUMBLER) {
|
|
srcDir "${topsrcdir}/mobile/android/stumbler/java"
|
|
}
|
|
|
|
if (!mozconfig.substs.MOZ_CRASHREPORTER) {
|
|
exclude 'org/mozilla/gecko/CrashReporterActivity.java'
|
|
exclude 'org/mozilla/gecko/CrashHandlerService.java'
|
|
}
|
|
|
|
if (!mozconfig.substs.MOZ_NATIVE_DEVICES) {
|
|
exclude 'org/mozilla/gecko/ChromeCastDisplay.java'
|
|
exclude 'org/mozilla/gecko/ChromeCastPlayer.java'
|
|
exclude 'org/mozilla/gecko/GeckoMediaPlayer.java'
|
|
exclude 'org/mozilla/gecko/GeckoPresentationDisplay.java'
|
|
exclude 'org/mozilla/gecko/MediaPlayerManager.java'
|
|
exclude 'org/mozilla/gecko/RemotePresentationService.java'
|
|
exclude 'org/mozilla/gecko/VirtualPresentation.java'
|
|
}
|
|
|
|
if (mozconfig.substs.MOZ_INSTALL_TRACKING) {
|
|
exclude 'org/mozilla/gecko/adjust/StubAdjustHelper.java'
|
|
} else {
|
|
exclude 'org/mozilla/gecko/adjust/AdjustHelper.java'
|
|
}
|
|
|
|
if (mozconfig.substs.MOZ_ANDROID_MMA) {
|
|
exclude 'org/mozilla/gecko/mma/MmaStubImp.java'
|
|
} else {
|
|
exclude 'org/mozilla/gecko/mma/MmaLeanplumImp.java'
|
|
exclude 'org/mozilla/gecko/mma/LeanplumVariables.java'
|
|
}
|
|
|
|
if (!mozconfig.substs.MOZ_ANDROID_GCM) {
|
|
exclude 'org/mozilla/gecko/gcm/**/*.java'
|
|
exclude 'org/mozilla/gecko/push/**/*.java'
|
|
}
|
|
}
|
|
|
|
res {
|
|
srcDir "${topsrcdir}/${mozconfig.substs.MOZ_BRANDING_DIRECTORY}/res"
|
|
srcDir "${topsrcdir}/mobile/android/services/src/main/res"
|
|
if (mozconfig.substs.MOZ_CRASHREPORTER) {
|
|
srcDir "${topsrcdir}/mobile/android/base/crashreporter/res"
|
|
}
|
|
}
|
|
|
|
assets {
|
|
if (mozconfig.substs.MOZ_ANDROID_DISTRIBUTION_DIRECTORY) {
|
|
srcDir "${mozconfig.substs.MOZ_ANDROID_DISTRIBUTION_DIRECTORY}/assets"
|
|
}
|
|
}
|
|
}
|
|
|
|
test {
|
|
java {
|
|
// Bug 1229149 tracks pushing this into a :services Gradle project.
|
|
srcDir "${topsrcdir}/mobile/android/services/src/test/java"
|
|
|
|
if (!mozconfig.substs.MOZ_ANDROID_GCM) {
|
|
exclude 'org/mozilla/gecko/gcm/**/*.java'
|
|
exclude 'org/mozilla/gecko/push/**/*.java'
|
|
}
|
|
}
|
|
resources {
|
|
// Bug 1229149 tracks pushing this into a :services Gradle project.
|
|
srcDir "${topsrcdir}/mobile/android/services/src/test/resources"
|
|
}
|
|
}
|
|
|
|
androidTest {
|
|
java {
|
|
srcDir "${topsrcdir}/mobile/android/tests/browser/robocop/src"
|
|
// Bug 1229149 tracks pushing this into a :services Gradle project.
|
|
srcDir "${topsrcdir}/mobile/android/services/src/androidTest/java"
|
|
srcDir "${topsrcdir}/mobile/android/tests/browser/junit3/src"
|
|
}
|
|
res {
|
|
srcDir "${topsrcdir}/mobile/android/tests/browser/robocop/res"
|
|
}
|
|
assets {
|
|
srcDir "${topsrcdir}/mobile/android/tests/browser/robocop/assets"
|
|
}
|
|
}
|
|
}
|
|
|
|
testOptions {
|
|
// For Robolectric: see https://github.com/robolectric/robolectric/issues/3333#issuecomment-324300418.
|
|
unitTests.includeAndroidResources true
|
|
|
|
unitTests.all {
|
|
// We'd like to use (Runtime.runtime.availableProcessors()/2), but
|
|
// we have tests that start test servers and the bound ports
|
|
// collide. We'll fix this soon to have much faster test cycles.
|
|
maxParallelForks 1
|
|
}
|
|
}
|
|
}
|
|
|
|
dependencies {
|
|
implementation "com.android.support:support-v4:$support_library_version"
|
|
implementation "com.android.support:appcompat-v7:$support_library_version"
|
|
implementation "com.android.support:cardview-v7:$support_library_version"
|
|
implementation "com.android.support:recyclerview-v7:$support_library_version"
|
|
implementation "com.android.support:design:$support_library_version"
|
|
implementation "com.android.support:customtabs:$support_library_version"
|
|
implementation "com.android.support:palette-v7:$support_library_version"
|
|
|
|
// We always include support for multidexing even when we don't enable it at runtime.
|
|
// We could conditionally include support, but we'd need
|
|
// to generate the `Application` class or fork the file on disk.
|
|
implementation "com.android.support:multidex:1.0.3"
|
|
|
|
if (mozconfig.substs.MOZ_NATIVE_DEVICES) {
|
|
implementation "com.android.support:mediarouter-v7:$support_library_version"
|
|
implementation "com.google.android.gms:play-services-basement:$google_play_services_version"
|
|
implementation "com.google.android.gms:play-services-base:$google_play_services_version"
|
|
implementation "com.google.android.gms:play-services-cast:$google_play_services_cast_version"
|
|
}
|
|
|
|
if (mozconfig.substs.MOZ_INSTALL_TRACKING) {
|
|
implementation "com.google.android.gms:play-services-ads-identifier:$google_play_services_version"
|
|
implementation "com.google.android.gms:play-services-basement:$google_play_services_version"
|
|
}
|
|
|
|
if (mozconfig.substs.MOZ_ANDROID_GCM) {
|
|
implementation "com.google.android.gms:play-services-basement:$google_play_services_version"
|
|
implementation "com.google.android.gms:play-services-base:$google_play_services_version"
|
|
implementation "com.google.android.gms:play-services-gcm:$google_play_services_version"
|
|
}
|
|
|
|
// Include LeakCanary in local builds, but not in official builds.
|
|
if (mozconfig.substs.MOZILLA_OFFICIAL) {
|
|
implementation 'com.squareup.leakcanary:leakcanary-android-no-op:1.4-beta1'
|
|
} else {
|
|
implementation 'com.squareup.leakcanary:leakcanary-android:1.4-beta1'
|
|
}
|
|
testImplementation 'com.squareup.leakcanary:leakcanary-android-no-op:1.4-beta1'
|
|
|
|
implementation project(path: ':geckoview')
|
|
implementation project(path: ':thirdparty')
|
|
|
|
testImplementation 'junit:junit:4.12'
|
|
testImplementation 'org.robolectric:robolectric:3.8'
|
|
testImplementation 'org.simpleframework:simple-http:6.0.1'
|
|
testImplementation 'org.mockito:mockito-core:1.10.19'
|
|
|
|
// Including the Robotium JAR directly can cause issues with dexing.
|
|
androidTestImplementation 'com.jayway.android.robotium:robotium-solo:5.5.4'
|
|
}
|
|
|
|
// TODO: (bug 1261486): This impl is not robust -
|
|
// we just wanted to land something.
|
|
task checkstyle(type: Checkstyle) {
|
|
configFile file("checkstyle.xml")
|
|
// TODO: should use sourceSets from project instead of hard-coded str.
|
|
source = ['../base/java/','../geckoview/src/main/java/']
|
|
// TODO: This ignores our pre-processed resources.
|
|
include '**/*.java'
|
|
// TODO: classpath should probably be something.
|
|
classpath = files()
|
|
}
|
|
|
|
// The localization system uses the moz.build preprocessor to interpolate a .dtd
|
|
// file of XML entity definitions into an XML file of elements referencing those
|
|
// entities. (Each locale produces its own .dtd file, backstopped by the en-US
|
|
// .dtd file in tree.) Android Studio (and IntelliJ) don't handle these inline
|
|
// entities smoothly. This filter merely expands the entities in place, making
|
|
// them appear properly throughout the IDE. Be aware that this assumes that the
|
|
// JVM's file.encoding is utf-8. See comments in
|
|
// mobile/android/mach_commands.py.
|
|
class ExpandXMLEntitiesFilter extends FilterReader {
|
|
ExpandXMLEntitiesFilter(Reader input) {
|
|
// Extremely inefficient, but whatever.
|
|
super(new StringReader(groovy.xml.XmlUtil.serialize(new XmlParser(false, false, true).parse(input))))
|
|
}
|
|
}
|
|
|
|
apply from: "${topsrcdir}/mobile/android/gradle/with_gecko_binaries.gradle"
|
|
|
|
android.applicationVariants.all { variant ->
|
|
def syncPreprocessedJava = task("syncPreprocessedJavaFor${variant.name.capitalize()}", type: Sync) {
|
|
into("${project.buildDir}/moz.build/src/${variant.name}/java")
|
|
from("${topobjdir}/mobile/android/base/generated/preprocessed")
|
|
exclude('**/*.mkdir.done')
|
|
}
|
|
// This is an Android-Gradle plugin 3+-ism. Culted from reading the source,
|
|
// searching for "registerJavaGeneratingTask", and finding
|
|
// https://github.com/GoogleCloudPlatform/endpoints-framework-gradle-plugin/commit/2f2b91476fb1c6647791e2c6fe531a47615a1e85.
|
|
// The added directory doesn't appear in the paths listed by the
|
|
// `sourceSets` task, for reasons unknown.
|
|
variant.registerJavaGeneratingTask(syncPreprocessedJava, syncPreprocessedJava.destinationDir)
|
|
|
|
def syncPreprocessedRes = task("syncPreprocessedResFor${variant.name.capitalize()}", type: Sync) {
|
|
into("${project.buildDir}/moz.build/src/${variant.name}/res")
|
|
from("${topobjdir}/mobile/android/base/res")
|
|
filesMatching('**/strings.xml') {
|
|
filter(ExpandXMLEntitiesFilter)
|
|
}
|
|
exclude('**/*.mkdir.done')
|
|
|
|
// Bug 1478411: We want to turn XML entity expansion errors into the "error:" strings that
|
|
// Tree Herder parses. It's surprisingly difficult to do useful things with exceptions in a
|
|
// filter, but it appears that something deep in the XML parser prints errors to stderr, so
|
|
// we amplify those error outputs to achieve the goal.
|
|
def listener = {
|
|
def matches = (it =~ /\[Fatal Error\] +(.*)/)
|
|
if (matches) {
|
|
def (_, message) = matches[0]
|
|
logger.lifecycle "error: ${topobjdir}/mobile/android/base/res/values/strings.xml${message}"
|
|
}
|
|
} as StandardOutputListener
|
|
|
|
doFirst {
|
|
logging.addStandardErrorListener(listener)
|
|
}
|
|
doLast {
|
|
logging.removeStandardErrorListener(listener)
|
|
}
|
|
}
|
|
|
|
// This is an Android-Gradle plugin 3+-ism. Determined by reading the
|
|
// source. The added directory doesn't appear in the paths listed by the
|
|
// `sourceSets` task, for reasons unknown.
|
|
variant.registerGeneratedResFolders(project.files(syncPreprocessedRes.destinationDir).builtBy(syncPreprocessedRes))
|
|
|
|
// It's not easy -- see the backout in Bug 1242213 -- to change the
|
|
// <manifest> package for Fennec. Gradle has grown a mechanism to achieve
|
|
// what we want for Fennec, however, with applicationId. To use the same
|
|
// manifest as moz.build, we replace the package with org.mozilla.gecko (the
|
|
// eventual package) here.
|
|
def rewriteManifestPackage = task("rewriteManifestPackageFor${variant.name.capitalize()}", type: Copy, dependsOn: rootProject.machBuildGeneratedAndroidCodeAndResources) {
|
|
into("${project.buildDir}/moz.build/src/${variant.name}")
|
|
from("${topobjdir}/mobile/android/base/AndroidManifest.xml")
|
|
filter { it.replaceFirst(/package=".*?"/, 'package="org.mozilla.gecko"') }
|
|
exclude('**/*.mkdir.done')
|
|
}
|
|
|
|
// Every configuration needs the stub manifest at
|
|
// src/main/AndroidManifest.xml and the generated manifest. We can't use
|
|
// the main sourceSet without losing the stub, so we cover all the
|
|
// configurations here.
|
|
android.sourceSets."${variant.name}".manifest.srcFile "${rewriteManifestPackage.destinationDir}/AndroidManifest.xml"
|
|
variant.preBuild.dependsOn rewriteManifestPackage
|
|
|
|
|
|
// Local (read, not 'official') builds want to reflect developer changes to
|
|
// AndroidManifest.xml.in, strings.xml, and preprocessed Java code. To do
|
|
// this, the Gradle build calls out to the moz.build system, which can be
|
|
// re-entrant. Official builds are driven by the moz.build system and
|
|
// should never be re-entrant in this way.
|
|
if (!mozconfig.substs.MOZILLA_OFFICIAL) {
|
|
syncPreprocessedJava.dependsOn rootProject.machBuildGeneratedAndroidCodeAndResources
|
|
syncPreprocessedRes.dependsOn rootProject.machBuildGeneratedAndroidCodeAndResources
|
|
rewriteManifestPackage.dependsOn rootProject.machBuildGeneratedAndroidCodeAndResources
|
|
}
|
|
|
|
// When driven from moz.build via |mach build|, Gradle does not require or
|
|
// use Gecko binaries. It's only |mach package| that packs the Gecko
|
|
// binaries into the resulting APK. The "withoutGeckoBinaries" variants
|
|
// handle this. When driven from Android Studio or Gradle, the
|
|
// "withGeckoBinaries" variants handle packing the Gecko binaries into the
|
|
// resulting APK (for on-device deployment). They also update the Omnijars
|
|
// as necessary, smoothing out the edit-compile-test development cycle.
|
|
// They do what they say on the tin!
|
|
if ((variant.productFlavors*.name).contains('withGeckoBinaries')) {
|
|
configureVariantWithGeckoBinaries(variant)
|
|
}
|
|
}
|
|
|
|
android.applicationVariants.all { variant ->
|
|
configureApplicationVariantWithJNIWrappers(variant, "Fennec")
|
|
}
|
|
|
|
if (gradle.startParameter.taskNames.any { it.endsWith('UnitTest') }) {
|
|
// Approach cribbed from https://github.com/rwinch/jce-checker.
|
|
int maxKeyLen = javax.crypto.Cipher.getMaxAllowedKeyLength("AES")
|
|
if (maxKeyLen <= 128) {
|
|
throw new GradleException(
|
|
"Android unit tests require " +
|
|
"Java Cryptography Extension (JCE) Unlimited Strength Jurisdiction Policy, see " +
|
|
"http://www.oracle.com/technetwork/java/javase/downloads/jce8-download-2133166.html")
|
|
}
|
|
}
|
|
|
|
// Bug 1320035: Gradle configuration for running findbugs. Findbugs only allows
|
|
// to generate one report per invocation: https://stackoverflow.com/a/42720235.
|
|
// Run two tasks, accepting the cost of duplicate work.
|
|
android.applicationVariants.all { variant ->
|
|
task("findbugsHtml${variant.name.capitalize()}", type: FindBugs) {
|
|
// TODO: figure out how to share the shared configuration.
|
|
description "Analyze ${variant.name} code with findbugs (HTML report)"
|
|
group "Verification"
|
|
|
|
ignoreFailures = false // We want builds to fail when running this task and issues are found
|
|
effort = "max" // Using more memory and time to find issues is acceptable in automation
|
|
reportLevel = "high" // For now we only care about high priority bugs. After we have fixed
|
|
// the issues with medium/low priority we can lower the report level here.
|
|
|
|
classes = files("$project.buildDir/intermediates/classes")
|
|
source = variant.javaCompile.source
|
|
classpath = variant.javaCompile.classpath
|
|
|
|
excludeFilter = file("findbugs-exclude.xml")
|
|
dependsOn "bundleAppClasses${variant.name.capitalize()}"
|
|
|
|
reports {
|
|
html.enabled = true // HTML reports for humans.
|
|
html.destination = file("$project.buildDir/reports/findbugs/findbugs-${variant.name}-output.html")
|
|
xml.enabled = false
|
|
}
|
|
}
|
|
|
|
task("findbugsXml${variant.name.capitalize()}", type: FindBugs) {
|
|
// TODO: figure out how to share the shared configuration.
|
|
description "Analyze ${variant.name} code with findbugs (XML report)"
|
|
group "Verification"
|
|
|
|
ignoreFailures = false // We want builds to fail when running this task and issues are found
|
|
effort = "max" // Using more memory and time to find issues is acceptable in automation
|
|
reportLevel = "high" // For now we only care about high priority bugs. After we have fixed
|
|
// the issues with medium/low priority we can lower the report level here.
|
|
|
|
classes = files("$project.buildDir/intermediates/classes")
|
|
source = variant.javaCompile.source
|
|
classpath = variant.javaCompile.classpath
|
|
|
|
excludeFilter = file("findbugs-exclude.xml")
|
|
dependsOn "bundleAppClasses${variant.name.capitalize()}"
|
|
|
|
reports {
|
|
xml.enabled = true // XML reports for machines.
|
|
xml.destination = file("$project.buildDir/reports/findbugs/findbugs-${variant.name}-output.xml")
|
|
html.enabled = false
|
|
}
|
|
}
|
|
}
|
|
|
|
// Bug 1353055 - Strip 'vars' debugging information to agree with moz.build.
|
|
apply from: "${topsrcdir}/mobile/android/gradle/debug_level.gradle"
|
|
android.applicationVariants.all configureVariantDebugLevel
|
|
|
|
|
|
// Bug 1320310 - Hack up the manifest produced by Gradle to match that produced
|
|
// by moz.build. Per https://bugzilla.mozilla.org/show_bug.cgi?id=1320310#c14,
|
|
// this breaks launching in Android Studio; therefore, we only do this for
|
|
// official automation builds and not for local developer builds.
|
|
import groovy.xml.XmlUtil
|
|
|
|
// Workaround for fixing sub-dependencies upon gradle error:
|
|
// All gms/firebase (except play-services-cast since it has sub-dependencies in 15.0.0)
|
|
// libraries must use the exact same version specification (mixing versions can
|
|
// lead to runtime crashes). Found versions 15.0.1, 15.0.0. Examples include
|
|
// com.google.android.gms:play-services-base:15.0.1 and com.google.android.gms:play-services-basement:15.0.0
|
|
configurations.all {
|
|
resolutionStrategy {
|
|
eachDependency { DependencyResolveDetails details ->
|
|
if (details.requested.group == 'com.google.android.gms'
|
|
&& details.requested.name != 'play-services-cast') {
|
|
details.useVersion "$google_play_services_version"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
android.applicationVariants.all { variant ->
|
|
if (!mozconfig.substs.MOZILLA_OFFICIAL) {
|
|
return
|
|
}
|
|
|
|
variant.outputs.each { output ->
|
|
output.processManifest.doLast {
|
|
[file("${manifestOutputDirectory}/AndroidManifest.xml"),
|
|
].each({ File manifestOutFile ->
|
|
if (manifestOutFile.exists()) {
|
|
def contents = manifestOutFile.getText('UTF-8')
|
|
|
|
// A non-validating, non-namespace aware XML processor.
|
|
def xml = new XmlSlurper(false, false).parseText(contents)
|
|
|
|
// First, reinstate our <activity-alias android:name=".App">.
|
|
xml.depthFirst()
|
|
.findAll { it.name() == 'activity-alias' && it.'@android:name' == 'org.mozilla.gecko.App' }
|
|
.each { it.'@android:name' = '.App' }
|
|
|
|
manifestOutFile.write(XmlUtil.serialize(xml), 'UTF-8')
|
|
}
|
|
})
|
|
}
|
|
}
|
|
}
|
|
|
|
// Bug 1415298: make Robolectric find assets. Fix adapted from
|
|
// https://github.com/robolectric/robolectric/issues/2647.
|
|
android.applicationVariants.all { variant ->
|
|
def productFlavor = ""
|
|
variant.productFlavors.each {
|
|
productFlavor += "${it.name.capitalize()}"
|
|
}
|
|
def buildType = "${variant.buildType.name.capitalize()}"
|
|
tasks["compile${productFlavor}${buildType}UnitTestSources"].dependsOn(tasks["merge${productFlavor}${buildType}Assets"])
|
|
}
|
|
|
|
apply from: "${topsrcdir}/mobile/android/gradle/jacoco_dependencies.gradle"
|
|
if (project.hasProperty('enable_code_coverage')) {
|
|
apply from: "${topsrcdir}/mobile/android/gradle/jacoco_for_junit.gradle"
|
|
}
|
|
|
|
|
|
// Set up code coverage for tests on emulators.
|
|
if (mozconfig.substs.MOZ_JAVA_CODE_COVERAGE) {
|
|
android {
|
|
jacoco {
|
|
version = "$jacoco_version"
|
|
}
|
|
buildTypes {
|
|
debug {
|
|
testCoverageEnabled true
|
|
}
|
|
}
|
|
}
|
|
|
|
dependencies {
|
|
// This is required both in the instrumented application classes and the test classes,
|
|
// so `api` has to be used instead of `androidTestImplementation`.
|
|
api "org.jacoco:org.jacoco.agent:$jacoco_version:runtime"
|
|
}
|
|
|
|
// Generate tasks to archive compiled classfiles for later use with JaCoCo report generation.
|
|
// One of these tasks is used by `mach android archive-coverage-artifacts`.
|
|
android.applicationVariants.all { variant ->
|
|
def name = variant.name
|
|
def compileTask = tasks.getByName("compile${name.capitalize()}JavaWithJavac")
|
|
task "archiveClassfiles${name.capitalize()}"(type: Zip, dependsOn: compileTask) {
|
|
description = "Archive compiled classfiles for $name in order to export them as code coverage artifacts."
|
|
def fileFilter = ['**/androidTest/**',
|
|
'**/test/**',
|
|
'**/R.class',
|
|
'**/R$*.class',
|
|
'**/BuildConfig.*',
|
|
'**/Manifest*.*',
|
|
'**/*Test*.*',
|
|
'android/**/*.*']
|
|
from fileTree(dir: compileTask.destinationDir, excludes: fileFilter)
|
|
destinationDir = file("${buildDir}/coverage")
|
|
// Note: This task assumes only one variant of archiveClassfiles* will be used.
|
|
// Running multiple variants of this task will overwrite the output archive.
|
|
archiveName = 'target.app_classfiles.zip'
|
|
}
|
|
}
|
|
}
|