tor-browser

build.gradle (20018B)

---

import org.gradle.api.services.BuildServiceParameters
import org.tomlj.Toml
import org.tomlj.TomlParseResult
import org.tomlj.TomlTable

buildscript {
   repositories {
       mavenLocal()

       gradle.mozconfig.substs.GRADLE_MAVEN_REPOSITORIES.each { repository ->
           maven {
               url = repository
               if (gradle.mozconfig.substs.ALLOW_INSECURE_GRADLE_REPOSITORIES) {
                   allowInsecureProtocol = true
               }
           }
       }
   }

   dependencies {
       classpath libs.android.gradle.plugin
       classpath libs.tomlj

       // Used in mobile/android/fenix/app/build.gradle
       classpath libs.androidx.benchmark.gradle
       classpath libs.androidx.navigation.safeargs
       classpath libs.osslicenses.plugin
       classpath libs.mozilla.glean.gradle.plugin
   }
}

plugins {
   id 'ApkSizePlugin'
   id "mozac.ConfigPlugin"
   alias(libs.plugins.detekt)
   alias(libs.plugins.kotlin.android) apply false
   alias(libs.plugins.kotlin.compose) apply false
   alias(libs.plugins.ksp)
   alias(libs.plugins.spotless)
}

def tryInt = { string ->
   if (string == null) {
       return string
   }
   if (string.isInteger()) {
       return string as Integer
   }
   return string
}

abstract class VerifyGleanVersionTask extends DefaultTask {
   @InputFile
   final RegularFileProperty source = project.objects.fileProperty().convention(project.layout.projectDirectory.file("Cargo.lock"))

   @Input
   String expectedVersion = project.ext.gleanVersion

   @OutputFile
   final RegularFileProperty outputFile = project.objects.fileProperty()

   @TaskAction
   void verifyGleanVersion() {
       def foundVersion = getRustVersionFor(source.get().asFile, "glean")
       if (expectedVersion != foundVersion) {
         throw new GradleException("Mismatched Glean version, expected: '${expectedVersion}'," +
             " found '${foundVersion}'")
       } else {
           logger.lifecycle("verifyGleanVersion> expected version matches found version '${foundVersion}'")
       }

       outputFile.get().asFile.text = "glean-${foundVersion}"
   }

   // Parses the Cargo.lock and returns the version for the given package name.
   static String getRustVersionFor(file, packageName) {
       String version = null;
       TomlParseResult result = Toml.parse(file.getText());
       for (object in result.getArray("package").toList()) {
           def table = (TomlTable) object
           if (table.getString("name") == packageName) {
               if (version != null) {
                   throw new GradleException("Multiple versions for '${packageName}' found." +
                                                    " Ensure '${packageName}' is only included once.")
               }
               version = table.getString("version")
           }
       }
       return version
   }
}

tasks.register("verifyGleanVersion", VerifyGleanVersionTask) {
   outputFile.convention(layout.buildDirectory.file("glean/verifyGleanVersion.marker"))
}

