iceraven-browser/settings.gradle

/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

import org.yaml.snakeyaml.Yaml

pluginManagement {
    includeBuild("android-components/plugins/publicsuffixlist")
    includeBuild("android-components/plugins/dependencies")
}


buildscript {
    repositories {
        mavenCentral()
    }

    dependencies {
        classpath 'org.yaml:snakeyaml:1.33'
    }
}

plugins {
    id 'mozac.DependenciesPlugin'
}

include ':app'
include ':mozilla-detekt-rules'
include ':mozilla-lint-rules'

// Synchronized library configuration for all modules
// This "componentsVersion" number is defined in "version.txt" and should follow
// semantic versioning (MAJOR.MINOR.PATCH). See https://semver.org/
class Config {

    public final String componentsVersion
    public final String componentsGroupId
    public final Integer compileSdkVersion
    public final Integer minSdkVersion
    public final Integer targetSdkVersion

    Config(
            String componentsVersion,
            String componentsGroupId,
            Integer compileSdkVersion,
            Integer minSdkVersion,
            Integer targetSdkVersion
    ) {
        this.componentsVersion = componentsVersion
        this.componentsGroupId = componentsGroupId
        this.compileSdkVersion = compileSdkVersion
        this.minSdkVersion = minSdkVersion
        this.targetSdkVersion = targetSdkVersion
    }
}

def setupProject(name, path, description) {
    settings.include(":$name")

    project(":$name").projectDir = new File(rootDir, "android-components/${path}")

    // project(...) gives us a skeleton project that we can't set ext.* on
    gradle.beforeProject { project ->
        // However, the "afterProject" listener iterates over every project and gives us the actual project
        // So, once we filter for the project we care about, we can set whatever we want
        if (project.name == name) {
            project.ext.description = description
        }
    }
}

def yaml = new Yaml()
def buildconfig = yaml.load(new File(rootDir, 'android-components/.buildconfig.yml').newInputStream())

buildconfig.projects.each { project ->
    if (!project.key.startsWith("samples")) {
        setupProject(project.key, project.value.path, project.value.description)
    }
}

gradle.projectsLoaded { ->
    def componentsVersion = new File(rootDir, 'version.txt').text.stripTrailing()
    def configData = yaml.load(new File(rootDir, 'android-components/.config.yml').newInputStream())

    // Wait until root project is "loaded" before we set "config"
    // Note that since this is set on "rootProject.ext", it will be "in scope" during the evaluation of all projects'
    // gradle files. This means that they can just access "config.<value>", and it'll function properly
    gradle.rootProject.ext.config = new Config(
            componentsVersion,
            configData.componentsGroupId,
            configData.compileSdkVersion,
            configData.minSdkVersion,
            configData.targetSdkVersion
    )
    gradle.rootProject.ext.buildConfig = buildconfig

    // Disables A-C tests and lint when building Fenix.
    gradle.allprojects { project ->
        if (project.projectDir.absolutePath.contains("/android-components/")) {
            project.tasks.withType(Test) {
                enabled = false
            }
            project.tasks.whenTaskAdded { task ->
                if (task.name.contains("lint")) {
                    task.enabled = false
                }
            }
        }
    }
}

def log(message) {
    logger.lifecycle("[settings] ${message}")
}

def runCmd(cmd, workingDir, successMessage, captureStdout=true) {
    def proc = cmd.execute(null, new File(workingDir))
    def standardOutput = captureStdout ? new ByteArrayOutputStream() : System.out
    proc.consumeProcessOutput(standardOutput, System.err)
    proc.waitFor()

    if (proc.exitValue() != 0) {
        throw new GradleException("Process '${cmd}' finished with non-zero exit value ${proc.exitValue()}");
    } else {
        log(successMessage)
    }
    return captureStdout ? standardOutput : null
}

//////////////////////////////////////////////////////////////////////////
// Local Development overrides
//////////////////////////////////////////////////////////////////////////

Properties localProperties = null
String settingAppServicesPath = "autoPublish.application-services.dir"
String settingGleanPath = "autoPublish.glean.dir"

if (file('local.properties').canRead()) {
    localProperties = new Properties()
    localProperties.load(file('local.properties').newDataInputStream())
    log('Loaded local.properties')
} else {
    log('Missing local.properties; see https://github.com/mozilla-mobile/fenix/blob/main/README.md#local-properties-helpers for instructions.')
}

if (localProperties != null) {
    localProperties.each { prop ->
        gradle.ext.set("localProperties.${prop.key}", prop.value)
    }

    String appServicesLocalPath = localProperties.getProperty(settingAppServicesPath)

    if (appServicesLocalPath != null) {
        log("Enabling automatic publication of application-services from: $appServicesLocalPath")
        // Windows can't execute .py files directly, so we assume a "manually installed" python,
        // which comes with a "py" launcher and respects the shebang line to specify the version.
        def publishAppServicesCmd = [];
        if (System.properties['os.name'].toLowerCase().contains('windows')) {
            publishAppServicesCmd << "py";
        }
        publishAppServicesCmd << "./automation/publish_to_maven_local_if_modified.py";
        runCmd(publishAppServicesCmd, appServicesLocalPath, "Published application-services for local development.", false)
    } else {
        log("Disabled auto-publication of application-services. Enable it by settings '$settingAppServicesPath' in local.properties")
    }

    String gleanLocalPath = localProperties.getProperty(settingGleanPath)

    if (gleanLocalPath != null) {
        log("Enabling automatic publication of Glean from: $gleanLocalPath")
        // As above, hacks to execute .py files on Windows.
        def publishGleanCmd = [];
        if (System.properties['os.name'].toLowerCase().contains('windows')) {
            publishGleanCmd << "py";
        }
        publishGleanCmd << "./build-scripts/publish_to_maven_local_if_modified.py";
        runCmd(publishGleanCmd, gleanLocalPath, "Published Glean for local development.", false)
    } else {
        log("Disabled auto-publication of Glean. Enable it by settings '$settingGleanPath' in local.properties")
    }
}