一、说明
要实现flutter 编辑器的两边对齐,需要修改flutter engine层,flutter engine层修改需要自己编译flutter engine.不仅如此,因为flutter engine层东西多且杂,需要debug调试.
二、Flutter Engine 的编译
Flutter engine 编译官网
https://github.com/flutter/flutter/wiki/Setting-up-the-Engine-development-environment
只看官网有些蒙的,还有下面三个可以参考
https://www.jianshu.com/p/b0eaae0a9a90
https://jsshou.cn/blog/flutter/Flutter%E5%BC%95%E6%93%8E%E7%BC%96%E8%AF%91%E4%B8%8E%E8%B0%83%E8%AF%95.html#%E4%B8%8B%E8%BD%BD%E6%BA%90%E7%A0%81
https://www.jianshu.com/p/510c26c715ad/
其实这个编译我是踩了很多坑的,现在来理一理我的最终的步骤.
A、所需软件支持
- Mac可以编译Android、iOS产物,Linux可以编译Android产物，windows都不能编译（本篇以Mac编译，记录都是以此为前提）
- git工具
- Chromium
depot_tools
安装方式:
1. 选择一个目录例如 /Users/xxx/
git clone https://chromium.googlesource.com/chromium/tools/depot_tools.git
2. 配置环境变量
export PATH=${PATH}:/Users/aozhaoyang/Desktop/depot_tools
- python环境
- curl和unzip工具
- xcode
B、下载源码
1.提前到github上fork engine项目到自己的账号github.com/hc2088/engine.git下
2.创建一个文件夹engine,下载flutter engine 源码
3.在engine文件夹下创建.gclient,然后配置如下:
url 修改为你fork flutter engine后的git clone 地址
cd engine
touch .gclient
solutions = [
{
"managed": False,
"name": "src/flutter",
"url": "git@github.com:flutter/engine.git",
"custom_deps": {},
"deps_file": "DEPS",
"safesync_url": "",
},
]
4.在engine目录下gclient sync,同步flutter engine代码.这个最好是开科学上网.终端的科学上网也需要配置.
sshkey也需要到flutter engine仓库里面配置一下.
5.执行完成之后,看下src目录下是否有如下仓库,没有就手动加一下
git remote add origin https://github.com/flutter/buildroot.git
image.png
6.确认flutter engine与flutter 版本是否一致
我是使用的fvm目录下的flutter,对应的路径为/Users/xxx/fvm/versions/3.3.7/bin/internal/engine.version,对应的flutter版本3.3.7,对应的flutter engine是857bd6b74c5eb56151bfafe91e7fa6a82b6fee25
如果当前flutter engine跟flutter对不上,执行回退操作,记住一定是在engine/src/flutter路径下,否则会找不到版本,如下:
git reset --hard 857bd6b74c5eb56151bfafe91e7fa6a82b6fee25
7.重新在engine/src下面执行gclient sync.时间有些长,耐心等待.
C、编译Android/IOS/HOST(桌面端)
按照端和芯片架构类型分别准备构建文件(可以只构建某一个端端一架构)
1.在engine/src目录下执行
android
./flutter/tools/gn --android --unoptimized --android-cpu=arm64
ios
./flutter/tools/gn --unoptimized --ios --mac-cpu=x64 --runtime-mode=debug
host
./flutter/tools/gn --unoptimized
- android：表示编译Android版本
- unoptimized： 表示不优化产物大小，这样会提高编译速度
- android-cpu： 表示打包的Android架构 如想编译macos的
编译产物
android
ninja -C out/android_debug_unopt_arm64
ios
ninja -C out/ios_debug_unopt
host
ninja -C out/host_debug_unopt
问题:目前m1上面不支持Android打包.
解决方案:https://github.com/flutter/flutter/issues/96745
1.下载补丁,在engine下面的flutter 下和depot_tools目录下进行git apply.
2.在engine下进行gclient sync
D、使用本地引擎运行Flutter
1.修改pubspec.yaml文件 在文件中添加下面代码
dependency_overrides:
sky_engine:
path: <FLUTTER_ENGINE_ROOT>/engine/src/out/host_debug_unopt/gen/dart-pkg/sky_engine
2.执行命令
flutter run --local-engine-src-path <FLUTTER_ENGINE_ROOT>/engine/src --local-engine=android_debug_unopt_arm64 -d deviceId
- local-engine-src-path：指定Flutter引擎存储库的路径，也就是src根目录的绝对路径
- local-engine：指定使用哪个引擎版本，比如
android_debug_unopt_arm64
E、debug flutter engine代码
可以使用vsCode,也可以使用xCode,我这是xcode
- 在Genrated.xcconfig(没有这个可以找下Flutter/Flutter-Generated)中加上 内容为
FLUTTER_ROOT=${FlutterSDK 路径}
FLUTTER_APPLICATION_PATH=${Demo工程路径}
FLUTTER_TARGET=${Demo工程路径}/lib/main.dart
FLUTTER_BUILD_DIR=build
SYMROOT=${SOURCE_ROOT}/../build/ios
FLUTTER_FRAMEWORK_DIR=${Flutter_Engine代码路径}/src/out/ios_debug_sim_unopt
FLUTTER_BUILD_NAME=1.0.0
FLUTTER_BUILD_NUMBER=1
FLUTTER_ENGINE=${Flutter_Engine代码路径}
LOCAL_ENGINE=${输出的路径（ios_debug_sim_unopt）}
ARCHS=${支持的架构(arm64)}
然后打上断点就可以调试啦~
三、Flutter Engine 两边对齐修改
思路:根据justify属性作为切入口,发现只要输入空格就可以实现两端对齐,然后修改flutter engine 代码,把计算空格部分代码修改成计算所有字符.
实现
把空格数量计算修改为所有字符的个数计算
计算空格间距修改为计算所有字符间距
算法解释:如果是开头的连续空格,不纳入计算间距,第一个和开头连续空格后的第一个字符也不纳入计算间距.(保持行开头非连续空格第一个字不动)
void TextLine::justify(SkScalar maxWidth) {
// Count words and the extra spaces to spread across the line
// TODO: do it at the line breaking?..
constexpr auto kWhiteSpaceNumOfStart = 2;
size_t allCharNums = 0;
SkScalar textLen = 0;
size_t posOfCharFirst = -1;
size_t firstResult = 0;
this->iterateThroughClustersInGlyphsOrder(
false, false, [&](const Cluster* cluster, bool ghost) {
textLen += cluster->width();
posOfCharFirst++;
if (posOfCharFirst == firstResult && firstResult < kWhiteSpaceNumOfStart &&
cluster->isWhitespaceBreak()) {
firstResult++;
return true;
}
if (posOfCharFirst == 0 || (posOfCharFirst == firstResult)) {
return true;
}
++allCharNums;
return true;
});
if (allCharNums == 0) {
return;
}
SkScalar step = (maxWidth - textLen) / allCharNums;
SkScalar shift = 0;
// Deal with the ghost spaces
auto ghostShift = maxWidth - this->fAdvance.fX;
// Spread the extra whitespaces
size_t posOfCharSecond = -1;
size_t result = 0;
this->iterateThroughClustersInGlyphsOrder(false, true, [&](const Cluster* cluster, bool ghost) {
posOfCharSecond++;
if (ghost) {
if (cluster->run().leftToRight()) {
shiftCluster(cluster, ghostShift, ghostShift);
}
return true;
}
auto prevShift = shift;
if (posOfCharSecond == result && result < kWhiteSpaceNumOfStart &&
cluster->isWhitespaceBreak()) {
result++;
return true;
}
if (posOfCharSecond == 0 || posOfCharSecond == result) {
return true;
}
shift += step;
shiftCluster(cluster, shift, prevShift);
return true;
});
SkAssertResult(nearlyEqual(shift, maxWidth - textLen));
this->fWidthWithSpaces += ghostShift;
this->fAdvance.fX = maxWidth;
}
上面代码可以按照自己的算法做任意排版.
四、如何使用本地打包产物
方案一
一开始以为使用如下命令就可以正常打包了,但是--local-engine只能指定一种架构的CPU,正常我们都是需要支持arm和arm64的,所以此方式不太行.
fvm flutter build apk -t lib/main.dart --local-engine=android_release_arm64 --local-engine-src-path=/Users/qimao/engine/src
方案二
使用编译好的产物,直接放到flutter的sdk的cache的engine中.
尝试了好几次,发现并不行.最后从参考文章作者了解到需要修改flutter.gradle脚本.因为1.12之前是直接通过本地产物编译,后面都是通过远程产物编译了.所以我们需要修改flutter.gradle脚本,变成本地编译.
参考文章
五、两端对齐
编辑器实际上就是一个可以编辑的富文本,在flutter中富文本是通过RichText实现的.可以从RichText的源码入手,首先可以看下它的渲染方法createRenderObject.
@override
RenderParagraph createRenderObject(BuildContext context) {
assert(textDirection != null || debugCheckHasDirectionality(context));
return RenderParagraph(text,
textAlign: textAlign,
textDirection: textDirection ?? Directionality.of(context),
softWrap: softWrap,
overflow: overflow,
textScaleFactor: textScaleFactor,
maxLines: maxLines,
strutStyle: strutStyle,
textWidthBasis: textWidthBasis,
textHeightBehavior: textHeightBehavior,
locale: locale ?? Localizations.maybeLocaleOf(context),
registrar: selectionRegistrar,
selectionColor: selectionColor,
);
}
它的实现是RenderParagraph,继续看它的源码,可以看到它的布局是交给_textPainter实现的.
void _layoutText({ double minWidth = 0.0, double maxWidth = double.infinity }) {
final bool widthMatters = softWrap || overflow == TextOverflow.ellipsis;
_textPainter.layout(
minWidth: minWidth,
maxWidth: widthMatters ?
maxWidth :
double.infinity,
);
}
继续查看的TextPainter的layout方法,它主要是创建了一个ui.Paragraph,通过它来进行布局.ui.Paragraph由ParagraphBuilder生成,通过设置ParagraphBuilder我们可以对文字进行各种TextStyle样式设置,以及设置宽高.其实已经可以控制文字的布局了:通过ui.Paragraph的paint去绘制文字.
void layout({ double minWidth = 0.0, double maxWidth = double.infinity }) {
assert(text != null, 'TextPainter.text must be set to a non-null value before using the TextPainter.');
assert(textDirection != null, 'TextPainter.textDirection must be set to a non-null value before using the TextPainter.');
// Return early if the current layout information is not outdated, even if
// _needsPaint is true (in which case _paragraph will be rebuilt in paint).
if (_paragraph != null && minWidth == _lastMinWidth && maxWidth == _lastMaxWidth) {
return;
}
if (_rebuildParagraphForPaint || _paragraph == null) {
_createParagraph();
}
_lastMinWidth = minWidth;
_lastMaxWidth = maxWidth;
// A change in layout invalidates the cached caret and line metrics as well.
_lineMetricsCache = null;
_previousCaretPosition = null;
_previousCaretPrototype = null;
_layoutParagraph(minWidth, maxWidth);
_inlinePlaceholderBoxes = _paragraph!.getBoxesForPlaceholders();
}
void _createParagraph() {
assert(_paragraph == null || _rebuildParagraphForPaint);
final InlineSpan? text = this.text;
if (text == null) {
throw StateError('TextPainter.text must be set to a non-null value before using the TextPainter.');
}
final ui.ParagraphBuilder builder = ui.ParagraphBuilder(_createParagraphStyle());
text.build(builder, textScaleFactor: textScaleFactor, dimensions: _placeholderDimensions);
_inlinePlaceholderScales = builder.placeholderScales;
_paragraph = builder.build();
_rebuildParagraphForPaint = false;
}
方案一思路形成:通过自定义ui.Paragraph中的ParagraphBuilder来控制每个文字的宽高,根据每个文字的宽度可以算出总宽度,然后通过手机屏幕的宽度减去文字总宽度就可以算出每个文字之间的间距,这样就可以确定每个文字的偏移量,最后在ui.Paragraph的paint中根据偏移量去绘制文字,就可以达到控制排版的效果.
我按照上面的思路去看quill框架代码,并修改quill绘制层源码,实现了排版功能.其中遇到了两问题.一是文字还没开始绘制,我们不知道当前文字宽度设置多大合适,如果是长英文单词需要设置的大一点,普通文字需要设置小一点.二是因为每个字的大小设置不一样,每一个字都需要创建一个ui.Paragraph.我测试了下,编辑器输入1万字的时候就开始卡顿.所以这个方案以失败告终.
继续看了下ui.Paragraph的layout代码,可以看到native,具体实现在flutter engine里面.至此dart framework层的RichText流程就完了.想要更深入研究只能看flutter engine代码了.
/// Computes the size and position of each glyph in the paragraph.
///
/// The [ParagraphConstraints] control how wide the text is allowed to be.
void layout(ParagraphConstraints constraints) {
_layout(constraints.width);
assert(() {
_needsLayout = false;
return true;
}());
}
void _layout(double width) native 'Paragraph_layout';
打开flutter engine 源码后,直接搜索Paragraph,可以找到flutter/lib/ui/text/paragraph.cpp.查看它的layout方法,发现Paragraph是个父类,并没有自己实现layout,它应该是有子类在做实现.
查看了下flutter/lib/ui/text/下并没有Paragraph的实现类,flutter engine库十分庞大,所以我通过断点发现它的子类ParagraphImpl,全局搜索找到third_party/skia/modules/skparagraph/src/ParagraphImpl.cpp.Skia是通用的图形渲染引擎.ParagraphImpl的layout的代码特别多,我们只需要看下行相关的排版核心代码.
void ParagraphImpl::layout(SkScalar rawWidth) {
...
if (fState < kLineBroken) {
this->resetContext();
this->resolveStrut();
this->computeEmptyMetrics();
this->fLines.reset();
this->breakShapedTextIntoLines(floorWidth);
fState = kLineBroken;
}
...
}
void ParagraphImpl::breakShapedTextIntoLines(SkScalar maxWidth) {
...
TextWrapper textWrapper;
textWrapper.breakTextIntoLines(
this,
maxWidth,
[&](TextRange textExcludingSpaces,
TextRange text,
TextRange textWithNewlines,
ClusterRange clusters,
ClusterRange clustersWithGhosts,
SkScalar widthWithSpaces,
size_t startPos,
size_t endPos,
SkVector offset,
SkVector advance,
InternalLineMetrics metrics,
bool addEllipsis) {
// TODO: Take in account clipped edges
auto& line = this->addLine(offset, advance, textExcludingSpaces, text, textWithNewlines, clusters, clustersWithGhosts, widthWithSpaces, metrics);
if (addEllipsis) {
line.createEllipsis(maxWidth, getEllipsis(), true);
}
fLongestLine = std::max(fLongestLine, nearlyZero(advance.fX) ? widthWithSpaces : advance.fX);
});
...
}
TextLine& ParagraphImpl::addLine(SkVector offset,
SkVector advance,
TextRange textExcludingSpaces,
TextRange text,
TextRange textIncludingNewLines,
ClusterRange clusters,
ClusterRange clustersWithGhosts,
SkScalar widthWithSpaces,
InternalLineMetrics sizes) {
// Define a list of styles that covers the line
auto blocks = findAllBlocks(textExcludingSpaces);
return fLines.emplace_back(this, offset, advance, blocks,
textExcludingSpaces, text, textIncludingNewLines,
clusters, clustersWithGhosts, widthWithSpaces, sizes);
}
layout布局的时候,会动态的根据文字的宽度把要显示的文字拆成多行.所以行(TextLine)就成为一段文字绘制的一个更小的单位.我们需要看下行相关的布局.TextLine代码也非常多,我找了下,并没有layout方法,只有paint方法.paint方法里面只有背景、文字本身、阴影、装饰等绘制.思路中断,我发现justify属性实际上是有两边对齐的效果的,只是中文符号和英文存在的时候不会对齐.我在TextLine中能看到一个justify的方法,代码如下:
void TextLine::justify(SkScalar maxWidth) {
// Count words and the extra spaces to spread across the line
// TODO: do it at the line breaking?..
size_t whitespacePatches = 0;
SkScalar textLen = 0;
bool whitespacePatch = false;
this->iterateThroughClustersInGlyphsOrder(false, false,
[&whitespacePatches, &textLen, &whitespacePatch](const Cluster* cluster, bool ghost) {
if (cluster->isWhitespaceBreak()) {
if (!whitespacePatch) {
whitespacePatch = true;
++whitespacePatches;
}
} else {
whitespacePatch = false;
}
textLen += cluster->width();
return true;
});
if (whitespacePatches == 0) {
return;
}
SkScalar step = (maxWidth - textLen) / whitespacePatches;
SkScalar shift = 0;
// Deal with the ghost spaces
auto ghostShift = maxWidth - this->fAdvance.fX;
// Spread the extra whitespaces
whitespacePatch = false;
this->iterateThroughClustersInGlyphsOrder(false, true, [&](const Cluster* cluster, bool ghost) {
if (ghost) {
if (cluster->run().leftToRight()) {
shiftCluster(cluster, ghostShift, ghostShift);
}
return true;
}
auto prevShift = shift;
if (cluster->isWhitespaceBreak()) {
if (!whitespacePatch) {
shift += step;
whitespacePatch = true;
--whitespacePatches;
}
} else {
whitespacePatch = false;
}
shiftCluster(cluster, shift, prevShift);
return true;
});
SkAssertResult(nearlyEqual(shift, maxWidth - textLen));
SkASSERT(whitespacePatches == 0);
this->fWidthWithSpaces += ghostShift;
this->fAdvance.fX = maxWidth;
}
这个其实就是我们要找的计算排版的核心逻辑:它会遍历当前行的每一个文字,计算出空格的数量和文字的总长度,然后使用行占用的最大宽度减去文字的总宽度,再除以空格的数量,就能得到每一个空格的偏移量.然后重新遍历整行文字,在每个空格地方加上之前算的偏移量.justify逻辑是可以做到等分空格的间距.我们做两端对齐,实际是需要等分每一个文字之间的间距,然后我们项目中还有首行缩进的功能,首行的第一个字前面是有两个空格的,我们在计算间距的时候不能把这两个空格加上,否则会导致首行第一个字母也会跟随文字变化而发生位置变化.我们最终修改代码逻辑如下:
void TextLine::justify(SkScalar maxWidth) {
// Count words and the extra spaces to spread across the line
// TODO: do it at the line breaking?..
constexpr auto kWhiteSpaceNumOfStart = 2;
size_t allCharNums = 0;
SkScalar textLen = 0;
size_t posOfCharFirst = -1;
size_t firstResult = 0;
this->iterateThroughClustersInGlyphsOrder(
false, false, [&](const Cluster* cluster, bool ghost) {
textLen += cluster->width();
posOfCharFirst++;
if (posOfCharFirst == firstResult && firstResult < kWhiteSpaceNumOfStart &&
cluster->isWhitespaceBreak()) {
firstResult++;
return true;
}
if (posOfCharFirst == 0 || (posOfCharFirst == firstResult)) {
return true;
}
++allCharNums;
return true;
});
if (allCharNums == 0) {
return;
}
SkScalar step = (maxWidth - textLen) / allCharNums;
SkScalar shift = 0;
// Deal with the ghost spaces
auto ghostShift = maxWidth - this->fAdvance.fX;
// Spread the extra whitespaces
size_t posOfCharSecond = -1;
size_t result = 0;
this->iterateThroughClustersInGlyphsOrder(false, true, [&](const Cluster* cluster, bool ghost) {
posOfCharSecond++;
if (ghost) {
if (cluster->run().leftToRight()) {
shiftCluster(cluster, ghostShift, ghostShift);
}
return true;
}
auto prevShift = shift;
if (posOfCharSecond == result && result < kWhiteSpaceNumOfStart &&
cluster->isWhitespaceBreak()) {
result++;
return true;
}
if (posOfCharSecond == 0 || posOfCharSecond == result) {
return true;
}
shift += step;
shiftCluster(cluster, shift, prevShift);
return true;
});
SkAssertResult(nearlyEqual(shift, maxWidth - textLen));
this->fWidthWithSpaces += ghostShift;
this->fAdvance.fX = maxWidth;
}
六、总结
总体分为两大块:一块是分析Flutter 引擎 c++代码并修改,另一块是定制engine引入项目打包.两部分难度都挺大,定制engine打包遇到的问题更难解决.目前定制engine的公司不多,网上没有成熟的解决方案,我们的方案是一点点摸索出来的,希望对你有所帮助.
更新3.16.9
// Copyright 2014 The Flutter Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
import com.android.build.OutputFile
import groovy.json.JsonSlurper
import groovy.json.JsonGenerator
import groovy.xml.QName
import java.nio.file.Path
import java.nio.file.Paths
import java.util.Set
import org.apache.tools.ant.taskdefs.condition.Os
import org.gradle.api.DefaultTask
import org.gradle.api.GradleException
import org.gradle.api.JavaVersion
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.logging.LogLevel
import org.gradle.api.tasks.Copy
import org.gradle.api.tasks.InputFiles
import org.gradle.api.tasks.Input
import org.gradle.api.tasks.Internal
import org.gradle.api.tasks.OutputDirectory
import org.gradle.api.tasks.OutputFiles
import org.gradle.api.tasks.Optional
import org.gradle.api.tasks.TaskAction
import org.gradle.api.tasks.bundling.Jar
import org.gradle.internal.os.OperatingSystem
/**
* For apps only. Provides the flutter extension used in app/build.gradle.
*
* The versions specified here should match the values in
* packages/flutter_tools/lib/src/android/gradle_utils.dart, so when bumping,
* make sure to update the versions specified there.
*
* Learn more about extensions in Gradle:
* * https://docs.gradle.org/8.0.2/userguide/custom_plugins.html#sec:getting_input_from_the_build
*/
class FlutterExtension {
/** Sets the compileSdkVersion used by default in Flutter app projects. */
static int compileSdkVersion = 34
/** Sets the minSdkVersion used by default in Flutter app projects. */
static int minSdkVersion = 19
/**
* Sets the targetSdkVersion used by default in Flutter app projects.
* targetSdkVersion should always be the latest available stable version.
*
* See https://developer.android.com/guide/topics/manifest/uses-sdk-element.
*/
static int targetSdkVersion = 33
/**
* Sets the ndkVersion used by default in Flutter app projects.
* Chosen as default version of the AGP version below as found in
* https://developer.android.com/studio/projects/install-ndk#default-ndk-per-agp.
*/
static String ndkVersion = "23.1.7779620"
/**
* Specifies the relative directory to the Flutter project directory.
* In an app project, this is ../.. since the app's build.gradle is under android/app.
*/
String source
/** Allows to override the target file. Otherwise, the target is lib/main.dart. */
String target
}
// This buildscript block supplies dependencies for this file's own import
// declarations above. It exists solely for compatibility with projects that
// have not migrated to declaratively apply the Flutter Gradle Plugin;
// for those that have, FGP's `build.gradle.kts` takes care of this.
buildscript {
repositories {
google()
mavenCentral()
}
dependencies {
// When bumping, also update:
// * ndkVersion in FlutterExtension in packages/flutter_tools/gradle/src/main/flutter.groovy
// * AGP version constants in packages/flutter_tools/lib/src/android/gradle_utils.dart
// * AGP version in dependencies block in packages/flutter_tools/gradle/build.gradle.kts
classpath("com.android.tools.build:gradle:7.3.0")
}
}
/**
* Some apps don't set default compile options.
* Apps can change these values in android/app/build.gradle.
* This just ensures that default values are set.
*/
android {
compileOptions {
sourceCompatibility JavaVersion.VERSION_1_8
targetCompatibility JavaVersion.VERSION_1_8
}
}
apply plugin: FlutterPlugin
class FlutterPlugin implements Plugin<Project> {
private static final String DEFAULT_MAVEN_HOST = "https://storage.googleapis.com";
/** The platforms that can be passed to the `--Ptarget-platform` flag. */
private static final String PLATFORM_ARM32 = "android-arm";
private static final String PLATFORM_ARM64 = "android-arm64";
private static final String PLATFORM_X86 = "android-x86";
private static final String PLATFORM_X86_64 = "android-x64";
/** The ABI architectures supported by Flutter. */
private static final String ARCH_ARM32 = "armeabi-v7a";
private static final String ARCH_ARM64 = "arm64-v8a";
private static final String ARCH_X86 = "x86";
private static final String ARCH_X86_64 = "x86_64";
private static final String INTERMEDIATES_DIR = "intermediates";
/** Maps platforms to ABI architectures. */
private static final Map PLATFORM_ARCH_MAP = [
(PLATFORM_ARM32) : ARCH_ARM32,
(PLATFORM_ARM64) : ARCH_ARM64,
(PLATFORM_X86) : ARCH_X86,
(PLATFORM_X86_64) : ARCH_X86_64,
]
/**
* The version code that gives each ABI a value.
* For each APK variant, use the following versions to override the version of the Universal APK.
* Otherwise, the Play Store will complain that the APK variants have the same version.
*/
private static final Map ABI_VERSION = [
(ARCH_ARM32) : 1,
(ARCH_ARM64) : 2,
(ARCH_X86) : 3,
(ARCH_X86_64) : 4,
]
/** When split is enabled, multiple APKs are generated per each ABI. */
private static final List DEFAULT_PLATFORMS = [
PLATFORM_ARM32,
PLATFORM_ARM64,
PLATFORM_X86_64,
]
/**
* The name prefix for flutter builds. This is used to identify gradle tasks
* where we expect the flutter tool to provide any error output, and skip the
* standard Gradle error output in the FlutterEventLogger. If you change this,
* be sure to change any instances of this string in symbols in the code below
* to match.
*/
static final String FLUTTER_BUILD_PREFIX = "flutterBuild"
private Project project
private Map baseJar = [:]
private File flutterRoot
private File flutterExecutable
private String localEngine
private String localEngineHost
private String localEngineSrcPath
private Properties localProperties
private String engineVersion
private String engineRealm
private Boolean customEngine
/**
* Flutter Docs Website URLs for help messages.
*/
private final String kWebsiteDeploymentAndroidBuildConfig = "https://docs.flutter.dev/deployment/android#reviewing-the-gradle-build-configuration"
@Override
void apply(Project project) {
this.project = project
customEngineInit()
def rootProject = project.rootProject
if (isFlutterAppProject()) {
rootProject.tasks.register("generateLockfiles") {
rootProject.subprojects.each { subproject ->
def gradlew = (OperatingSystem.current().isWindows()) ?
"${rootProject.projectDir}/gradlew.bat" : "${rootProject.projectDir}/gradlew"
rootProject.exec {
workingDir(rootProject.projectDir)
executable(gradlew)
args(":${subproject.name}:dependencies", "--write-locks")
}
}
}
}
/// 相较于 3.3.7 本部分代码,前置了
String flutterRootPath = resolveProperty("flutter.sdk", System.env.FLUTTER_ROOT)
if (flutterRootPath == null) {
throw new GradleException("Flutter SDK not found. Define location with flutter.sdk in the local.properties file or with a FLUTTER_ROOT environment variable.")
}
flutterRoot = project.file(flutterRootPath)
if (!flutterRoot.isDirectory()) {
throw new GradleException("flutter.sdk must point to the Flutter SDK directory")
}
engineVersion = useLocalEngine()
? "+" // Match any version since there's only one.
: "1.0.0-" + Paths.get(flutterRoot.absolutePath, "bin", "internal", "engine.version").toFile().text.trim()
//engine.realm 跟 engine.version 类似都是确保flutter 版本一致
engineRealm = Paths.get(flutterRoot.absolutePath, "bin", "internal", "engine.realm").toFile().text.trim()
if (engineRealm) {
engineRealm = engineRealm + "/"
}
// Configure the Maven repository.
String hostedRepository = System.env.FLUTTER_STORAGE_BASE_URL ?: DEFAULT_MAVEN_HOST
String repository = useLocalEngine()
? project.property("local-engine-repo")
: "$hostedRepository/${engineRealm}download.flutter.io"
rootProject.allprojects {
repositories {
maven {
url(repository)
}
}
}
project.extensions.create("flutter", FlutterExtension)
this.addFlutterTasks(project)
// By default, assembling APKs generates fat APKs if multiple platforms are passed.
// Configuring split per ABI allows to generate separate APKs for each abi.
// This is a noop when building a bundle.
if (shouldSplitPerAbi()) {
project.android {
splits {
abi {
// Enables building multiple APKs per ABI.
enable(true)
// Resets the list of ABIs that Gradle should create APKs for to none.
reset()
// Specifies that we do not want to also generate a universal APK that includes all ABIs.
universalApk(false)
}
}
}
}
if (project.hasProperty("deferred-component-names")) {
String[] componentNames = project.property("deferred-component-names").split(",").collect {":${it}"}
project.android {
dynamicFeatures = componentNames
}
}
getTargetPlatforms().each { targetArch ->
String abiValue = PLATFORM_ARCH_MAP[targetArch]
project.android {
if (shouldSplitPerAbi()) {
splits {
abi {
include(abiValue)
}
}
}
}
}
// 对比 3.3.7 flutter.gradle 新增部分 ++++ ///
String flutterExecutableName = Os.isFamily(Os.FAMILY_WINDOWS) ? "flutter.bat" : "flutter"
flutterExecutable = Paths.get(flutterRoot.absolutePath, "bin", flutterExecutableName).toFile();
if (project.hasProperty("multidex-enabled") &&
project.property("multidex-enabled").toBoolean()) {
String flutterMultidexKeepfile = Paths.get(flutterRoot.absolutePath, "packages", "flutter_tools",
"gradle", "flutter_multidex_keepfile.txt")
project.android {
buildTypes {
release {
multiDexKeepFile(project.file(flutterMultidexKeepfile))
}
}
}
project.dependencies {
implementation("androidx.multidex:multidex:2.0.1")
}
}
// 对比 3.3.7 flutter.gradle 新增部分 ------ ///
// Use Kotlin DSL to handle baseApplicationName logic due to Groovy dynamic dispatch bug.
project.apply from: Paths.get(flutterRoot.absolutePath, "packages", "flutter_tools", "gradle", "src", "main", "kotlin", "flutter.gradle.kts")
String flutterProguardRules = Paths.get(flutterRoot.absolutePath, "packages", "flutter_tools",
"gradle", "flutter_proguard_rules.pro")
project.android.buildTypes {
// Add profile build type.
profile {
initWith(debug)
if (it.hasProperty("matchingFallbacks")) {
matchingFallbacks = ["debug", "release"]
}
}
// TODO(garyq): Shrinking is only false for multi apk split aot builds, where shrinking is not allowed yet.
// This limitation has been removed experimentally in gradle plugin version 4.2, so we can remove
// this check when we upgrade to 4.2+ gradle. Currently, deferred components apps may see
// increased app size due to this.
if (shouldShrinkResources(project)) {
release {
// Enables code shrinking, obfuscation, and optimization for only
// your project's release build type.
minifyEnabled(true)
// Enables resource shrinking, which is performed by the Android Gradle plugin.
// The resource shrinker can't be used for libraries.
shrinkResources(isBuiltAsApp(project))
// Fallback to `android/app/proguard-rules.pro`.
// This way, custom Proguard rules can be configured as needed.
proguardFiles(project.android.getDefaultProguardFile("proguard-android.txt"), flutterProguardRules, "proguard-rules.pro")
}
}
}
// 自定义-引擎
if (useLocalEngine()) {
// This is required to pass the local engine to flutter build aot.
String engineOutPath = project.property("local-engine-out")
File engineOut = project.file(engineOutPath)
if (!engineOut.isDirectory()) {
throw new GradleException("local-engine-out must point to a local engine build")
}
localEngine = engineOut.name
localEngineSrcPath = engineOut.parentFile.parent
String engineHostOutPath = project.property("local-engine-host-out")
File engineHostOut = project.file(engineHostOutPath)
if (!engineHostOut.isDirectory()) {
throw new GradleException("local-engine-host-out must point to a local engine host build")
}
localEngineHost = engineHostOut.name
}
project.android.buildTypes.all(this.&addFlutterDependencies)
}
private static Boolean shouldShrinkResources(Project project) {
if (project.hasProperty("shrink")) {
return project.property("shrink").toBoolean()
}
return true
}
/**
* Adds the dependencies required by the Flutter project.
* This includes:
* 1. The embedding
* 2. libflutter.so
*/
void addFlutterDependencies(buildType) {
String flutterBuildMode = buildModeFor(buildType)
if (!supportsBuildMode(flutterBuildMode)) {
println " [info]不支持的build mode ${flutterBuildMode}"
return
}
println "[info][project : ${project.name}][add flutter dependencies][build mode $flutterBuildMode] "
// The embedding is set as an API dependency in a Flutter plugin.
// Therefore, don't make the app project depend on the embedding if there are Flutter
// plugins.
// This prevents duplicated classes when using custom build types. That is, a custom build
// type like profile is used, and the plugin and app projects have API dependencies on the
// embedding.
if (!isFlutterAppProject() || getPluginList().size() == 0) {
addApiDependencies(project, buildType.name,
"io.flutter:flutter_embedding_$flutterBuildMode:$engineVersion")
}
List<String> platforms = getTargetPlatforms().collect()
// Debug mode includes x86 and x64, which are commonly used in emulators.
if (flutterBuildMode == "debug" && !useLocalEngine()) {
platforms.add("android-x86")
platforms.add("android-x64")
}
println "[info] $platforms"
platforms.each { platform ->
String arch = PLATFORM_ARCH_MAP[platform].replace("-", "_")
//arm64_v8a_release-1.0.0-e76c956498841e1ab458577d3892003e553e4f3c.jar
String localJarName = "${arch}_$flutterBuildMode" + ".jar"
String jarName = "io.flutter:${arch}_$flutterBuildMode:$engineVersion";
if (customEngine) {
// String jarName = ""
// if (flutterBuildMode == "debug") {
// jarName = "${platform}/flutter.jar"
// } else {
// jarName = "${platform}-${buildType.name}/flutter.jar"
// }
if (jarFileExit(localJarName)) {
println "[info][add local file dependency ${localJarName}]";
File jarFile = getFlutterJarPath(localJarName)
addApiDependencies(project, buildType.name, project.files {
jarFile
})
} else {
println "[info][add remote file dependency ${jarName}]";
addApiDependencies(project, buildType.name, jarName)
}
} else {
println "[info][add remote file dependency ${jarName}]";
addApiDependencies(project, buildType.name, jarName)
}
}
println "[info][${flutterBuildMode}][project : ${project} add Flutter dependencies ][End]"
println ""
}
/**
* Returns the directory where the plugins are built.
*/
private File getPluginBuildDir() {
// Module projects specify this flag to include plugins in the same repo as the module project.
if (project.ext.has("pluginBuildDir")) {
return project.ext.get("pluginBuildDir")
}
return project.buildDir
}
/**
* Configures the Flutter plugin dependencies.
*
* The plugins are added to pubspec.yaml. Then, upon running `flutter pub get`,
* the tool generates a `.flutter-plugins` file, which contains a 1:1 map to each plugin location.
* Finally, the project's `settings.gradle` loads each plugin's android directory as a subproject.
*/
private void configurePlugins() {
getPluginList().each(this.&configurePluginProject)
getPluginDependencies().each(this.&configurePluginDependencies)
}
/** Adds the plugin project dependency to the app project. */
private void configurePluginProject(String pluginName, String _) {
Project pluginProject = project.rootProject.findProject(":$pluginName")
if (pluginProject == null) {
project.logger.error("Plugin project :$pluginName not found. Please update settings.gradle.")
return
}
// Add plugin dependency to the app project.
project.dependencies {
api(pluginProject)
}
Closure addEmbeddingDependencyToPlugin = { buildType ->
String flutterBuildMode = buildModeFor(buildType)
// In AGP 3.5, the embedding must be added as an API implementation,
// so java8 features are desugared against the runtime classpath.
// For more, see https://github.com/flutter/flutter/issues/40126
if (!supportsBuildMode(flutterBuildMode)) {
return
}
if (!pluginProject.hasProperty("android")) {
return
}
// Copy build types from the app to the plugin.
// This allows to build apps with plugins and custom build types or flavors.
pluginProject.android.buildTypes {
"${buildType.name}" {}
}
// The embedding is API dependency of the plugin, so the AGP is able to desugar
// default method implementations when the interface is implemented by a plugin.
//
// See https://issuetracker.google.com/139821726, and
// https://github.com/flutter/flutter/issues/72185 for more details.
addApiDependencies(
pluginProject,
buildType.name,
"io.flutter:flutter_embedding_$flutterBuildMode:$engineVersion"
)
}
// Wait until the Android plugin loaded.
pluginProject.afterEvaluate {
// Checks if there is a mismatch between the plugin compileSdkVersion and the project compileSdkVersion.
if (pluginProject.android.compileSdkVersion > project.android.compileSdkVersion) {
project.logger.quiet("Warning: The plugin ${pluginName} requires Android SDK version ${getCompileSdkFromProject(pluginProject)} or higher.")
project.logger.quiet("For more information about build configuration, see $kWebsiteDeploymentAndroidBuildConfig.")
}
project.android.buildTypes.all(addEmbeddingDependencyToPlugin)
}
}
/**
* Compares semantic versions ignoring labels.
*
* If the versions are equal (ignoring labels), returns one of the two strings arbitrarily.
*
* If minor or patch are omitted (non-conformant to semantic versioning), they are considered zero.
* If the provided versions in both are equal, the longest version string is returned.
* For example, "2.8.0" vs "2.8" will always consider "2.8.0" to be the most recent version.
*/
static String mostRecentSemanticVersion(String version1, String version2) {
List version1Tokenized = version1.tokenize(".")
List version2Tokenized = version2.tokenize(".")
def version1numTokens = version1Tokenized.size()
def version2numTokens = version2Tokenized.size()
def minNumTokens = Math.min(version1numTokens, version2numTokens)
for (int i = 0; i < minNumTokens; i++) {
def num1 = version1Tokenized[i].toInteger()
def num2 = version2Tokenized[i].toInteger()
if (num1 > num2) {
return version1
}
if (num2 > num1) {
return version2
}
}
if (version1numTokens > version2numTokens) {
return version1
}
return version2
}
/** Prints error message and fix for any plugin compileSdkVersion or ndkVersion that are higher than the project. */
private void detectLowCompileSdkVersionOrNdkVersion() {
project.afterEvaluate {
// Default to int max if using a preview version to skip the sdk check.
int projectCompileSdkVersion = Integer.MAX_VALUE
// Stable versions use ints, legacy preview uses string.
if (getCompileSdkFromProject(project).isInteger()) {
projectCompileSdkVersion = getCompileSdkFromProject(project) as int
}
int maxPluginCompileSdkVersion = projectCompileSdkVersion
String ndkVersionIfUnspecified = "21.1.6352462" /* The default for AGP 4.1.0 used in old templates. */
String projectNdkVersion = project.android.ndkVersion ?: ndkVersionIfUnspecified
String maxPluginNdkVersion = projectNdkVersion
int numProcessedPlugins = getPluginList().size()
getPluginList().each { plugin ->
Project pluginProject = project.rootProject.findProject(plugin.key)
pluginProject.afterEvaluate {
// Default to int min if using a preview version to skip the sdk check.
int pluginCompileSdkVersion = Integer.MIN_VALUE;
// Stable versions use ints, legacy preview uses string.
if (getCompileSdkFromProject(pluginProject).isInteger()) {
pluginCompileSdkVersion = getCompileSdkFromProject(pluginProject) as int;
}
maxPluginCompileSdkVersion = Math.max(pluginCompileSdkVersion, maxPluginCompileSdkVersion)
String pluginNdkVersion = pluginProject.android.ndkVersion ?: ndkVersionIfUnspecified
maxPluginNdkVersion = mostRecentSemanticVersion(pluginNdkVersion, maxPluginNdkVersion)
numProcessedPlugins--
if (numProcessedPlugins == 0) {
if (maxPluginCompileSdkVersion > projectCompileSdkVersion) {
project.logger.error("One or more plugins require a higher Android SDK version.\nFix this issue by adding the following to ${project.projectDir}${File.separator}build.gradle:\nandroid {\n compileSdkVersion ${maxPluginCompileSdkVersion}\n ...\n}\n")
}
if (maxPluginNdkVersion != projectNdkVersion) {
project.logger.error("One or more plugins require a higher Android NDK version.\nFix this issue by adding the following to ${project.projectDir}${File.separator}build.gradle:\nandroid {\n ndkVersion \"${maxPluginNdkVersion}\"\n ...\n}\n")
}
}
}
}
}
}
/**
* Returns the portion of the compileSdkVersion string that corresponds to either the numeric
* or string version.
*/
private String getCompileSdkFromProject(Project gradleProject) {
return gradleProject.android.compileSdkVersion.substring(8);
}
/**
* Returns `true` if the given path contains an `android/build.gradle` file.
*/
private Boolean doesSupportAndroidPlatform(String path) {
File editableAndroidProject = new File(path, 'android' + File.separator + 'build.gradle')
return editableAndroidProject.exists()
}
/**
* Add the dependencies on other plugin projects to the plugin project.
* A plugin A can depend on plugin B. As a result, this dependency must be surfaced by
* making the Gradle plugin project A depend on the Gradle plugin project B.
*/
private void configurePluginDependencies(Object dependencyObject) {
assert(dependencyObject.name instanceof String)
Project pluginProject = project.rootProject.findProject(":${dependencyObject.name}")
if (pluginProject == null ||
!doesSupportAndroidPlatform(pluginProject.projectDir.parentFile.path)) {
return
}
assert(dependencyObject.dependencies instanceof List)
dependencyObject.dependencies.each { pluginDependencyName ->
assert(pluginDependencyName instanceof String)
if (pluginDependencyName.empty) {
return
}
Project dependencyProject = project.rootProject.findProject(":$pluginDependencyName")
if (dependencyProject == null ||
!doesSupportAndroidPlatform(dependencyProject.projectDir.parentFile.path)) {
return
}
// Wait for the Android plugin to load and add the dependency to the plugin project.
pluginProject.afterEvaluate {
pluginProject.dependencies {
implementation(dependencyProject)
}
}
}
}
private Properties getPluginList() {
File pluginsFile = new File(project.projectDir.parentFile.parentFile, '.flutter-plugins')
Properties allPlugins = readPropertiesIfExist(pluginsFile)
Properties androidPlugins = new Properties()
allPlugins.each { name, path ->
if (doesSupportAndroidPlatform(path)) {
androidPlugins.setProperty(name, path)
}
// TODO(amirh): log an error if this plugin was specified to be an Android
// plugin according to the new schema, and was missing a build.gradle file.
// https://github.com/flutter/flutter/issues/40784
}
return androidPlugins
}
/** Gets the plugins dependencies from `.flutter-plugins-dependencies`. */
private List getPluginDependencies() {
// Consider a `.flutter-plugins-dependencies` file with the following content:
// {
// "dependencyGraph": [
// {
// "name": "plugin-a",
// "dependencies": ["plugin-b","plugin-c"]
// },
// {
// "name": "plugin-b",
// "dependencies": ["plugin-c"]
// },
// {
// "name": "plugin-c",
// "dependencies": []'
// }
// ]
// }
//
// This means, `plugin-a` depends on `plugin-b` and `plugin-c`.
// `plugin-b` depends on `plugin-c`.
// `plugin-c` doesn't depend on anything.
File pluginsDependencyFile = new File(project.projectDir.parentFile.parentFile, '.flutter-plugins-dependencies')
if (pluginsDependencyFile.exists()) {
def object = new JsonSlurper().parseText(pluginsDependencyFile.text)
assert(object instanceof Map)
assert(object.dependencyGraph instanceof List)
return object.dependencyGraph
}
return []
}
private static String toCamelCase(List<String> parts) {
if (parts.empty) {
return ""
}
return "${parts[0]}${parts[1..-1].collect { it.capitalize() }.join('')}"
}
private String resolveProperty(String name, String defaultValue) {
if (localProperties == null) {
localProperties = readPropertiesIfExist(new File(project.projectDir.parentFile, "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
}
private static Properties readPropertiesIfExist(File propertiesFile) {
Properties result = new Properties()
if (propertiesFile.exists()) {
propertiesFile.withReader("UTF-8") { reader -> result.load(reader) }
}
return result
}
private List<String> getTargetPlatforms() {
if (!project.hasProperty("target-platform")) {
println "[info] useDEFAULT_PLATFORMS"
return DEFAULT_PLATFORMS
}
return project.property("target-platform").split(",").collect {
if (!PLATFORM_ARCH_MAP[it]) {
throw new GradleException("Invalid platform: $it.")
}
return it
}
}
private Boolean shouldSplitPerAbi() {
return project.findProperty("split-per-abi")?.toBoolean() ?: false;
}
private Boolean useLocalEngine() {
return project.hasProperty("local-engine-repo")
}
private Boolean isVerbose() {
return project.findProperty("verbose")?.toBoolean() ?: false;
}
/** Whether to build the debug app in "fast-start" mode. */
private Boolean isFastStart() {
return project.findProperty("fast-start")?.toBoolean() ?: false;
}
private static Boolean isBuiltAsApp(Project project) {
// Projects are built as applications when the they use the `com.android.application`
// plugin.
return project.plugins.hasPlugin("com.android.application");
}
/**
* Returns true if the build mode is supported by the current call to Gradle.
* This only relevant when using a local engine. Because the engine
* is built for a specific mode, the call to Gradle must match that mode.
*/
private Boolean supportsBuildMode(String flutterBuildMode) {
if (!useLocalEngine()) {
return true;
}
assert(project.hasProperty("local-engine-build-mode"))
// Don't configure dependencies for a build mode that the local engine
// doesn't support.
return project.property("local-engine-build-mode") == flutterBuildMode
}
private void addCompileOnlyDependency(Project project, String variantName, Object dependency, Closure config = null) {
if (project.state.failure) {
return
}
String configuration;
if (project.getConfigurations().findByName("compileOnly")) {
configuration = "${variantName}CompileOnly";
} else {
configuration = "${variantName}Provided";
}
project.dependencies.add(configuration, dependency, config)
}
private static void addApiDependencies(Project project, String variantName, Object dependency, Closure config = null) {
String configuration;
// `compile` dependencies are now `api` dependencies.
if (project.getConfigurations().findByName("api")) {
configuration = "${variantName}Api";
} else {
configuration = "${variantName}Compile";
}
project.dependencies.add(configuration, dependency, config)
}
// Add a task that can be called on flutter projects that prints the Java version used in Gradle.
//
// Format of the output of this task can be used in debugging what version of Java Gradle is using.
// Not recomended for use in time sensitive commands like `flutter run` or `flutter build` as
// Gradle is slower than we want. Particularly in light of https://github.com/flutter/flutter/issues/119196.
private static void addTaskForJavaVersion(Project project) {
// Warning: the name of this task is used by other code. Change with caution.
project.tasks.register("javaVersion") {
description "Print the current java version used by gradle. "
"see: https://docs.gradle.org/current/javadoc/org/gradle/api/JavaVersion.html"
doLast {
println(JavaVersion.current())
}
}
}
// Add a task that can be called on Flutter projects that prints the available build variants
// in Gradle.
//
// This task prints variants in this format:
//
// BuildVariant: debug
// BuildVariant: release
// BuildVariant: profile
//
// Format of the output of this task is used by `AndroidProject.getBuildVariants`.
private static void addTaskForPrintBuildVariants(Project project) {
// Warning: The name of this task is used by `AndroidProject.getBuildVariants`.
project.tasks.register("printBuildVariants") {
description "Prints out all build variants for this Android project"
doLast {
project.android.applicationVariants.all { variant ->
println "BuildVariant: ${variant.name}";
}
}
}
}
// Add a task that can be called on Flutter projects that outputs app link related project
// settings into a json file.
//
// See https://developer.android.com/training/app-links/ for more information about app link.
//
// The json will be saved in path stored in outputPath parameter.
//
// An example json:
// {
// applicationId: "com.example.app",
// deeplinks: [
// {"scheme":"http", "host":"example.com", "path":".*"},
// {"scheme":"https","host":"example.com","path":".*"}
// ]
// }
//
// The output file is parsed and used by devtool.
private static void addTasksForOutputsAppLinkSettings(Project project) {
project.android.applicationVariants.all { variant ->
// Warning: The name of this task is used by AndroidBuilder.outputsAppLinkSettings
project.tasks.register("output${variant.name.capitalize()}AppLinkSettings") {
description "stores app links settings for the given build variant of this Android project into a json file."
variant.outputs.all { output ->
// Deeplinks are defined in AndroidManifest.xml and is only available after
// `processResourcesProvider`.
def processResources = output.hasProperty("processResourcesProvider") ?
output.processResourcesProvider.get() : output.processResources
dependsOn processResources.name
}
doLast {
def appLinkSettings = new AppLinkSettings()
appLinkSettings.applicationId = variant.applicationId
appLinkSettings.deeplinks = [] as Set<Deeplink>
variant.outputs.all { output ->
def processResources = output.hasProperty("processResourcesProvider") ?
output.processResourcesProvider.get() : output.processResources
def manifest = new XmlParser().parse(processResources.manifestFile)
manifest.application.activity.each { activity ->
activity."intent-filter".each { appLinkIntent ->
// Print out the host attributes in data tags.
def schemes = [] as Set<String>
def hosts = [] as Set<String>
def paths = [] as Set<String>
appLinkIntent.data.each { data ->
data.attributes().each { entry ->
if (entry.key instanceof QName) {
switch (entry.key.getLocalPart()) {
case "scheme":
schemes.add(entry.value)
break
case "host":
hosts.add(entry.value)
break
case "pathAdvancedPattern":
case "pathPattern":
case "path":
paths.add(entry.value)
break
case "pathPrefix":
paths.add("${entry.value}.*")
break
case "pathSuffix":
paths.add(".*${entry.value}")
break
}
}
}
}
schemes.each {scheme ->
hosts.each { host ->
if (!paths) {
appLinkSettings.deeplinks.add(new Deeplink(scheme: scheme, host: host, path: ".*"))
} else {
paths.each { path ->
appLinkSettings.deeplinks.add(new Deeplink(scheme: scheme, host: host, path: path))
}
}
}
}
}
}
}
def generator = new JsonGenerator.Options().build()
new File(project.getProperty("outputPath")).write(generator.toJson(appLinkSettings))
}
}
}
}
/**
* Returns a Flutter build mode suitable for the specified Android buildType.
*
* The BuildType DSL type is not public, and is therefore omitted from the signature.
*
* @return "debug", "profile", or "release" (fall-back).
*/
private static String buildModeFor(buildType) {
if (buildType.name == "profile") {
return "profile"
} else if (buildType.debuggable) {
return "debug"
}
return "release"
}
private static String getEngineArtifactDirName(buildType, targetArch) {
if (buildType.name == "profile") {
return "${targetArch}-profile"
} else if (buildType.debuggable) {
return "${targetArch}"
}
return "${targetArch}-release"
}
/**
* Gets the directory that contains the Flutter source code.
* This is the directory containing the `android/` directory.
*/
private File getFlutterSourceDirectory() {
if (project.flutter.source == null) {
throw new GradleException("Must provide Flutter source directory")
}
return project.file(project.flutter.source)
}
/**
* Gets the target file. This is typically `lib/main.dart`.
*/
private String getFlutterTarget() {
String target = project.flutter.target
if (target == null) {
target = "lib/main.dart"
}
if (project.hasProperty("target")) {
target = project.property("target")
}
return target
}
// TODO: Remove this AGP hack. https://github.com/flutter/flutter/issues/109560
/**
* In AGP 4.0, the Android linter task depends on the JAR tasks that generate `libapp.so`.
* When building APKs, this causes an issue where building release requires the debug JAR,
* but Gradle won't build debug.
*
* To workaround this issue, only configure the JAR task that is required given the task
* from the command line.
*
* The AGP team said that this issue is fixed in Gradle 7.0, which isn't released at the
* time of adding this code. Once released, this can be removed. However, after updating to
* AGP/Gradle 7.2.0/7.5, removing this hack still causes build failures. Futher
* investigation necessary to remove this.
*
* Tested cases:
* * `./gradlew assembleRelease`
* * `./gradlew app:assembleRelease.`
* * `./gradlew assemble{flavorName}Release`
* * `./gradlew app:assemble{flavorName}Release`
* * `./gradlew assemble.`
* * `./gradlew app:assemble.`
* * `./gradlew bundle.`
* * `./gradlew bundleRelease.`
* * `./gradlew app:bundleRelease.`
*
* Related issues:
* https://issuetracker.google.com/issues/158060799
* https://issuetracker.google.com/issues/158753935
*/
private boolean shouldConfigureFlutterTask(Task assembleTask) {
def cliTasksNames = project.gradle.startParameter.taskNames
if (cliTasksNames.size() != 1 || !cliTasksNames.first().contains("assemble")) {
return true
}
def taskName = cliTasksNames.first().split(":").last()
if (taskName == "assemble") {
return true
}
if (taskName == assembleTask.name) {
return true
}
if (taskName.endsWith("Release") && assembleTask.name.endsWith("Release")) {
return true
}
if (taskName.endsWith("Debug") && assembleTask.name.endsWith("Debug")) {
return true
}
if (taskName.endsWith("Profile") && assembleTask.name.endsWith("Profile")) {
return true
}
return false
}
private Task getAssembleTask(variant) {
// `assemble` became `assembleProvider` in AGP 3.3.0.
return variant.hasProperty("assembleProvider") ? variant.assembleProvider.get() : variant.assemble
}
private boolean isFlutterAppProject() {
return project.android.hasProperty("applicationVariants")
}
private void addFlutterTasks(Project project) {
if (project.state.failure) {
return
}
String[] fileSystemRootsValue = null
if (project.hasProperty("filesystem-roots")) {
fileSystemRootsValue = project.property("filesystem-roots").split("\\|")
}
String fileSystemSchemeValue = null
if (project.hasProperty("filesystem-scheme")) {
fileSystemSchemeValue = project.property("filesystem-scheme")
}
Boolean trackWidgetCreationValue = true
if (project.hasProperty("track-widget-creation")) {
trackWidgetCreationValue = project.property("track-widget-creation").toBoolean()
}
String frontendServerStarterPathValue = null
if (project.hasProperty("frontend-server-starter-path")) {
frontendServerStarterPathValue = project.property("frontend-server-starter-path")
}
String extraFrontEndOptionsValue = null
if (project.hasProperty("extra-front-end-options")) {
extraFrontEndOptionsValue = project.property("extra-front-end-options")
}
String extraGenSnapshotOptionsValue = null
if (project.hasProperty("extra-gen-snapshot-options")) {
extraGenSnapshotOptionsValue = project.property("extra-gen-snapshot-options")
}
String splitDebugInfoValue = null
if (project.hasProperty("split-debug-info")) {
splitDebugInfoValue = project.property("split-debug-info")
}
Boolean dartObfuscationValue = false
if (project.hasProperty("dart-obfuscation")) {
dartObfuscationValue = project.property("dart-obfuscation").toBoolean();
}
Boolean treeShakeIconsOptionsValue = false
if (project.hasProperty("tree-shake-icons")) {
treeShakeIconsOptionsValue = project.property("tree-shake-icons").toBoolean()
}
String dartDefinesValue = null
if (project.hasProperty("dart-defines")) {
dartDefinesValue = project.property("dart-defines")
}
String bundleSkSLPathValue;
if (project.hasProperty("bundle-sksl-path")) {
bundleSkSLPathValue = project.property("bundle-sksl-path")
}
String performanceMeasurementFileValue;
if (project.hasProperty("performance-measurement-file")) {
performanceMeasurementFileValue = project.property("performance-measurement-file")
}
String codeSizeDirectoryValue;
if (project.hasProperty("code-size-directory")) {
codeSizeDirectoryValue = project.property("code-size-directory")
}
Boolean deferredComponentsValue = false
if (project.hasProperty("deferred-components")) {
deferredComponentsValue = project.property("deferred-components").toBoolean()
}
Boolean validateDeferredComponentsValue = true
if (project.hasProperty("validate-deferred-components")) {
validateDeferredComponentsValue = project.property("validate-deferred-components").toBoolean()
}
addTaskForJavaVersion(project)
if(isFlutterAppProject()) {
addTaskForPrintBuildVariants(project)
addTasksForOutputsAppLinkSettings(project)
}
def targetPlatforms = getTargetPlatforms()
def addFlutterDeps = { variant ->
if (shouldSplitPerAbi()) {
variant.outputs.each { output ->
// Assigns the new version code to versionCodeOverride, which changes the version code
// for only the output APK, not for the variant itself. Skipping this step simply
// causes Gradle to use the value of variant.versionCode for the APK.
// For more, see https://developer.android.com/studio/build/configure-apk-splits
def abiVersionCode = ABI_VERSION.get(output.getFilter(OutputFile.ABI))
if (abiVersionCode != null) {
output.versionCodeOverride =
abiVersionCode * 1000 + variant.versionCode
}
}
}
// Build an AAR when this property is defined.
boolean isBuildingAar = project.hasProperty("is-plugin")
// In add to app scenarios, a Gradle project contains a `:flutter` and `:app` project.
// `:flutter` is used as a subproject when these tasks exists and the build isn't building an AAR.
Task packageAssets = project.tasks.findByPath(":flutter:package${variant.name.capitalize()}Assets")
Task cleanPackageAssets = project.tasks.findByPath(":flutter:cleanPackage${variant.name.capitalize()}Assets")
boolean isUsedAsSubproject = packageAssets && cleanPackageAssets && !isBuildingAar
boolean isAndroidLibraryValue = isBuildingAar || isUsedAsSubproject
String variantBuildMode = buildModeFor(variant.buildType)
String flavorValue = variant.getFlavorName()
String taskName = toCamelCase(["compile", FLUTTER_BUILD_PREFIX, variant.name])
// Be careful when configuring task below, Groovy has bizarre
// scoping rules: writing `verbose isVerbose()` means calling
// `isVerbose` on the task itself - which would return `verbose`
// original value. You either need to hoist the value
// into a separate variable `verbose verboseValue` or prefix with
// `this` (`verbose this.isVerbose()`).
FlutterTask compileTask = project.tasks.create(name: taskName, type: FlutterTask) {
flutterRoot(this.flutterRoot)
flutterExecutable(this.flutterExecutable)
buildMode(variantBuildMode)
minSdkVersion(variant.mergedFlavor.minSdkVersion.apiLevel)
localEngine(this.localEngine)
localEngineHost(this.localEngineHost)
localEngineSrcPath(this.localEngineSrcPath)
targetPath(getFlutterTarget())
verbose(this.isVerbose())
fastStart(this.isFastStart())
fileSystemRoots(fileSystemRootsValue)
fileSystemScheme(fileSystemSchemeValue)
trackWidgetCreation(trackWidgetCreationValue)
targetPlatformValues = targetPlatforms
sourceDir(getFlutterSourceDirectory())
intermediateDir(project.file("${project.buildDir}/$INTERMEDIATES_DIR/flutter/${variant.name}/"))
frontendServerStarterPath(frontendServerStarterPathValue)
extraFrontEndOptions(extraFrontEndOptionsValue)
extraGenSnapshotOptions(extraGenSnapshotOptionsValue)
splitDebugInfo(splitDebugInfoValue)
treeShakeIcons(treeShakeIconsOptionsValue)
dartObfuscation(dartObfuscationValue)
dartDefines(dartDefinesValue)
bundleSkSLPath(bundleSkSLPathValue)
performanceMeasurementFile(performanceMeasurementFileValue)
codeSizeDirectory(codeSizeDirectoryValue)
deferredComponents(deferredComponentsValue)
validateDeferredComponents(validateDeferredComponentsValue)
isAndroidLibrary(isAndroidLibraryValue)
flavor(flavorValue)
}
File libJar = project.file("${project.buildDir}/$INTERMEDIATES_DIR/flutter/${variant.name}/libs.jar")
Task packFlutterAppAotTask = project.tasks.create(name: "packLibs${FLUTTER_BUILD_PREFIX}${variant.name.capitalize()}", type: Jar) {
destinationDirectory = libJar.parentFile
archiveFileName = libJar.name
dependsOn compileTask
targetPlatforms.each { targetPlatform ->
String abi = PLATFORM_ARCH_MAP[targetPlatform]
from("${compileTask.intermediateDir}/${abi}") {
include "*.so"
// Move `app.so` to `lib/<abi>/libapp.so`
rename { String filename ->
return "lib/${abi}/lib${filename}"
}
}
}
}
addApiDependencies(project, variant.name, project.files {
packFlutterAppAotTask
})
Task copyFlutterAssetsTask = project.tasks.create(
name: "copyFlutterAssets${variant.name.capitalize()}",
type: Copy,
) {
dependsOn(compileTask)
with(compileTask.assets)
def currentGradleVersion = project.getGradle().getGradleVersion()
// See https://docs.gradle.org/current/javadoc/org/gradle/api/file/ConfigurableFilePermissions.html
// See https://github.com/flutter/flutter/pull/50047
if (compareVersionStrings(currentGradleVersion, "8.3") >= 0) {
filePermissions {
user {
read = true
write = true
}
}
} else {
// See https://docs.gradle.org/8.2/dsl/org.gradle.api.tasks.Copy.html#org.gradle.api.tasks.Copy:fileMode
// See https://github.com/flutter/flutter/pull/50047
fileMode(0644)
}
if (isUsedAsSubproject) {
dependsOn(packageAssets)
dependsOn(cleanPackageAssets)
into(packageAssets.outputDir)
return
}
// `variant.mergeAssets` will be removed at the end of 2019.
def mergeAssets = variant.hasProperty("mergeAssetsProvider") ?
variant.mergeAssetsProvider.get() : variant.mergeAssets
dependsOn(mergeAssets)
dependsOn("clean${mergeAssets.name.capitalize()}")
mergeAssets.mustRunAfter("clean${mergeAssets.name.capitalize()}")
into(mergeAssets.outputDir)
}
if (!isUsedAsSubproject) {
def variantOutput = variant.outputs.first()
def processResources = variantOutput.hasProperty("processResourcesProvider") ?
variantOutput.processResourcesProvider.get() : variantOutput.processResources
processResources.dependsOn(copyFlutterAssetsTask)
}
// The following tasks use the output of copyFlutterAssetsTask,
// so it's necessary to declare it as an dependency since Gradle 8.
// See https://docs.gradle.org/8.1/userguide/validation_problems.html#implicit_dependency.
def compressAssetsTask = project.tasks.findByName("compress${variant.name.capitalize()}Assets")
if (compressAssetsTask) {
compressAssetsTask.dependsOn(copyFlutterAssetsTask)
}
def bundleAarTask = project.tasks.findByName("bundle${variant.name.capitalize()}Aar")
if (bundleAarTask) {
bundleAarTask.dependsOn(copyFlutterAssetsTask)
}
return copyFlutterAssetsTask
} // end def addFlutterDeps
if (isFlutterAppProject()) {
project.android.applicationVariants.all { variant ->
Task assembleTask = getAssembleTask(variant)
if (!shouldConfigureFlutterTask(assembleTask)) {
return
}
Task copyFlutterAssetsTask = addFlutterDeps(variant)
def variantOutput = variant.outputs.first()
def processResources = variantOutput.hasProperty("processResourcesProvider") ?
variantOutput.processResourcesProvider.get() : variantOutput.processResources
processResources.dependsOn(copyFlutterAssetsTask)
// Copy the output APKs into a known location, so `flutter run` or `flutter build apk`
// can discover them. By default, this is `<app-dir>/build/app/outputs/flutter-apk/<filename>.apk`.
//
// The filename consists of `app<-abi>?<-flavor-name>?-<build-mode>.apk`.
// Where:
// * `abi` can be `armeabi-v7a|arm64-v8a|x86|x86_64` only if the flag `split-per-abi` is set.
// * `flavor-name` is the flavor used to build the app in lower case if the assemble task is called.
// * `build-mode` can be `release|debug|profile`.
variant.outputs.all { output ->
assembleTask.doLast {
// `packageApplication` became `packageApplicationProvider` in AGP 3.3.0.
def outputDirectory = variant.hasProperty("packageApplicationProvider")
? variant.packageApplicationProvider.get().outputDirectory
: variant.packageApplication.outputDirectory
// `outputDirectory` is a `DirectoryProperty` in AGP 4.1.
String outputDirectoryStr = outputDirectory.metaClass.respondsTo(outputDirectory, "get")
? outputDirectory.get()
: outputDirectory
String filename = "app"
String abi = output.getFilter(OutputFile.ABI)
if (abi != null && !abi.isEmpty()) {
filename += "-${abi}"
}
if (variant.flavorName != null && !variant.flavorName.isEmpty()) {
filename += "-${variant.flavorName.toLowerCase()}"
}
filename += "-${buildModeFor(variant.buildType)}"
project.copy {
from new File("$outputDirectoryStr/${output.outputFileName}")
into new File("${project.buildDir}/outputs/flutter-apk");
rename {
return "${filename}.apk"
}
}
println "[info][build apk done][qimao []~(￣▽￣)~*]"
println ""
}
}
// Copy the native assets created by build.dart and placed here by flutter assemble.
def nativeAssetsDir = "${project.buildDir}/../native_assets/android/jniLibs/lib/"
project.android.sourceSets.main.jniLibs.srcDir(nativeAssetsDir)
}
configurePlugins()
detectLowCompileSdkVersionOrNdkVersion()
return
}
// Flutter host module project (Add-to-app).
String hostAppProjectName = project.rootProject.hasProperty("flutter.hostAppProjectName") ? project.rootProject.property("flutter.hostAppProjectName") : "app"
Project appProject = project.rootProject.findProject(":${hostAppProjectName}")
assert(appProject != null) : "Project :${hostAppProjectName} doesn't exist. To customize the host app project name, set `flutter.hostAppProjectName=<project-name>` in gradle.properties."
// Wait for the host app project configuration.
appProject.afterEvaluate {
assert(appProject.android != null)
project.android.libraryVariants.all { libraryVariant ->
Task copyFlutterAssetsTask
appProject.android.applicationVariants.all { appProjectVariant ->
Task appAssembleTask = getAssembleTask(appProjectVariant)
if (!shouldConfigureFlutterTask(appAssembleTask)) {
return
}
// Find a compatible application variant in the host app.
//
// For example, consider a host app that defines the following variants:
// | ----------------- | ----------------------------- |
// | Build Variant | Flutter Equivalent Variant |
// | ----------------- | ----------------------------- |
// | freeRelease | release |
// | freeDebug | debug |
// | freeDevelop | debug |
// | profile | profile |
// | ----------------- | ----------------------------- |
//
// This mapping is based on the following rules:
// 1. If the host app build variant name is `profile` then the equivalent
// Flutter variant is `profile`.
// 2. If the host app build variant is debuggable
// (e.g. `buildType.debuggable = true`), then the equivalent Flutter
// variant is `debug`.
// 3. Otherwise, the equivalent Flutter variant is `release`.
String variantBuildMode = buildModeFor(libraryVariant.buildType)
if (buildModeFor(appProjectVariant.buildType) != variantBuildMode) {
return
}
if (copyFlutterAssetsTask == null) {
copyFlutterAssetsTask = addFlutterDeps(libraryVariant)
}
Task mergeAssets = project
.tasks
.findByPath(":${hostAppProjectName}:merge${appProjectVariant.name.capitalize()}Assets")
assert(mergeAssets)
mergeAssets.dependsOn(copyFlutterAssetsTask)
}
}
}
configurePlugins()
detectLowCompileSdkVersionOrNdkVersion()
}
// compareTo implementation of version strings in the format of ints and periods
// Requires non null objects.
static int compareVersionStrings(String firstString, String secondString) {
List firstVersion = firstString.tokenize(".")
List secondVersion = secondString.tokenize(".")
def commonIndices = Math.min(firstVersion.size(), secondVersion.size())
for (int i = 0; i < commonIndices; i++) {
def firstAtIndex = firstVersion[i].toInteger()
def secondAtIndex = secondVersion[i].toInteger()
if (firstAtIndex != secondAtIndex) {
// <=> in groovy delegates to compareTo
return firstAtIndex <=> secondAtIndex
}
}
// If we got this far then all the common indices are identical, so whichever version is longer must be more recent
return firstVersion.size() <=> secondVersion.size()
}
// custom engine 相关初始化
void customEngineInit() {
customEngine = getCustomEngine()
if ( customEngine ) {
println "[info][build apk][custom engine]"
println ""
} else {
println "[info][build apk]"
println ""
}
}
// 获取 custom_engine 配置
private boolean getCustomEngine() {
boolean flag = false
if (project.hasProperty("custom_engine")) {
flag = project.property("custom_engine").toBoolean()
}
return flag
}
// 获取 jar file
private File getFlutterJarPath(jarName) {
if (baseJar[jarName] != null) {
return baseJar[jarName]
} else {
Path jarPath = Paths.get(flutterRoot.absolutePath, "bin", "cache", "artifacts", "engine", "custom_engine", jarName)
File jarFile = jarPath.toFile()
baseJar[jarName] = jarFile
return jarFile
}
}
// 判断 jar file 是否存在
private boolean jarFileExit(jarName) {
Path jarPath = Paths.get(flutterRoot.absolutePath, "bin", "cache", "artifacts", "engine", "custom_engine", jarName)
return jarPath.toFile().exists()
}
}
class AppLinkSettings {
String applicationId
Set<Deeplink> deeplinks
}
class Deeplink {
String scheme, host, path
boolean equals(o) {
if (o == null)
throw new NullPointerException()
if (o.getClass() != getClass())
return false
return scheme == o.scheme &&
host == o.host &&
path == o.path
}
}
abstract class BaseFlutterTask extends DefaultTask {
@Internal
File flutterRoot
@Internal
File flutterExecutable
@Input
String buildMode
@Input
int minSdkVersion
@Optional @Input
String localEngine
@Optional @Input
String localEngineHost
@Optional @Input
String localEngineSrcPath
@Optional @Input
Boolean fastStart
@Input
String targetPath
@Optional @Input
Boolean verbose
@Optional @Input
String[] fileSystemRoots
@Optional @Input
String fileSystemScheme
@Input
Boolean trackWidgetCreation
@Optional @Input
List<String> targetPlatformValues
@Internal
File sourceDir
@Internal
File intermediateDir
@Optional @Input
String frontendServerStarterPath
@Optional @Input
String extraFrontEndOptions
@Optional @Input
String extraGenSnapshotOptions
@Optional @Input
String splitDebugInfo
@Optional @Input
Boolean treeShakeIcons
@Optional @Input
Boolean dartObfuscation
@Optional @Input
String dartDefines
@Optional @Input
String bundleSkSLPath
@Optional @Input
String codeSizeDirectory;
@Optional @Input
String performanceMeasurementFile;
@Optional @Input
Boolean deferredComponents
@Optional @Input
Boolean validateDeferredComponents
@Optional @Input
Boolean isAndroidLibrary
@Optional @Input
String flavor
@OutputFiles
FileCollection getDependenciesFiles() {
FileCollection depfiles = project.files()
// Includes all sources used in the flutter compilation.
depfiles += project.files("${intermediateDir}/flutter_build.d")
return depfiles
}
void buildBundle() {
if (!sourceDir.isDirectory()) {
throw new GradleException("Invalid Flutter source directory: ${sourceDir}")
}
intermediateDir.mkdirs()
// Compute the rule name for flutter assemble. To speed up builds that contain
// multiple ABIs, the target name is used to communicate which ones are required
// rather than the TargetPlatform. This allows multiple builds to share the same
// cache.
String[] ruleNames;
if (buildMode == "debug") {
ruleNames = ["debug_android_application"]
} else if (deferredComponents) {
ruleNames = targetPlatformValues.collect { "android_aot_deferred_components_bundle_${buildMode}_$it" }
} else {
ruleNames = targetPlatformValues.collect { "android_aot_bundle_${buildMode}_$it" }
}
project.exec {
logging.captureStandardError(LogLevel.ERROR)
executable(flutterExecutable.absolutePath)
workingDir(sourceDir)
if (localEngine != null) {
args "--local-engine", localEngine
args "--local-engine-src-path", localEngineSrcPath
}
if (localEngineHost != null) {
args "--local-engine-host", localEngineHost
}
if (verbose) {
args "--verbose"
} else {
args "--quiet"
}
args("assemble")
args("--no-version-check")
args("--depfile", "${intermediateDir}/flutter_build.d")
args("--output", "${intermediateDir}")
if (performanceMeasurementFile != null) {
args("--performance-measurement-file=${performanceMeasurementFile}")
}
if (!fastStart || buildMode != "debug") {
args("-dTargetFile=${targetPath}")
} else {
args("-dTargetFile=${Paths.get(flutterRoot.absolutePath, "examples", "splash", "lib", "main.dart")}")
}
args("-dTargetPlatform=android")
args("-dBuildMode=${buildMode}")
if (trackWidgetCreation != null) {
args("-dTrackWidgetCreation=${trackWidgetCreation}")
}
if (splitDebugInfo != null) {
args("-dSplitDebugInfo=${splitDebugInfo}")
}
if (treeShakeIcons == true) {
args("-dTreeShakeIcons=true")
}
if (dartObfuscation == true) {
args("-dDartObfuscation=true")
}
if (dartDefines != null) {
args("--DartDefines=${dartDefines}")
}
if (bundleSkSLPath != null) {
args("-dBundleSkSLPath=${bundleSkSLPath}")
}
if (codeSizeDirectory != null) {
args("-dCodeSizeDirectory=${codeSizeDirectory}")
}
if (flavor != null) {
args("-dFlavor=${flavor}")
}
if (extraGenSnapshotOptions != null) {
args("--ExtraGenSnapshotOptions=${extraGenSnapshotOptions}")
}
if (frontendServerStarterPath != null) {
args("-dFrontendServerStarterPath=${frontendServerStarterPath}")
}
if (extraFrontEndOptions != null) {
args("--ExtraFrontEndOptions=${extraFrontEndOptions}")
}
args("-dAndroidArchs=${targetPlatformValues.join(' ')}")
args("-dMinSdkVersion=${minSdkVersion}")
if (isAndroidLibrary != null) {
args("-dIsAndroidLibrary=${isAndroidLibrary ? "true" : "false"}")
}
args(ruleNames)
}
}
}
class FlutterTask extends BaseFlutterTask {
@OutputDirectory
File getOutputDirectory() {
return intermediateDir
}
@Internal
String getAssetsDirectory() {
return "${outputDirectory}/flutter_assets"
}
@Internal
CopySpec getAssets() {
return project.copySpec {
from("${intermediateDir}")
include("flutter_assets/**") // the working dir and its files
}
}
@Internal
CopySpec getSnapshots() {
return project.copySpec {
from("${intermediateDir}")
if (buildMode == "release" || buildMode == "profile") {
targetPlatformValues.each {
include("${PLATFORM_ARCH_MAP[targetArch]}/app.so")
}
}
}
}
FileCollection readDependencies(File dependenciesFile, Boolean inputs) {
if (dependenciesFile.exists()) {
// Dependencies file has Makefile syntax:
// <target> <files>: <source> <files> <separated> <by> <non-escaped space>
String depText = dependenciesFile.text
// So we split list of files by non-escaped(by backslash) space,
def matcher = depText.split(": ")[inputs ? 1 : 0] =~ /(\\ |[^\s])+/
// then we replace all escaped spaces with regular spaces
def depList = matcher.collect{it[0].replaceAll("\\\\ ", " ")}
return project.files(depList)
}
return project.files();
}
@InputFiles
FileCollection getSourceFiles() {
FileCollection sources = project.files()
for (File depfile in getDependenciesFiles()) {
sources += readDependencies(depfile, true)
}
return sources + project.files("pubspec.yaml")
}
@OutputFiles
FileCollection getOutputFiles() {
FileCollection sources = project.files()
for (File depfile in getDependenciesFiles()) {
sources += readDependencies(depfile, false)
}
return sources
}
@TaskAction
void build() {
buildBundle()
}
}
如果你有实践过好的自定义flutter engine的方案,也可以在评论区留言~
一些路径记忆
packages/flutter_tools/gradle/src/main/groovy/flutter.groovy
flutter.jar与xframework
/Users/aozhaoyang/fvm/versions/3.16.9/bin/cache/artifacts/engine/android-arm-release
fvm flutter precache