allprojects {
   // Expose the per-object-directory configuration to all projects.
   ext {
       mozconfig = gradle.mozconfig
       topsrcdir = gradle.mozconfig.topsrcdir
       topobjdir = gradle.mozconfig.topobjdir

       gleanVersion = libs.versions.glean.get() // Verification done in verifyGleanVersion task

       artifactSuffix = getArtifactSuffix()
       versionName = getVersionName()
       versionCode = computeVersionCode()
       versionNumber = getVersionNumber()
       buildId = getBuildId()

       buildToolsVersion = mozconfig.substs.ANDROID_BUILD_TOOLS_VERSION
       compileSdkMajorVersion = tryInt(mozconfig.substs.ANDROID_COMPILE_SDK_MAJOR)
       compileSdkMinorVersion = tryInt(mozconfig.substs.ANDROID_COMPILE_SDK_MINOR)
       minSdkVersion = tryInt(mozconfig.substs.MOZ_ANDROID_MIN_SDK_VERSION)
       targetSdkVersion = tryInt(mozconfig.substs.ANDROID_TARGET_SDK)
       manifestPlaceholders = [
           ANDROID_TARGET_SDK: mozconfig.substs.ANDROID_TARGET_SDK,
           MOZ_ANDROID_MIN_SDK_VERSION: mozconfig.substs.MOZ_ANDROID_MIN_SDK_VERSION,
       ]
   }

   afterEvaluate {
       if (it.hasProperty('android')) {
           android {
               buildToolsVersion gradle.mozconfig.substs.ANDROID_BUILD_TOOLS_VERSION
               testOptions {
                   unitTests.includeAndroidResources = true
               }
           }
       }
   }

   repositories {
       mavenLocal()

       gradle.mozconfig.substs.GRADLE_MAVEN_REPOSITORIES.each { repository ->
           maven {
               url = repository
               if (gradle.mozconfig.substs.ALLOW_INSECURE_GRADLE_REPOSITORIES) {
                   allowInsecureProtocol = true
               }
           }
       }
   }

   // Use the semanticdb-javac and semanticdb-kotlinc plugins to generate semanticdb files for Searchfox
   if (mozconfig.substs.ENABLE_MOZSEARCH_PLUGIN || mozconfig.substs.DOWNLOAD_ALL_GRADLE_DEPENDENCIES) {
       def targetRoot = new File(topobjdir, "mozsearch_java_index")

       afterEvaluate {
           def addDependencyToConfigurationIfExists = { configurationName, dependency ->
               def configuration = configurations.findByName(configurationName)
               if (configuration != null) {
                   dependencies.add(configurationName, dependency)
               }
           }

           addDependencyToConfigurationIfExists("compileOnly", libs.semanticdb.java)
           addDependencyToConfigurationIfExists("testCompileOnly", libs.semanticdb.java)
           addDependencyToConfigurationIfExists("androidTestCompileOnly", libs.semanticdb.java)
           addDependencyToConfigurationIfExists("kotlinCompilerPluginClasspath", libs.semanticdb.kotlin)
       }

       tasks.withType(JavaCompile) {
           options.compilerArgs += [
               "-Xplugin:semanticdb -sourceroot:${topsrcdir} -targetroot:${targetRoot}",
           ]
       }

       tasks.withType(org.jetbrains.kotlin.gradle.tasks.KotlinCompile) {
           compilerOptions.freeCompilerArgs.addAll([
               "-P", "plugin:semanticdb-kotlinc:sourceroot=${topsrcdir}".toString(),
               "-P", "plugin:semanticdb-kotlinc:targetroot=${targetRoot}".toString(),
           ])
       }
   }
}

abstract class MozconfigService implements BuildService<MozconfigService.Params>, AutoCloseable {
   interface Params extends BuildServiceParameters {
       MapProperty<String, Object> getMozconfigParam()
   }

   void close() {
   }

   Object getMozconfig() {
       return parameters.mozconfigParam.get()
   }
}

