build.gradle

   1 import org.tomlj.Toml
   2 import org.tomlj.TomlParseResult
   3 import org.tomlj.TomlTable
   4
   5 def tryInt = { string ->
   6     if (string == null) {
   7         return string
   8     }
   9     if (string.isInteger()) {
  10         return string as Integer
  11     }
  12     return string
  13 }
  14
  15 // Parses the Cargo.lock and returns the version for the given package name.
  16 def getRustVersionFor(packageName) {
  17     String version = null;
  18     TomlParseResult result = Toml.parse(file("Cargo.lock").getText());
  19     for (object in result.getArray("package").toList()) {
  20         def table = (TomlTable) object
  21         if (table.getString("name") == packageName) {
  22             if (version != null) {
  23                 throw new StopExecutionException("Multiple versions for '${packageName}' found." +
  24                         " Ensure '${packageName}' is only included once.")
  25             }
  26             version = table.getString("version")
  27         }
  28     }
  29     return version
  30 }
  31
  32 allprojects {
  33     // Expose the per-object-directory configuration to all projects.
  34     ext {
  35         mozconfig = gradle.mozconfig
  36         topsrcdir = gradle.mozconfig.topsrcdir
  37         topobjdir = gradle.mozconfig.topobjdir
  38
  39         gleanVersion = "51.5.0"
  40         if (gleanVersion != getRustVersionFor("glean")) {
  41           throw new StopExecutionException("Mismatched Glean version, expected: ${gleanVersion}," +
  42               " found ${getRustVersionFor("glean")}")
  43         }
  44
  45         artifactSuffix = getArtifactSuffix()
  46         versionName = getVersionName()
  47         versionCode = computeVersionCode()
  48         versionNumber = getVersionNumber()
  49         buildId = getBuildId()
  50
  51         buildToolsVersion = mozconfig.substs.ANDROID_BUILD_TOOLS_VERSION
  52         compileSdkVersion = tryInt(mozconfig.substs.ANDROID_TARGET_SDK)
  53         targetSdkVersion = tryInt(mozconfig.substs.ANDROID_TARGET_SDK)
  54         minSdkVersion = tryInt(mozconfig.substs.MOZ_ANDROID_MIN_SDK_VERSION)
  55         manifestPlaceholders = [
  56             ANDROID_PACKAGE_NAME: mozconfig.substs.ANDROID_PACKAGE_NAME,
  57             ANDROID_TARGET_SDK: mozconfig.substs.ANDROID_TARGET_SDK,
  58             MOZ_ANDROID_MIN_SDK_VERSION: mozconfig.substs.MOZ_ANDROID_MIN_SDK_VERSION,
  59         ]
  60     }
  61
  62     repositories {
  63         gradle.mozconfig.substs.GRADLE_MAVEN_REPOSITORIES.each { repository ->
  64             maven {
  65                 url repository
  66                 if (gradle.mozconfig.substs.ALLOW_INSECURE_GRADLE_REPOSITORIES) {
  67                     allowInsecureProtocol = true
  68                 }
  69             }
  70         }
  71     }
  72
  73     task downloadDependencies() {
  74         description 'Download all dependencies to the Gradle cache'
  75         doLast {
  76             configurations.each { configuration ->
  77                 if (configuration.canBeResolved) {
  78                     configuration.allDependencies.each { dependency ->
  79                         try {
  80                             configuration.files(dependency)
  81                         } catch(e) {
  82                             println("Could not resolve ${configuration.name} -> ${dependency.name}")
  83                             println(" > ${e.message}")
  84                             if (e.cause) {
  85                                 println(" >> ${e.cause}")
  86                                 if (e.cause.cause) {
  87                                     println(" >> ${e.cause.cause}")
  88                                 }
  89                             }
  90                             println("")
  91                         }
  92                     }
  93                 }
  94             }
  95         }
  96     }
  97 }
  98
  99 buildDir "${topobjdir}/gradle/build"
 100
 101 buildscript {
 102     repositories {
 103         gradle.mozconfig.substs.GRADLE_MAVEN_REPOSITORIES.each { repository ->
 104             maven {
 105                 url repository
 106                 if (gradle.mozconfig.substs.ALLOW_INSECURE_GRADLE_REPOSITORIES) {
 107                     allowInsecureProtocol = true
 108                 }
 109             }
 110         }
 111     }
 112
 113     ext.kotlin_version = '1.7.20'
 114
 115     dependencies {
 116         classpath 'org.mozilla.apilint:apilint:0.5.2'
 117         classpath 'com.android.tools.build:gradle:7.3.0'
 118         classpath 'org.apache.commons:commons-exec:1.3'
 119         classpath 'com.diffplug.spotless:spotless-plugin-gradle:6.10.0'
 120         classpath 'org.tomlj:tomlj:1.0.0'
 121         classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
 122     }
 123 }
 124
 125 // A stream that processes bytes line by line, prepending a tag before sending
 126 // each line to Gradle's logging.
 127 class TaggedLogOutputStream extends org.apache.commons.exec.LogOutputStream {
 128     String tag
 129     Logger logger
 130
 131     TaggedLogOutputStream(tag, logger) {
 132         this.tag = tag
 133         this.logger = logger
 134     }
 135
 136     void processLine(String line, int level) {
 137         logger.lifecycle("${this.tag} ${line}")
 138     }
 139 }
 140
 141 ext.geckoBinariesOnlyIf = { task ->
 142     // Never when Gradle was invoked within `mach build`.
 143     if ('1' == System.env.GRADLE_INVOKED_WITHIN_MACH_BUILD) {
 144         rootProject.logger.lifecycle("Skipping task ${task.path} because: within `mach build`")
 145         return false
 146     }
 147
 148     // Never for official builds.
 149     if (mozconfig.substs.MOZILLA_OFFICIAL) {
 150         rootProject.logger.lifecycle("Skipping task ${task.path} because: MOZILLA_OFFICIAL")
 151         return false
 152     }
 153
 154     // Multi-l10n builds set `AB_CD=multi`, which isn't a valid locale.  To
 155     // avoid failures, if Gradle is invoked with AB_CD=multi, we don't invoke
 156     // Make at all.
 157     if ('multi' == System.env.AB_CD) {
 158         rootProject.logger.lifecycle("Skipping task ${task.path} because: AB_CD=multi")
 159         return false
 160     }
 161
 162     // Single-locale l10n repacks set `IS_LANGUAGE_REPACK=1` and handle resource
 163     // and code generation themselves.
 164     if ('1' == System.env.IS_LANGUAGE_REPACK) {
 165         rootProject.logger.lifecycle("Skipping task ${task.path} because: IS_LANGUAGE_REPACK")
 166         return false
 167     }
 168
 169     rootProject.logger.lifecycle("Executing task ${task.path}")
 170     return true
 171 }
 172
 173 // Non-official versions are like "61.0a1", where "a1" is the milestone.
 174 // This simply strips that off, leaving "61.0" in this example.
 175 def getAppVersionWithoutMilestone() {
 176     return project.ext.mozconfig.substs.MOZ_APP_VERSION.replaceFirst(/a[0-9]/, "")
 177 }
 178
 179 // This converts MOZ_APP_VERSION into an integer
 180 // version code.
 181 //
 182 // We take something like 58.1.2a1 and come out with 5800102
 183 // This gives us 3 digits for the major number, and 2 digits
 184 // each for the minor and build number. Beta and Release
 185 //
 186 // This must be synchronized with _compute_gecko_version(...) in /taskcluster/gecko_taskgraph/transforms/task.py
 187 def computeVersionCode() {
 188     String appVersion = getAppVersionWithoutMilestone()
 189
 190     // Split on the dot delimiter, e.g. 58.1.1a1 -> ["58, "1", "1a1"]
 191     String[] parts = appVersion.split('\\.')
 192
 193     assert parts.size() == 2 || parts.size() == 3
 194
 195     // Major
 196     int code = Integer.parseInt(parts[0]) * 100000
 197
 198     // Minor
 199     code += Integer.parseInt(parts[1]) * 100
 200
 201     // Build
 202     if (parts.size() == 3) {
 203         code += Integer.parseInt(parts[2])
 204     }
 205
 206     return code;
 207 }
 208
 209 def getVersionName() {
 210     return "${mozconfig.substs.MOZ_APP_VERSION}-${mozconfig.substs.MOZ_UPDATE_CHANNEL}"
 211 }
 212
 213 // Mimic Python: open(os.path.join(buildconfig.topobjdir, 'buildid.h')).readline().split()[2]
 214 def getBuildId() {
 215     return file("${topobjdir}/buildid.h").getText('utf-8').split()[2]
 216 }
 217
 218 def getVersionNumber() {
 219     def appVersion = getAppVersionWithoutMilestone()
 220     def parts = appVersion.split('\\.')
 221     def version = parts[0] + "." + parts[1] + "." + getBuildId()
 222     def substs = project.ext.mozconfig.substs
 223     if (!substs.MOZILLA_OFFICIAL && !substs.MOZ_ANDROID_FAT_AAR_ARCHITECTURES) {
 224         // Use -SNAPSHOT versions locally to enable the local GeckoView substitution flow.
 225         version += "-SNAPSHOT"
 226     }
 227     return version
 228 }
 229
 230 def getArtifactSuffix() {
 231     def substs = project.ext.mozconfig.substs
 232
 233     def suffix = ""
 234     // Release artifacts don't specify the channel, for the sake of simplicity.
 235     if (substs.MOZ_UPDATE_CHANNEL != 'release') {
 236         suffix += "-${mozconfig.substs.MOZ_UPDATE_CHANNEL}"
 237     }
 238
 239     return suffix
 240 }
 241
 242 class MachExec extends Exec {
 243     def MachExec() {
 244         // Bug 1543982: When invoking `mach build` recursively, the outer `mach
 245         // build` itself modifies the environment, causing configure to run
 246         // again.  This tries to restore the environment that the outer `mach
 247         // build` was invoked in.  See the comment in
 248         // $topsrcdir/settings.gradle.
 249         project.ext.mozconfig.mozconfig.env.unmodified.each { k, v -> environment.remove(k) }
 250         environment project.ext.mozconfig.orig_mozconfig.env.unmodified
 251         environment 'MOZCONFIG', project.ext.mozconfig.substs.MOZCONFIG
 252     }
 253 }
 254
 255 task machBuildFaster(type: MachExec) {
 256     onlyIf rootProject.ext.geckoBinariesOnlyIf
 257
 258     workingDir "${topsrcdir}"
 259
 260     commandLine mozconfig.substs.PYTHON3
 261     args "${topsrcdir}/mach"
 262     args 'build'
 263     args 'faster'
 264
 265     // Add `-v` if we're running under `--info` (or `--debug`).
 266     if (project.logger.isEnabled(LogLevel.INFO)) {
 267         args '-v'
 268     }
 269
 270     // `path` is like `:machBuildFaster`.
 271     standardOutput = new TaggedLogOutputStream("${path}>", logger)
 272     errorOutput = standardOutput
 273 }
 274
 275 task machStagePackage(type: MachExec) {
 276     onlyIf rootProject.ext.geckoBinariesOnlyIf
 277
 278     dependsOn rootProject.machBuildFaster
 279
 280     workingDir "${topobjdir}"
 281
 282     // We'd prefer this to be a `mach` invocation, but `mach build
 283     // mobile/android/installer/stage-package` doesn't work as expected.
 284     commandLine mozconfig.substs.GMAKE
 285     args '-C'
 286     args "${topobjdir}/mobile/android/installer"
 287     args 'stage-package'
 288
 289     outputs.file "${topobjdir}/dist/geckoview/assets/omni.ja"
 290
 291     outputs.file "${topobjdir}/dist/geckoview/assets/${mozconfig.substs.ANDROID_CPU_ARCH}/libxul.so"
 292     outputs.file "${topobjdir}/dist/geckoview/lib/${mozconfig.substs.ANDROID_CPU_ARCH}/libmozglue.so"
 293
 294     // Force running `stage-package`.
 295     outputs.upToDateWhen { false }
 296
 297     // `path` is like `:machStagePackage`.
 298     standardOutput = new TaggedLogOutputStream("${path}>", logger)
 299     errorOutput = standardOutput
 300 }
 301
 302 afterEvaluate {
 303     subprojects { project ->
 304         tasks.withType(JavaCompile) {
 305             // Add compiler args for all code except third-party code.
 306             options.compilerArgs += [
 307                 // Turn on all warnings, except...
 308                 "-Xlint:all",
 309                 // Deprecation, because we do use deprecated API for compatibility.
 310                 "-Xlint:-deprecation",
 311                 // Serial, because we don't use Java serialization.
 312                 "-Xlint:-serial",
 313                 // Classfile, because javac has a bug with MethodParameters attributes
 314                 // with Java 7. https://bugs.openjdk.java.net/browse/JDK-8190452
 315                 "-Xlint:-classfile",
 316                 // Turn all remaining warnings into errors,
 317                 // unless marked by @SuppressWarnings.
 318                 "-Werror"]
 319         }
 320     }
 321 }
 322
 323 apply plugin: 'idea'
 324
 325 idea {
 326     project {
 327         languageLevel = '1.8'
 328     }
 329
 330     module {
 331         // Object directories take a huge amount of time for IntelliJ to index.
 332         // Exclude them.  Convention is that object directories start with obj.
 333         // IntelliJ is clever and will not exclude the parts of the object
 334         // directory that are referenced, if there are any.  In practice,
 335         // indexing the entirety of the tree is taking too long, so exclude all
 336         // but mobile/.
 337         def topsrcdirURI = file(topsrcdir).toURI()
 338         excludeDirs += files(file(topsrcdir)
 339             .listFiles({it.isDirectory()} as FileFilter)
 340             .collect({topsrcdirURI.relativize(it.toURI()).toString()}) // Relative paths.
 341             .findAll({!it.equals('mobile/')}))
 342
 343         // If topobjdir is below topsrcdir, hide only some portions of that tree.
 344         def topobjdirURI = file(topobjdir).toURI()
 345         if (!topsrcdirURI.relativize(topobjdirURI).isAbsolute()) {
 346             excludeDirs -= file(topobjdir)
 347             excludeDirs += files(file(topobjdir).listFiles())
 348             excludeDirs -= file("${topobjdir}/gradle")
 349         }
 350     }
 351 }
 352
 353 subprojects {
 354     apply plugin: "com.diffplug.spotless"
 355
 356     spotless {
 357         java {
 358             target project.fileTree(project.projectDir) {
 359                 include '**/*.java'
 360                 exclude '**/thirdparty/**'
 361             }
 362             googleJavaFormat('1.15.0')
 363         }
 364     }
 365 }