mirror of
https://github.com/flutter/flutter
synced 2024-09-19 16:21:58 +00:00
118c2df776
Context: https://github.com/flutter/flutter/issues/131862 This PR injects a "realm" component to the storage base URL when the contents of the file `bin/internal/engine.realm` is non-empty. As documented in the PR, when the realm is `flutter_archives_v2`, and `bin/internal/engine.version` contains the commit hash for a commit in a `flutter/engine` PR, then the artifacts pulled by the tool will be the artifacts built by the presubmit checks for the PR. This works for everything but the following two cases: 1. Fuchsia artifacts are not uploaded to CIPD by the Fuchsia presubmit builds. 2. Web artifacts are not uploaded to gstatic by the web engine presubmit builds. For (1), the flutter/flutter presubmit `fuchsia_precache` is driven by a shell script outside of the repo. It will fail when the `engine.version` and `engine.realm` don't point to a post-submit engine commit. For (2), the flutter/flutter web presubmit tests that refer to artifacts in gstatic hang when the artifacts aren't found, so this PR skips them.
152 lines
5.8 KiB
Groovy
152 lines
5.8 KiB
Groovy
// This script is used to initialize the build in a module or plugin project.
|
|
// During this phase, the script applies the Maven plugin and configures the
|
|
// destination of the local repository.
|
|
// The local repository will contain the AAR and POM files.
|
|
|
|
import java.nio.file.Paths
|
|
import org.gradle.api.Project
|
|
import org.gradle.api.artifacts.Configuration
|
|
import org.gradle.api.publish.maven.MavenPublication
|
|
|
|
void configureProject(Project project, String outputDir) {
|
|
if (!project.hasProperty("android")) {
|
|
throw new GradleException("Android property not found.")
|
|
}
|
|
if (!project.android.hasProperty("libraryVariants")) {
|
|
throw new GradleException("Can't generate AAR on a non Android library project.");
|
|
}
|
|
|
|
// Snapshot versions include the timestamp in the artifact name.
|
|
// Therefore, remove the snapshot part, so new runs of `flutter build aar` overrides existing artifacts.
|
|
// This version isn't relevant in Flutter since the pub version is used
|
|
// to resolve dependencies.
|
|
project.version = project.version.replace("-SNAPSHOT", "")
|
|
|
|
if (project.hasProperty("buildNumber")) {
|
|
project.version = project.property("buildNumber")
|
|
}
|
|
|
|
project.components.forEach { component ->
|
|
if (component.name != "all") {
|
|
addAarTask(project, component)
|
|
}
|
|
}
|
|
|
|
project.publishing {
|
|
repositories {
|
|
maven {
|
|
url = uri("file://${outputDir}/outputs/repo")
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!project.property("is-plugin").toBoolean()) {
|
|
return
|
|
}
|
|
|
|
String storageUrl = System.getenv('FLUTTER_STORAGE_BASE_URL') ?: "https://storage.googleapis.com"
|
|
|
|
String engineRealm = Paths.get(getFlutterRoot(project), "bin", "internal", "engine.realm")
|
|
.toFile().text.trim()
|
|
if (engineRealm) {
|
|
engineRealm = engineRealm + "/"
|
|
}
|
|
|
|
// This is a Flutter plugin project. Plugin projects don't apply the Flutter Gradle plugin,
|
|
// as a result, add the dependency on the embedding.
|
|
project.repositories {
|
|
maven {
|
|
url "$storageUrl/${engineRealm}download.flutter.io"
|
|
}
|
|
}
|
|
String engineVersion = Paths.get(getFlutterRoot(project), "bin", "internal", "engine.version")
|
|
.toFile().text.trim()
|
|
project.dependencies {
|
|
// Add the embedding dependency.
|
|
compileOnly ("io.flutter:flutter_embedding_release:1.0.0-$engineVersion") {
|
|
// We only need to expose io.flutter.plugin.*
|
|
// No need for the embedding transitive dependencies.
|
|
transitive = false
|
|
}
|
|
}
|
|
}
|
|
|
|
void configurePlugin(Project project, String outputDir) {
|
|
if (!project.hasProperty("android")) {
|
|
// A plugin doesn't support the Android platform when this property isn't defined in the plugin.
|
|
return
|
|
}
|
|
configureProject(project, outputDir)
|
|
}
|
|
|
|
String getFlutterRoot(Project project) {
|
|
if (!project.hasProperty("flutter-root")) {
|
|
throw new GradleException("The `-Pflutter-root` flag must be specified.")
|
|
}
|
|
return project.property("flutter-root")
|
|
}
|
|
|
|
void addAarTask(Project project, component) {
|
|
String variantName = component.name.capitalize()
|
|
String taskName = "assembleAar$variantName"
|
|
project.tasks.create(name: taskName) {
|
|
// This check is required to be able to configure the archives before `publish` runs.
|
|
if (!project.gradle.startParameter.taskNames.contains(taskName)) {
|
|
return
|
|
}
|
|
|
|
// Create a default MavenPublication for the variant (except "all" since that is used to publish artifacts in the new way)
|
|
project.publishing.publications.create(component.name, MavenPublication) { pub ->
|
|
groupId = "${pub.groupId}"
|
|
artifactId = "${pub.artifactId}_${pub.name}"
|
|
version = "${pub.version}"
|
|
from component
|
|
}
|
|
|
|
// Generate the Maven artifacts.
|
|
finalizedBy "publish"
|
|
}
|
|
}
|
|
|
|
// maven-publish has to be applied _before_ the project gets evaluated, but some of the code in
|
|
// `configureProject` requires the project to be evaluated. Apply the maven plugin to all projects, but
|
|
// only configure it if it matches the conditions in `projectsEvaluated`
|
|
|
|
allprojects {
|
|
apply plugin: "maven-publish"
|
|
}
|
|
|
|
projectsEvaluated {
|
|
assert rootProject.hasProperty("is-plugin")
|
|
if (rootProject.property("is-plugin").toBoolean()) {
|
|
assert rootProject.hasProperty("output-dir")
|
|
// In plugin projects, the root project is the plugin.
|
|
configureProject(rootProject, rootProject.property("output-dir"))
|
|
return
|
|
}
|
|
// The module project is the `:flutter` subproject.
|
|
Project moduleProject = rootProject.subprojects.find { it.name == "flutter" }
|
|
assert moduleProject != null
|
|
assert moduleProject.hasProperty("output-dir")
|
|
configureProject(moduleProject, moduleProject.property("output-dir"))
|
|
|
|
// Gets the plugin subprojects.
|
|
Set<Project> modulePlugins = rootProject.subprojects.findAll {
|
|
it.name != "flutter" && it.name != "app"
|
|
}
|
|
// When a module is built as a Maven artifacts, plugins must also be built this way
|
|
// because the module POM's file will include a dependency on the plugin Maven artifact.
|
|
// This is due to the Android Gradle Plugin expecting all library subprojects to be published
|
|
// as Maven artifacts.
|
|
modulePlugins.each { pluginProject ->
|
|
configurePlugin(pluginProject, moduleProject.property("output-dir"))
|
|
moduleProject.android.libraryVariants.all { variant ->
|
|
// Configure the `assembleAar<variantName>` task for each plugin's projects and make
|
|
// the module's equivalent task depend on the plugin's task.
|
|
String variantName = variant.name.capitalize()
|
|
moduleProject.tasks.findByPath("assembleAar$variantName")
|
|
.dependsOn(pluginProject.tasks.findByPath("assembleAar$variantName"))
|
|
}
|
|
}
|
|
}
|