554 lines
23 KiB
Groovy
554 lines
23 KiB
Groovy
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')
|
|
|
|
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
|
|
|
|
versionCode project.ext.versionCode
|
|
versionName project.ext.versionName
|
|
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", "\"${project.ext.buildId}\"";
|
|
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} + \" IceCat/\" + ${mozconfig.defines.MOZILLA_UAVERSION}";
|
|
buildConfigField 'String', "USER_AGENT_GECKOVIEW_MOBILE_ANDROID_10", "\"Mozilla/5.0 (Android 10; Mobile; rv:\" + ${mozconfig.defines.MOZILLA_UAVERSION} + \") Gecko/\" + ${mozconfig.defines.MOZILLA_UAVERSION} + \" IceCat/\" + ${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';
|
|
|
|
buildConfigField 'int', 'MOZ_ANDROID_CONTENT_SERVICE_COUNT', mozconfig.substs.MOZ_ANDROID_CONTENT_SERVICE_COUNT;
|
|
|
|
// 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';
|
|
|
|
// This env variable signifies whether we are running an isolated process build.
|
|
buildConfigField 'boolean', 'MOZ_ANDROID_CONTENT_SERVICE_ISOLATED_PROCESS', mozconfig.substs.MOZ_ANDROID_CONTENT_SERVICE_ISOLATED_PROCESS ? 'true' : 'false';
|
|
}
|
|
|
|
project.configureProductFlavors.delegate = it
|
|
project.configureProductFlavors()
|
|
|
|
compileOptions {
|
|
sourceCompatibility JavaVersion.VERSION_17
|
|
targetCompatibility JavaVersion.VERSION_17
|
|
}
|
|
|
|
lintOptions {
|
|
abortOnError false
|
|
}
|
|
|
|
sourceSets {
|
|
main {
|
|
java {
|
|
if (!mozconfig.substs.MOZ_ANDROID_HLS_SUPPORT) {
|
|
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/sdk/android/api"
|
|
srcDir "${topsrcdir}/third_party/libwebrtc/sdk/android/src"
|
|
srcDir "${topsrcdir}/third_party/libwebrtc/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"
|
|
}
|
|
}
|
|
|
|
withGeckoBinaries {
|
|
assets {
|
|
// This should contain only `omni.ja`.
|
|
srcDir "${topobjdir}/dist/geckoview/assets"
|
|
}
|
|
|
|
jniLibs {
|
|
if (!mozconfig.substs.MOZ_ANDROID_FAT_AAR_ARCHITECTURES) {
|
|
srcDir "${topobjdir}/dist/geckoview/lib"
|
|
} else {
|
|
srcDir "${topobjdir}/dist/fat-aar/output/jni"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
buildFeatures {
|
|
buildConfig true
|
|
aidl = true
|
|
}
|
|
|
|
publishing {
|
|
singleVariant('withGeckoBinariesDebug')
|
|
}
|
|
|
|
namespace 'org.mozilla.geckoview'
|
|
}
|
|
|
|
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
|
|
jvmTarget = JavaVersion.VERSION_17
|
|
}
|
|
|
|
doFirst {
|
|
logging.addStandardErrorListener(listener)
|
|
}
|
|
doLast {
|
|
logging.removeStandardErrorListener(listener)
|
|
}
|
|
}
|
|
|
|
configurations {
|
|
withGeckoBinariesApi {
|
|
outgoing {
|
|
if (!mozconfig.substs.MOZ_ANDROID_GECKOVIEW_LITE) {
|
|
// The omni build provides glean-native
|
|
capability("org.mozilla.telemetry:glean-native:${project.ext.gleanVersion}")
|
|
}
|
|
afterEvaluate {
|
|
// Implicit capability
|
|
capability("org.mozilla.geckoview:${getArtifactId()}:${project.ext.versionNumber}")
|
|
}
|
|
}
|
|
}
|
|
// TODO: This is a workaround for a bug that was fixed in Gradle 7.
|
|
// The variant resolver _should_ pick the RuntimeOnly configuration when building
|
|
// the tests as those define the implicit :geckoview capability but it doesn't,
|
|
// so we manually define it here.
|
|
withGeckoBinariesRuntimeOnly {
|
|
outgoing {
|
|
afterEvaluate {
|
|
// Implicit capability
|
|
capability("org.mozilla.geckoview:geckoview:${project.ext.versionNumber}")
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
dependencies {
|
|
implementation ComponentsDependencies.androidx_annotation
|
|
implementation ComponentsDependencies.androidx_collection
|
|
implementation ComponentsDependencies.androidx_core
|
|
|
|
implementation "com.google.android.gms:play-services-fido:21.1.0"
|
|
implementation "org.yaml:snakeyaml:2.2"
|
|
|
|
implementation ComponentsDependencies.androidx_lifecycle_common
|
|
implementation ComponentsDependencies.androidx_lifecycle_process
|
|
|
|
if (mozconfig.substs.MOZ_ANDROID_HLS_SUPPORT) {
|
|
implementation project(":exoplayer2")
|
|
}
|
|
|
|
testImplementation ComponentsDependencies.testing_junit
|
|
testImplementation ComponentsDependencies.testing_robolectric
|
|
|
|
androidTestImplementation ComponentsDependencies.testing_coroutines
|
|
androidTestImplementation ComponentsDependencies.androidx_test_runner
|
|
androidTestImplementation ComponentsDependencies.androidx_test_rules
|
|
androidTestImplementation ComponentsDependencies.androidx_test_junit
|
|
androidTestImplementation ComponentsDependencies.androidx_espresso_core
|
|
|
|
androidTestImplementation 'com.koushikdutta.async:androidasync:3.1.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.asFile.get() +
|
|
variant.aidlCompileProvider.get().sourceOutputDir.asFile.get()
|
|
)
|
|
options.addStringOption("Xmaxwarns", "1000")
|
|
|
|
classpath += files(android.getBootClasspath())
|
|
classpath += variant.javaCompileProvider.get().classpath
|
|
|
|
options.memberLevel = JavadocMemberLevel.PROTECTED
|
|
options.source = 11
|
|
options.links("https://developer.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.noQualifiers = ['java.lang']
|
|
options.tags = ['hide:a:']
|
|
}
|
|
|
|
def javadocJar = task("javadocJar${name.capitalize()}", type: Jar, dependsOn: javadoc) {
|
|
archiveClassifier = 'javadoc'
|
|
from javadoc.destinationDir
|
|
}
|
|
|
|
// This task is used by `mach android geckoview-docs`.
|
|
task("javadocCopyJar${name.capitalize()}", type: Copy) {
|
|
from(javadocJar.destinationDirectory) {
|
|
include 'geckoview-*-javadoc.jar'
|
|
rename { _ -> 'geckoview-javadoc.jar' }
|
|
}
|
|
into javadocJar.destinationDirectory
|
|
dependsOn javadocJar
|
|
}
|
|
|
|
def sourcesJar = task("sourcesJar${name.capitalize()}", type: Jar) {
|
|
archiveClassifier = 'sources'
|
|
description = "Generate Javadoc for build variant $name"
|
|
destinationDirectory =
|
|
file("${topobjdir}/mobile/android/geckoview/sources/${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 {
|
|
configDirectory = 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")
|
|
}
|
|
}
|
|
|
|
apply plugin: 'maven-publish'
|
|
|
|
version = getVersionNumber()
|
|
println("GeckoView version = " + version)
|
|
group = 'org.mozilla.geckoview'
|
|
|
|
def getArtifactId() {
|
|
def id = "geckoview" + project.ext.artifactSuffix
|
|
|
|
if (!mozconfig.substs.MOZ_ANDROID_GECKOVIEW_LITE) {
|
|
id += "-omni"
|
|
}
|
|
|
|
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.
|
|
id += "-${mozconfig.substs.ANDROID_CPU_ARCH}"
|
|
}
|
|
|
|
return id
|
|
}
|
|
|
|
publishing {
|
|
publications {
|
|
android.libraryVariants.all { variant ->
|
|
"${variant.name}"(MavenPublication) {
|
|
from components.findByName(variant.name)
|
|
|
|
pom {
|
|
afterEvaluate {
|
|
artifactId = getArtifactId()
|
|
}
|
|
|
|
url = 'https://geckoview.dev'
|
|
|
|
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/'
|
|
}
|
|
}
|
|
}
|
|
|
|
// Javadoc and sources for developer ergononomics.
|
|
artifact tasks["javadocJar${variant.name.capitalize()}"]
|
|
artifact tasks["sourcesJar${variant.name.capitalize()}"]
|
|
}
|
|
}
|
|
}
|
|
repositories {
|
|
maven {
|
|
url = "${topobjdir}/gradle/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.archiveFile
|
|
classpath project(':annotations').compileJava.classpath
|
|
classpath project(':annotations').sourceSets.main.runtimeClasspath
|
|
|
|
// 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",
|
|
]
|
|
|
|
mainClass = '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 29
|
|
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$',
|
|
'^org.mozilla.geckoview.R$',
|
|
]
|
|
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',
|
|
]
|
|
}
|