diff options
Diffstat (limited to 'mobile/android/geckoview/build.gradle')
| -rw-r--r-- | mobile/android/geckoview/build.gradle | 580 |
1 files changed, 580 insertions, 0 deletions
diff --git a/mobile/android/geckoview/build.gradle b/mobile/android/geckoview/build.gradle new file mode 100644 index 0000000000..288dfde227 --- /dev/null +++ b/mobile/android/geckoview/build.gradle @@ -0,0 +1,580 @@ +buildDir "${topobjdir}/gradle/build/mobile/android/geckoview" + +import groovy.json.JsonOutput + +apply plugin: 'com.android.library' +apply plugin: 'checkstyle' +apply plugin: 'kotlin-android' + +apply from: "${topsrcdir}/mobile/android/gradle/product_flavors.gradle" + +// The SDK binding generation tasks depend on the JAR creation task of the +// :annotations project. +evaluationDependsOn(':annotations') + +// Non-official versions are like "61.0a1", where "a1" is the milestone. +// This simply strips that off, leaving "61.0" in this example. +def getAppVersionWithoutMilestone() { + return mozconfig.substs.MOZ_APP_VERSION.replaceFirst(/a[0-9]/, "") +} + +// This converts MOZ_APP_VERSION into an integer +// version code. +// +// We take something like 58.1.2a1 and come out with 5800102 +// This gives us 3 digits for the major number, and 2 digits +// each for the minor and build number. Beta and Release +// +// This must be synchronized with _compute_gecko_version(...) in /taskcluster/taskgraph/transforms/task.py +def computeVersionCode() { + String appVersion = getAppVersionWithoutMilestone() + + // Split on the dot delimiter, e.g. 58.1.1a1 -> ["58, "1", "1a1"] + String[] parts = appVersion.split('\\.') + + assert parts.size() == 2 || parts.size() == 3 + + // Major + int code = Integer.parseInt(parts[0]) * 100000 + + // Minor + code += Integer.parseInt(parts[1]) * 100 + + // Build + if (parts.size() == 3) { + code += Integer.parseInt(parts[2]) + } + + return code; +} + +def computeVersionNumber() { + def appVersion = getAppVersionWithoutMilestone() + def parts = appVersion.split('\\.') + return parts[0] + "." + parts[1] + "." + getBuildId() +} + +// Mimic Python: open(os.path.join(buildconfig.topobjdir, 'buildid.h')).readline().split()[2] +def getBuildId() { + return file("${topobjdir}/buildid.h").getText('utf-8').split()[2] +} + +android { + buildToolsVersion project.ext.buildToolsVersion + 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 + multiDexEnabled true + + versionCode computeVersionCode() + versionName "${mozconfig.substs.MOZ_APP_VERSION}-${mozconfig.substs.MOZ_UPDATE_CHANNEL}" + consumerProguardFiles 'proguard-rules.txt' + + testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner" + + buildConfigField 'String', "GRE_MILESTONE", "\"${mozconfig.substs.GRE_MILESTONE}\"" + buildConfigField 'String', "MOZ_APP_BASENAME", "\"${mozconfig.substs.MOZ_APP_BASENAME}\""; + + // For the benefit of future archaeologists: + // GRE_BUILDID is exactly the same as MOZ_APP_BUILDID unless you're running + // on XULRunner, which is never the case on Android. + buildConfigField 'String', "MOZ_APP_BUILDID", "\"${getBuildId()}\""; + buildConfigField 'String', "MOZ_APP_ID", "\"${mozconfig.substs.MOZ_APP_ID}\""; + buildConfigField 'String', "MOZ_APP_NAME", "\"${mozconfig.substs.MOZ_APP_NAME}\""; + buildConfigField 'String', "MOZ_APP_VENDOR", "\"${mozconfig.substs.MOZ_APP_VENDOR}\""; + buildConfigField 'String', "MOZ_APP_VERSION", "\"${mozconfig.substs.MOZ_APP_VERSION}\""; + buildConfigField 'String', "MOZ_APP_DISPLAYNAME", "\"${mozconfig.substs.MOZ_APP_DISPLAYNAME}\""; + buildConfigField 'String', "MOZ_APP_UA_NAME", "\"${mozconfig.substs.MOZ_APP_UA_NAME}\""; + buildConfigField 'String', "MOZ_UPDATE_CHANNEL", "\"${mozconfig.substs.MOZ_UPDATE_CHANNEL}\""; + + // MOZILLA_VERSION is oddly quoted from autoconf, but we don't have to handle it specially in Gradle. + buildConfigField 'String', "MOZILLA_VERSION", "\"${mozconfig.substs.MOZILLA_VERSION}\""; + buildConfigField 'String', "OMNIJAR_NAME", "\"${mozconfig.substs.OMNIJAR_NAME}\""; + + // Keep in sync with actual user agent in nsHttpHandler::BuildUserAgent + buildConfigField 'String', "USER_AGENT_GECKOVIEW_MOBILE", "\"Mozilla/5.0 (Android \" + android.os.Build.VERSION.RELEASE + \"; Mobile; rv:\" + ${mozconfig.defines.MOZILLA_UAVERSION} + \") Gecko/\" + ${mozconfig.defines.MOZILLA_UAVERSION} + \" Firefox/\" + ${mozconfig.defines.MOZILLA_UAVERSION}"; + buildConfigField 'String', "USER_AGENT_GECKOVIEW_TABLET", "\"Mozilla/5.0 (Android \" + android.os.Build.VERSION.RELEASE + \"; Tablet; rv:\" + ${mozconfig.defines.MOZILLA_UAVERSION} + \") Gecko/\" + ${mozconfig.defines.MOZILLA_UAVERSION} + \" Firefox/\" + ${mozconfig.defines.MOZILLA_UAVERSION}"; + + buildConfigField 'int', 'MIN_SDK_VERSION', mozconfig.substs.MOZ_ANDROID_MIN_SDK_VERSION; + + // Is the underlying compiled C/C++ code compiled with --enable-debug? + buildConfigField 'boolean', 'DEBUG_BUILD', mozconfig.substs.MOZ_DEBUG ? 'true' : 'false'; + + // See this wiki page for more details about channel specific build defines: + // https://wiki.mozilla.org/Platform/Channel-specific_build_defines + // This makes no sense for GeckoView and should be removed as soon as possible. + buildConfigField 'boolean', 'RELEASE_OR_BETA', mozconfig.substs.RELEASE_OR_BETA ? 'true' : 'false'; + // This makes no sense for GeckoView and should be removed as soon as possible. + buildConfigField 'boolean', 'NIGHTLY_BUILD', mozconfig.substs.NIGHTLY_BUILD ? 'true' : 'false'; + // This makes no sense for GeckoView and should be removed as soon as possible. + buildConfigField 'boolean', 'MOZ_CRASHREPORTER', mozconfig.substs.MOZ_CRASHREPORTER ? 'true' : 'false'; + + // Official corresponds, roughly, to whether this build is performed on + // Mozilla's continuous integration infrastructure. You should disable + // developer-only functionality when this flag is set. + // This makes no sense for GeckoView and should be removed as soon as possible. + buildConfigField 'boolean', 'MOZILLA_OFFICIAL', mozconfig.substs.MOZILLA_OFFICIAL ? 'true' : 'false'; + } + + project.configureProductFlavors.delegate = it + project.configureProductFlavors() + + compileOptions { + sourceCompatibility JavaVersion.VERSION_1_8 + targetCompatibility JavaVersion.VERSION_1_8 + } + + dexOptions { + javaMaxHeapSize "6g" + } + + lintOptions { + abortOnError false + } + + sourceSets { + main { + java { + srcDir "${topsrcdir}/mobile/android/geckoview/src/thirdparty/java" + + if (!mozconfig.substs.MOZ_ANDROID_HLS_SUPPORT) { + exclude 'com/google/android/exoplayer2/**' + exclude 'org/mozilla/gecko/media/GeckoHlsAudioRenderer.java' + exclude 'org/mozilla/gecko/media/GeckoHlsPlayer.java' + exclude 'org/mozilla/gecko/media/GeckoHlsRendererBase.java' + exclude 'org/mozilla/gecko/media/GeckoHlsVideoRenderer.java' + exclude 'org/mozilla/gecko/media/Utils.java' + } + + if (mozconfig.substs.MOZ_WEBRTC) { + srcDir "${topsrcdir}/dom/media/systemservices/android_video_capture/java/src" + srcDir "${topsrcdir}/third_party/libwebrtc/webrtc/sdk/android" + srcDir "${topsrcdir}/third_party/libwebrtc/webrtc/rtc_base/java" + } + + srcDir "${topobjdir}/mobile/android/geckoview/src/main/java" + } + + resources { + if (mozconfig.substs.MOZ_ASAN) { + // If this is an ASAN build, include a `wrap.sh` for Android 8.1+ devices. See + // https://developer.android.com/ndk/guides/wrap-script. + srcDir "${topsrcdir}/mobile/android/geckoview/src/asan/resources" + } + } + + assets { + } + + debug { + manifest.srcFile "${topobjdir}/mobile/android/geckoview/src/main/AndroidManifest_overlay.xml" + } + + release { + manifest.srcFile "${topobjdir}/mobile/android/geckoview/src/main/AndroidManifest_overlay.xml" + } + } + } +} + +tasks.withType(org.jetbrains.kotlin.gradle.tasks.KotlinCompile) { + // Translate Kotlin messages like "w: ..." and "e: ..." into + // "...: warning: ..." and "...: error: ...", to make Treeherder understand. + def listener = { + if (it.startsWith("e: warnings found")) { + return + } + + if (it.startsWith('w: ') || it.startsWith('e: ')) { + def matches = (it =~ /([ew]): (.+): \((\d+), (\d+)\): (.*)/) + if (!matches) { + logger.quiet "kotlinc message format has changed!" + if (it.startsWith('w: ')) { + // For warnings, don't continue because we don't want to throw an + // exception. For errors, we want the exception so that the new error + // message format gets translated properly. + return + } + } + def (_, type, file, line, column, message) = matches[0] + type = (type == 'w') ? 'warning' : 'error' + // Use logger.lifecycle, which does not go through stderr again. + logger.lifecycle "$file:$line:$column: $type: $message" + } + } as StandardOutputListener + + kotlinOptions { + allWarningsAsErrors = true + } + + doFirst { + logging.addStandardErrorListener(listener) + } + doLast { + logging.removeStandardErrorListener(listener) + } +} + +dependencies { + // For exoplayer. + compileOnly "com.google.code.findbugs:jsr305:3.0.2" + compileOnly "org.checkerframework:checker-compat-qual:2.5.0" + compileOnly "org.checkerframework:checker-qual:2.5.0" + compileOnly "org.jetbrains.kotlin:kotlin-annotations-jvm:1.3.70" + + implementation "androidx.annotation:annotation:1.1.0" + implementation "androidx.legacy:legacy-support-v4:1.0.0" + implementation "androidx.palette:palette:1.0.0" + + implementation "com.google.android.gms:play-services-fido:18.1.0" + implementation "org.yaml:snakeyaml:1.24:android" + + implementation "androidx.lifecycle:lifecycle-extensions:2.0.0" + implementation "androidx.lifecycle:lifecycle-common-java8:2.0.0" + + testImplementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version" + testImplementation 'junit:junit:4.12' + testImplementation 'org.robolectric:robolectric:4.3' + testImplementation 'org.mockito:mockito-core:1.10.19' + + androidTestImplementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version" + androidTestImplementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.3.2" + androidTestImplementation 'androidx.test:runner:1.1.0' + androidTestImplementation 'androidx.test:rules:1.1.0' + androidTestImplementation 'androidx.test.ext:junit:1.1.0' + androidTestImplementation 'androidx.test.espresso:espresso-core:3.1.0' + + androidTestImplementation 'com.koushikdutta.async:androidasync:2.+' + + androidTestImplementation 'androidx.multidex:multidex:2.0.0' +} + +apply from: "${topsrcdir}/mobile/android/gradle/with_gecko_binaries.gradle" + +android.libraryVariants.all { variant -> + // See the notes in mobile/android/app/build.gradle for details on including + // Gecko binaries and the Omnijar. + if ((variant.productFlavors*.name).contains('withGeckoBinaries')) { + configureVariantWithGeckoBinaries(variant) + } + + // Javadoc and Sources JAR configuration cribbed from + // https://github.com/mapbox/mapbox-gl-native/blob/d169ea55c1cfa85cd8bf19f94c5f023569f71810/platform/android/MapboxGLAndroidSDK/build.gradle#L85 + // informed by + // https://code.tutsplus.com/tutorials/creating-and-publishing-an-android-library--cms-24582, + // and amended from numerous Stackoverflow posts. + def name = variant.name + def javadoc = task "javadoc${name.capitalize()}"(type: Javadoc) { + failOnError = false + description = "Generate Javadoc for build variant $name" + destinationDir = new File(destinationDir, variant.baseName) + + // The javadoc task will not re-run if the previous run is still up-to-date, + // this is a problem for the javadoc lint, which needs to read the output of the task + // to determine if there are warnings or errors. To force that we pass a -Pandroid-lint + // parameter to all lints that can be used here to force running the task every time. + outputs.upToDateWhen { + !project.hasProperty('android-lint') + } + + doFirst { + classpath = files(variant.javaCompileProvider.get().classpath.files) + } + + def results = [] + def listener = { + if (!it.toLowerCase().contains("warning") && !it.toLowerCase().contains("error")) { + // Likely not an error or a warning + return + } + // Like '/abs/path/to/topsrcdir/mobile/android/geckoview/src/main/java/org/mozilla/geckoview/ContentBlocking.java:480: warning: no @return' + def matches = (it =~ /(.+):(\d+):.*(warning|error)(.*)/) + if (!matches) { + // could not parse, let's add it anyway since it's a warning or error + results << [path: "parsing-failed", lineno: 0, level: "error", message: it] + return + } + def (_, file, line, level, message) = matches[0] + results << [path: file, lineno: line, level: level, message: message] + } as StandardOutputListener + + doFirst { + logging.addStandardErrorListener(listener) + } + + doLast { + logging.removeStandardErrorListener(listener) + + // We used to treat Javadoc warnings as errors here; now we rely on the + // `android-javadoc` linter to fail in the face of Javadoc warnings. + def resultsJson = JsonOutput.toJson(results) + + file("$buildDir/reports").mkdirs() + file("$buildDir/reports/javadoc-results-${name}.json").write(resultsJson) + } + + source = variant.sourceSets.collect({ it.java.srcDirs }) + exclude '**/R.java', '**/BuildConfig.java' + include 'org/mozilla/geckoview/**.java' + options.addPathOption('sourcepath', ':').setValue( + variant.sourceSets.collect({ it.java.srcDirs }).flatten() + + variant.generateBuildConfigProvider.get().sourceOutputDir + + variant.aidlCompileProvider.get().sourceOutputDir) + + // javadoc 8 has a bug that requires the rt.jar file from the JRE to be + // in the bootclasspath (https://stackoverflow.com/a/30458820). + options.bootClasspath = [ + file("${System.properties['java.home']}/lib/rt.jar")] + android.bootClasspath + options.memberLevel = JavadocMemberLevel.PROTECTED + options.source = 8 + options.links("https://d.android.com/reference/") + + options.docTitle = "GeckoView ${mozconfig.substs.MOZ_APP_VERSION} API" + options.header = "GeckoView ${mozconfig.substs.MOZ_APP_VERSION} API" + options.noTimestamp = true + options.noIndex = true + options.noQualifiers = ['java.lang'] + options.tags = ['hide:a:'] + } + + def javadocJar = task("javadocJar${name.capitalize()}", type: Jar, dependsOn: javadoc) { + classifier = 'javadoc' + from javadoc.destinationDir + } + + // This task is used by `mach android geckoview-docs`. + task("javadocCopyJar${name.capitalize()}", type: Copy) { + from(javadocJar.destinationDir) { + include 'geckoview-*-javadoc.jar' + rename { _ -> 'geckoview-javadoc.jar' } + } + into javadocJar.destinationDir + dependsOn javadocJar + } + + def sourcesJar = task("sourcesJar${name.capitalize()}", type: Jar) { + classifier 'sources' + description = "Generate Javadoc for build variant $name" + destinationDir = new File(destinationDir, variant.baseName) + from files(variant.sourceSets.collect({ it.java.srcDirs }).flatten()) + } + + task("checkstyle${name.capitalize()}", type: Checkstyle) { + classpath = variant.javaCompileProvider.get().classpath + // TODO: cleanup and include all sources + source = ['src/main/java/'] + include '**/*.java' + + } +} + +checkstyle { + configDir = file(".") + configFile = file("checkstyle.xml") + toolVersion = "8.36.2" +} + +android.libraryVariants.all { variant -> + if (variant.name == mozconfig.substs.GRADLE_ANDROID_GECKOVIEW_VARIANT_NAME) { + configureLibraryVariantWithJNIWrappers(variant, "Generated") + } +} + +android.libraryVariants.all { variant -> + // At this point, the Android-Gradle plugin has created all the Android + // tasks and configurations. This is the time for us to declare additional + // Glean files to package into AAR files. This packs `metrics.yaml` in the + // root of the AAR, sibling to `AndroidManifest.xml` and `classes.jar`. By + // default, consumers of the AAR will ignore this file, but consumers that + // look for it can find it (provided GeckoView is a `module()` dependency + // and not a `project()` dependency.) Under the hood this uses that the + // task provided by `packageLibraryProvider` task is a Maven `Zip` task, + // and we can simply extend its inputs. See + // https://android.googlesource.com/platform/tools/base/+/0cbe8846f7d02c0bb6f07156b9f4fde16d96d329/build-system/gradle-core/src/main/java/com/android/build/gradle/tasks/BundleAar.kt#94. + variant.packageLibraryProvider.get().from("${topsrcdir}/toolkit/components/telemetry/geckoview/streaming/metrics.yaml") +} + +apply plugin: 'maven-publish' + +version = computeVersionNumber() +if (!mozconfig.substs.MOZILLA_OFFICIAL && !mozconfig.substs.MOZ_ANDROID_FAT_AAR_ARCHITECTURES) { + // Use -SNAPSHOT versions locally to enable the local GeckoView substitution flow. + version = "${version}-SNAPSHOT" +} + +publishing { + publications { + android.libraryVariants.all { variant -> + "${variant.name}"(MavenPublication) { + pom { + groupId = 'org.mozilla.geckoview' + + if (mozconfig.substs.MOZ_UPDATE_CHANNEL == 'release') { + // Release artifacts don't specify the channel, for the sake of simplicity. + artifactId = 'geckoview' + } else { + artifactId = "geckoview-${mozconfig.substs.MOZ_UPDATE_CHANNEL}" + } + + if (mozconfig.substs.MOZILLA_OFFICIAL && !mozconfig.substs.MOZ_ANDROID_FAT_AAR_ARCHITECTURES) { + // In automation, per-architecture artifacts identify + // the architecture; multi-architecture artifacts don't. + // When building locally, we produce a "skinny AAR" with + // one target architecture masquerading as a "fat AAR" + // to enable Gradle composite builds to substitute this + // project into consumers easily. + artifactId = "${artifactId}-${mozconfig.substs.ANDROID_CPU_ARCH}" + } + + url = 'https://wiki.mozilla.org/Mobile/GeckoView' + + licenses { + license { + name = 'The Mozilla Public License, v. 2.0' + url = 'http://mozilla.org/MPL/2.0/' + distribution = 'repo' + } + } + + scm { + if (mozconfig.substs.MOZ_INCLUDE_SOURCE_INFO) { + // URL is like "https://hg.mozilla.org/mozilla-central/rev/1e64b8a0c546a49459d404aaf930d5b1f621246a". + connection = "scm::hg::${mozconfig.substs.MOZ_SOURCE_REPO}" + url = mozconfig.substs.MOZ_SOURCE_URL + tag = mozconfig.substs.MOZ_SOURCE_CHANGESET + } else { + // Default to mozilla-central. + connection = 'scm::hg::https://hg.mozilla.org/mozilla-central/' + url = 'https://hg.mozilla.org/mozilla-central/' + } + } + + // Unfortunately Gradle does not provide a way to expose dependencies for custom + // project types like Android plugins. So we need to add them manually to the POM + // XML here, or use a plugin that achieves the same (like + // https://github.com/wupdigital/android-maven-publish). We elect to do this + // manually since our dependencies are simple and plugins increase our complexity + // surface. This workaround can be removed after this issue is fixed: + // https://github.com/gradle/gradle/issues/1842 + withXml { + def dependenciesNode = asNode().appendNode('dependencies') + + configurations.getByName("implementation").dependencies.each { + def dependencyNode = dependenciesNode.appendNode('dependency') + dependencyNode.appendNode('groupId', it.group) + dependencyNode.appendNode('artifactId', it.name) + dependencyNode.appendNode('version', it.version) + } + } + } + + artifact tasks["bundle${variant.name.capitalize()}Aar"] + + // Javadoc and sources for developer ergononomics. + artifact tasks["javadocJar${variant.name.capitalize()}"] + artifact tasks["sourcesJar${variant.name.capitalize()}"] + } + } + } + repositories { + maven { + url = "${project.buildDir}/maven" + } + } +} + +// This is all related to the withGeckoBinaries approach; see +// mobile/android/gradle/with_gecko_binaries.gradle. +afterEvaluate { + // The bundle tasks are only present when the particular configuration is + // being built, so this task might not exist. (This is due to the way the + // Android Gradle plugin defines things during configuration.) + def bundleWithGeckoBinaries = tasks.findByName('bundleWithGeckoBinariesReleaseAar') + if (!bundleWithGeckoBinaries) { + return + } + + // Remove default configuration, which is the release configuration, when + // we're actually building withGeckoBinaries. This makes `gradle install` + // install the withGeckoBinaries artifacts, not the release artifacts (which + // are withoutGeckoBinaries and not suitable for distribution.) + def Configuration archivesConfig = project.getConfigurations().getByName('archives') + archivesConfig.artifacts.removeAll { it.extension.equals('aar') } + + // For now, ensure Kotlin is only used in tests. + android.sourceSets.all { sourceSet -> + if (sourceSet.name.startsWith('test') || sourceSet.name.startsWith('androidTest')) { + return + } + (sourceSet.java.srcDirs + sourceSet.kotlin.srcDirs).each { + if (!fileTree(it, { include '**/*.kt' }).empty) { + throw new GradleException("Kotlin used in non-test directory ${it.path}") + } + } + } +} + +// Bug 1353055 - Strip 'vars' debugging information to agree with moz.build. +apply from: "${topsrcdir}/mobile/android/gradle/debug_level.gradle" +android.libraryVariants.all configureVariantDebugLevel + +// There's nothing specific to the :geckoview project here -- this just needs to +// be somewhere where the Android plugin is available so that we can fish the +// path to "android.jar". +task("generateSDKBindings", type: JavaExec) { + classpath project(':annotations').jar.archivePath + classpath project(':annotations').compileJava.classpath + + // To use the lint APIs: "Lint must be invoked with the System property + // com.android.tools.lint.bindir pointing to the ANDROID_SDK tools + // directory" + systemProperties = [ + 'com.android.tools.lint.bindir': "${android.sdkDirectory}/tools", + ] + + main = 'org.mozilla.gecko.annotationProcessors.SDKProcessor' + // We only want to generate bindings for the main framework JAR, + // but not any of the additional android.test libraries. + args android.bootClasspath.findAll { it.getName().startsWith('android.jar') } + args 16 + args "${topobjdir}/widget/android/bindings" + + // Configure the arguments at evaluation-time, not at configuration-time. + doFirst { + // From -Pgenerate_sdk_bindings_args=... on command line; missing in + // `android-gradle-dependencies` toolchain task. + if (project.hasProperty('generate_sdk_bindings_args')) { + args project.generate_sdk_bindings_args.split(';') + } + } + + workingDir "${topsrcdir}/widget/android/bindings" + + dependsOn project(':annotations').jar +} + +apply plugin: 'org.mozilla.apilint' + +apiLint { + // TODO: Change this to `org` after hiding org.mozilla.gecko + packageFilter = 'org.mozilla.geckoview' + changelogFileName = 'src/main/java/org/mozilla/geckoview/doc-files/CHANGELOG.md' + skipClassesRegex = ['^org.mozilla.geckoview.BuildConfig$'] + lintFilters = ['GV'] + deprecationAnnotation = 'org.mozilla.geckoview.DeprecationSchedule' + libraryVersion = mozconfig.substs.MOZILLA_VERSION.split('\\.')[0] as Integer + allowedPackages = [ + 'java', + 'android', + 'androidx', + 'org.json', + 'org.mozilla.geckoview', + ] +} |