// Non-official versions are like "61.0a1" or "61.0b1", where "a1" and "b1"
// are the milestone.
// This simply strips that off, leaving "61.0" in this example.
def getAppVersionWithoutMilestone() {
   return project.ext.mozconfig.substs.MOZ_APP_VERSION.replaceFirst(/[ab][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/gecko_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 getVersionName() {
   return "${mozconfig.substs.MOZ_APP_VERSION}-${mozconfig.substs.MOZ_UPDATE_CHANNEL}"
}

// 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]
}

def getVersionNumber() {
   def appVersion = getAppVersionWithoutMilestone()
   def parts = appVersion.split('\\.')
   def version = parts[0] + "." + parts[1] + "." + getBuildId()
   def substs = project.ext.mozconfig.substs
   if (!substs.MOZILLA_OFFICIAL && !substs.MOZ_ANDROID_FAT_AAR_ARCHITECTURES) {
       // Use -SNAPSHOT versions locally to enable the local GeckoView substitution flow.
       version += "-SNAPSHOT"
   }
   return version
}

def getArtifactSuffix() {
   def substs = project.ext.mozconfig.substs

   def suffix = ""
   // Release artifacts don't specify the channel, for the sake of simplicity.
   if (substs.MOZ_UPDATE_CHANNEL != 'release') {
       suffix += "-${mozconfig.substs.MOZ_UPDATE_CHANNEL}"
   }

   return suffix
}

abstract class MachExec extends Exec {
   def MachExec() {
       // Bug 1543982: When invoking `mach build` recursively, the outer `mach
       // build` itself modifies the environment, causing configure to run
       // again.  This tries to restore the environment that the outer `mach
       // build` was invoked in.  See the comment in
       // $topsrcdir/settings.gradle.
       project.ext.mozconfig.mozconfig.env.unmodified.each { k, v -> environment.remove(k) }
       environment project.ext.mozconfig.orig_mozconfig.env.unmodified
       environment 'MOZCONFIG', project.ext.mozconfig.substs.MOZCONFIG
   }

   static def geckoBinariesOnlyIf(task, mozconfig) {
       // Never when Gradle was invoked within `mach build`.
       if ('1' == System.env.GRADLE_INVOKED_WITHIN_MACH_BUILD) {
           task.logger.lifecycle("Skipping task ${task.path} because: within `mach build`")
           return false
       }

       // Never for official builds.
       if (mozconfig.substs.MOZILLA_OFFICIAL) {
           task.logger.lifecycle("Skipping task ${task.path} because: MOZILLA_OFFICIAL")
           return false
       }
       if (mozconfig.substs.ENABLE_MOZSEARCH_PLUGIN) {
           task.logger.lifecycle("Skipping task ${task.path} because: ENABLE_MOZSEARCH_PLUGIN")
           return false
       }

       // Multi-l10n builds set `AB_CD=multi`, which isn't a valid locale, and
       // `MOZ_CHROME_MULTILOCALE`.  To avoid failures, if Gradle is invoked with
       // either, we don't invoke Make at all; this allows a multi-locale omnijar
       // to be consumed without modification.
       if ('multi' == System.env.AB_CD || System.env.MOZ_CHROME_MULTILOCALE) {
           task.logger.lifecycle("Skipping task ${task.path} because: AB_CD=multi")
           return false
       }

       // Single-locale l10n repacks set `IS_LANGUAGE_REPACK=1` and handle resource
       // and code generation themselves.
       if ('1' == System.env.IS_LANGUAGE_REPACK) {
           task.logger.lifecycle("Skipping task ${task.path} because: IS_LANGUAGE_REPACK")
           return false
       }

       task.logger.lifecycle("Executing task ${task.path}")
       return true
   }
}

task machBuildFaster(type: MachExec) {
   def mozconfigProvider = gradle.sharedServices.registerIfAbsent("mozconfig", MozconfigService) {
       parameters.mozconfigParam.set(project.ext.mozconfig)
   }
   usesService(mozconfigProvider)
   onlyIf { task -> MachExec.geckoBinariesOnlyIf(task, mozconfigProvider.get().getMozconfig()) }

   workingDir "${topsrcdir}"

   commandLine mozconfig.substs.PYTHON3
   args "${topsrcdir}/mach"
   args 'build'
   args 'faster'

   // Add `-v` if we're running under `--info` (or `--debug`).
   if (project.logger.isEnabled(LogLevel.INFO)) {
       args '-v'
   }

   standardOutput = System.out
   errorOutput = System.err
}

task machStagePackage(type: MachExec) {
   def mozconfigProvider = gradle.sharedServices.registerIfAbsent("mozconfig", MozconfigService) {
       parameters.mozconfigParam.set(project.ext.mozconfig)
   }
   usesService(mozconfigProvider)
   onlyIf { task -> MachExec.geckoBinariesOnlyIf(task, mozconfigProvider.get().getMozconfig()) }
   dependsOn rootProject.machBuildFaster

   workingDir "${topobjdir}"

   commandLine mozconfig.substs.PYTHON3
   args "${topsrcdir}/mach"
   args 'build'
   args 'stage-package'

   outputs.file "${topobjdir}/dist/geckoview/assets/omni.ja"

   outputs.file "${topobjdir}/dist/geckoview/assets/${mozconfig.substs.ANDROID_CPU_ARCH}/libxul.so"
   outputs.file "${topobjdir}/dist/geckoview/lib/${mozconfig.substs.ANDROID_CPU_ARCH}/libmozglue.so"

   // Force running `stage-package`.
   outputs.upToDateWhen { false }

   standardOutput = System.out
   errorOutput = System.err
}

afterEvaluate {
   subprojects { project ->
       tasks.withType(JavaCompile) {
           // Add compiler args for all code except third-party code.
           options.compilerArgs += [
               // Turn on all warnings, except...
               "-Xlint:all",
               // Deprecation, because we do use deprecated API for compatibility.
               "-Xlint:-deprecation",
               // Serial, because we don't use Java serialization.
               "-Xlint:-serial",
               // Classfile, because javac has a bug with MethodParameters attributes
               // with Java 7. https://bugs.openjdk.java.net/browse/JDK-8190452
               "-Xlint:-classfile"]

           // In GeckoView java projects only, turn all remaining warnings
           // into errors unless marked by @SuppressWarnings.
           def projectName = project.getName()
           if (projectName.startsWith('geckoview')
               || projectName == 'annotations'
               || projectName == 'exoplayer2'
               || projectName == 'messaging_example'
               || projectName == 'port_messaging_example'
               || projectName == 'test_runner'
           ) {
               options.compilerArgs += [
                       "-Werror"
               ]
           }
       }

       project.configurations.configureEach {
           // Dependencies can't depend on a different major version of Glean than A-C itself.
           resolutionStrategy.eachDependency { details ->
               if (details.requested.group == 'org.mozilla.telemetry'
                       && details.requested.name.contains('glean') ) {
                   def requested = details.requested.version.tokenize(".")
                       def defined = project.ext.gleanVersion.tokenize(".")
                       // Check the major version
                       if (requested[0] != defined[0]) {
                           throw new AssertionError("Cannot resolve to a single Glean version. Requested: ${details.requested.version}, A-C uses: ${libs.mozilla.glean}")
                       } else {
                           // Enforce that all (transitive) dependencies are using the defined Glean version
                           details.useVersion project.ext.gleanVersion
                       }
               }
           }

           resolutionStrategy.capabilitiesResolution.withCapability("org.mozilla.telemetry:glean-native") {
               def toBeSelected = candidates.find { it.id instanceof ModuleComponentIdentifier && it.id.module.contains('geckoview') }
               if (toBeSelected != null) {
                   select(toBeSelected)
               }
               because 'use GeckoView Glean instead of standalone Glean'
           }
       }
   }
}

apply plugin: 'idea'

idea {
   project {
       languageLevel = '1.8'
   }

   module {
       // Object directories take a huge amount of time for IntelliJ to index.
       // Exclude them.  Convention is that object directories start with obj.
       // IntelliJ is clever and will not exclude the parts of the object
       // directory that are referenced, if there are any.  In practice,
       // indexing the entirety of the tree is taking too long, so exclude all
       // but mobile/.
       def topsrcdirURI = file(topsrcdir).toURI()
       excludeDirs += files(file(topsrcdir)
           .listFiles({it.isDirectory()} as FileFilter)
           .collect({topsrcdirURI.relativize(it.toURI()).toString()}) // Relative paths.
           .findAll({!it.equals('mobile/')}))

       // If topobjdir is below topsrcdir, hide only some portions of that tree.
       def topobjdirURI = file(topobjdir).toURI()
       if (!topsrcdirURI.relativize(topobjdirURI).isAbsolute()) {
           excludeDirs -= file(topobjdir)
           excludeDirs += files(file(topobjdir).listFiles())
           excludeDirs -= file("${topobjdir}/gradle")
       }
   }
}

subprojects { project ->
   // Perform spotless lint in GeckoView projects only.
   // Sync with spotless_projects in mobile/android/geckoview/gradle.configure.
   def projectName = project.getName()
   if (projectName.startsWith('geckoview')
           || projectName == 'annotations'
           || projectName == 'exoplayer2'
           || projectName == 'messaging_example'
           || projectName == 'port_messaging_example'
           || projectName == 'test_runner'
   ) {
       apply plugin: "com.diffplug.spotless"

       spotless {
           lineEndings = com.diffplug.spotless.LineEnding.UNIX
           java {
               target project.fileTree(project.projectDir) {
                   include '**/*.java'
                   exclude '**/thirdparty/**'
               }
               googleJavaFormat(libs.versions.google.java.format.get())
           }
           kotlin {
               target project.fileTree(project.projectDir) {
                   include '**/*.kt'
                   exclude '**/thirdparty/**'
               }
               ktlint("${libs.versions.ktlint.get()}").setEditorConfigPath("${topsrcdir}/mobile/android/geckoview/.editorconfig")
           }
       }

       // Work around https://github.com/diffplug/spotless/issues/1958 by
       // explicitly depending on Spotless plugin dependencies.
       project.configurations {
           googleJavaFormat
       }

       project.dependencies {
           googleJavaFormat libs.google.java.format
       }
   }

   afterEvaluate {
       // Our vendored copy of exoplayer2 hits build failures when targeting Java 17.
       // Given our intent to remove it in the near future, just leave it alone here.
       if (it.hasProperty('android') && projectName != 'exoplayer2') {
           kotlin {
               jvmToolchain(config.jvmTargetCompatibility)
           }
       }

       if (it.hasProperty('android')
               && (project.projectDir.absolutePath.contains("android-components")
               || projectName == "fenix"
               || projectName == "focus-android")
       ) {
           dependencies {
               lintChecks project.project(':components:tooling-lint')
           }

           android {
               // Copied from subbproject's build.gradle
               lint {
                   baseline = file("${project.projectDir}/lint-baseline.xml")
               }
           }
       }
   }

   project.configurations.configureEach {
       resolutionStrategy.capabilitiesResolution.withCapability("org.mozilla.telemetry:glean-native") {
           def toBeSelected = candidates.find {
               it.id instanceof ProjectComponentIdentifier && it.id.projectName.contains('geckoview')
           }
           if (toBeSelected != null) {
               select(toBeSelected)
           }
           because 'use GeckoView Glean instead of standalone Glean'
       }
   }
}

tasks.register("lint-a-c") {
   subprojects.each{
       if (it.tasks.findByName("lint") != null && it.projectDir.absolutePath.contains("android-components")) {
           dependsOn it.tasks.named("lint")
       }
   }
}