import java.nio.file.Path import java.nio.file.Paths import com.android.builder.model.AndroidProject import org.apache.tools.ant.taskdefs.condition.Os import org.gradle.api.DefaultTask import org.gradle.api.GradleException import org.gradle.api.Project import org.gradle.api.Plugin import org.gradle.api.Task import org.gradle.api.file.CopySpec import org.gradle.api.file.FileCollection import org.gradle.api.tasks.Copy import org.gradle.api.tasks.InputFiles import org.gradle.api.tasks.OutputDirectory import org.gradle.api.tasks.TaskAction import org.gradle.api.tasks.bundling.Jar buildscript { repositories { jcenter() } dependencies { classpath 'com.android.tools.build:gradle:2.2.3' } } apply plugin: FlutterPlugin class FlutterPlugin implements Plugin<Project> { private File flutterRoot private File flutterExecutable private String localEngine private String localEngineSrcPath private Properties localProperties private File flutterJar private File debugFlutterJar private File profileFlutterJar private File releaseFlutterJar private Properties readPropertiesIfExist(File propertiesFile) { Properties result = new Properties() if (propertiesFile.exists()) { propertiesFile.withInputStream { stream -> result.load(stream) } } return result } private String resolveProperty(Project project, String name, String defaultValue) { if (localProperties == null) { localProperties = readPropertiesIfExist(project.rootProject.file("local.properties")) } String result if (project.hasProperty(name)) { result = project.property(name) } if (result == null) { result = localProperties.getProperty(name) } if (result == null) { result = defaultValue } return result } @Override void apply(Project project) { // Add a 'profile' build type project.android.buildTypes { profile { initWith debug } } String flutterRootPath = resolveProperty(project, "flutter.sdk", System.env.FLUTTER_HOME) if (flutterRootPath == null) { throw new GradleException("Flutter SDK not found. Define location with flutter.sdk in the local.properties file or with a FLUTTER_HOME environment variable.") } flutterRoot = project.file(flutterRootPath) if (!flutterRoot.isDirectory()) { throw new GradleException("flutter.sdk must point to the Flutter SDK directory") } String flutterExecutableName = Os.isFamily(Os.FAMILY_WINDOWS) ? "flutter.bat" : "flutter" flutterExecutable = Paths.get(flutterRoot.absolutePath, "bin", flutterExecutableName).toFile(); if (project.hasProperty('localEngineOut')) { String engineOutPath = project.property('localEngineOut') File engineOut = project.file(engineOutPath) if (!engineOut.isDirectory()) { throw new GradleException('localEngineOut must point to a local engine build') } flutterJar = Paths.get(engineOut.absolutePath, "flutter.jar").toFile() if (!flutterJar.isFile()) { throw new GradleException('Local engine build does not contain flutter.jar') } localEngine = engineOut.name localEngineSrcPath = engineOut.parentFile.parent project.dependencies { compile project.files(flutterJar) } } else { Path baseEnginePath = Paths.get(flutterRoot.absolutePath, "bin", "cache", "artifacts", "engine") debugFlutterJar = baseEnginePath.resolve("android-arm").resolve("flutter.jar").toFile() profileFlutterJar = baseEnginePath.resolve("android-arm-profile").resolve("flutter.jar").toFile() releaseFlutterJar = baseEnginePath.resolve("android-arm-release").resolve("flutter.jar").toFile() if (!debugFlutterJar.isFile()) { project.exec { executable flutterExecutable.absolutePath args "precache" } if (!debugFlutterJar.isFile()) { throw new GradleException("Unable to find flutter.jar in SDK: ${debugFlutterJar}") } } // Add x86/x86_64 native library. Debug mode only, for now. File flutterX86Jar = project.file("${project.buildDir}/${AndroidProject.FD_INTERMEDIATES}/flutter/flutter-x86.jar") project.tasks.create("flutterBuildX86Jar", Jar) { destinationDir flutterX86Jar.parentFile archiveName flutterX86Jar.name from("${flutterRoot}/bin/cache/artifacts/engine/android-x86/libflutter.so") { into "lib/x86" } from("${flutterRoot}/bin/cache/artifacts/engine/android-x64/libflutter.so") { into "lib/x86_64" } } project.dependencies { debugCompile project.files(flutterX86Jar, debugFlutterJar) profileCompile project.files(profileFlutterJar) releaseCompile project.files(releaseFlutterJar) } } project.extensions.create("flutter", FlutterExtension) project.afterEvaluate this.&addFlutterTask File pluginsFile = new File(project.rootProject.projectDir.parentFile, '.flutter-plugins') Properties plugins = readPropertiesIfExist(pluginsFile) plugins.each { name, _ -> def pluginProject = project.rootProject.findProject(":$name") if (pluginProject != null) { project.dependencies { compile pluginProject } pluginProject.afterEvaluate this.&addFlutterJarDependency } else { project.logger.error("Plugin project :$name not found. Please update settings.gradle.") } } } private void addFlutterJarDependency(Project project) { project.dependencies { if (flutterJar != null) { provided project.files(flutterJar) } else { debugProvided project.files(debugFlutterJar) releaseProvided project.files(releaseFlutterJar) } } } private void addFlutterTask(Project project) { if (project.flutter.source == null) { throw new GradleException("Must provide Flutter source directory") } String target = project.flutter.target if (target == null) { target = 'lib/main.dart' } if (project.hasProperty('target')) { target = project.property('target') } if (project.tasks.findByName('flutterBuildX86Jar')) { project.compileDebugJavaWithJavac.dependsOn project.flutterBuildX86Jar } File kernel if (project.hasProperty('kernel')) { kernel = project.file(project.property('kernel')) } project.android.applicationVariants.all { variant -> if (!["debug", "profile", "release"].contains(variant.name)) { throw new GradleException("Build variant must be one of \"debug\", \"profile\", or \"release\" but was \"${variant.name}\"") } FlutterTask flutterTask = project.tasks.create("flutterBuild${variant.name.capitalize()}", FlutterTask) { flutterRoot this.flutterRoot flutterExecutable this.flutterExecutable buildMode variant.name localEngine this.localEngine localEngineSrcPath this.localEngineSrcPath targetPath target kernelFile kernel sourceDir project.file(project.flutter.source) intermediateDir project.file("${project.buildDir}/${AndroidProject.FD_INTERMEDIATES}/flutter/${variant.name}") } Task copyFlxTask = project.tasks.create(name: "copyFlutterAssets${variant.name.capitalize()}", type: Copy) { dependsOn flutterTask dependsOn variant.mergeAssets into variant.mergeAssets.outputDir with flutterTask.assets } variant.outputs[0].processResources.dependsOn(copyFlxTask) } } } class FlutterExtension { String source String target } class FlutterTask extends DefaultTask { File flutterRoot File flutterExecutable String buildMode String localEngine String localEngineSrcPath @Input String targetPath @Optional @InputFile File kernelFile File sourceDir @OutputDirectory File intermediateDir CopySpec getAssets() { return project.copySpec { from "${intermediateDir}/app.flx" if (buildMode != 'debug') { from "${intermediateDir}/vm_snapshot_data" from "${intermediateDir}/vm_snapshot_instr" from "${intermediateDir}/isolate_snapshot_data" from "${intermediateDir}/isolate_snapshot_instr" } } } FileCollection readDependencies(File dependenciesFile) { if (dependenciesFile.exists()) { try { // Dependencies file has Makefile syntax: // <target> <files>: <source> <files> <separated> <by> <space> String depText = dependenciesFile.text return project.files(depText.split(': ')[1].split()) } catch (Exception e) { logger.error("Error reading dependency file ${dependenciesFile}: ${e}") } } return null } @InputFiles FileCollection getSourceFiles() { File dependenciesFile if (buildMode != 'debug') { dependenciesFile = project.file("${intermediateDir}/snapshot.d") } else { dependenciesFile = project.file("${intermediateDir}/snapshot_blob.bin.d") } FileCollection sources = readDependencies(dependenciesFile) if (sources != null) { // We have a dependencies file. Add a dependency on gen_snapshot as well, since the // snapshots have to be rebuilt if it changes. FileCollection snapshotter = readDependencies(project.file("${intermediateDir}/gen_snapshot.d")) if (snapshotter != null) { sources = sources.plus(snapshotter) } // Finally, add a dependency on pubspec.yaml as well. return sources.plus(project.files('pubspec.yaml')) } // No dependencies file (or problems parsing it). Fall back to source files. return project.fileTree( dir: sourceDir, exclude: ['android', 'ios'], include: ['**/*.dart', 'pubspec.yaml'] ) } @TaskAction void build() { if (!sourceDir.isDirectory()) { throw new GradleException("Invalid Flutter source directory: ${sourceDir}") } intermediateDir.mkdirs() if (buildMode != "debug") { project.exec { executable flutterExecutable.absolutePath workingDir sourceDir if (localEngine != null) { args "--local-engine", localEngine args "--local-engine-src-path", localEngineSrcPath } args "build", "aot" args "--quiet" args "--target", targetPath args "--target-platform", "android-arm" args "--output-dir", "${intermediateDir}" args "--${buildMode}" } } project.exec { executable flutterExecutable.absolutePath workingDir sourceDir if (localEngine != null) { args "--local-engine", localEngine args "--local-engine-src-path", localEngineSrcPath } args "build", "flx" args "--target", targetPath if (kernelFile != null) { args "--kernel", kernelFile.absolutePath } args "--output-file", "${intermediateDir}/app.flx" if (buildMode != "debug") { args "--precompiled" } else { args "--snapshot", "${intermediateDir}/snapshot_blob.bin" args "--depfile", "${intermediateDir}/snapshot_blob.bin.d" } args "--working-dir", "${intermediateDir}/flx" } } }