从架构到源码：一文了解Flutter渲染机制

时间 2020-12-01

标签前端 android git github web 算法 macos canvas 小程序微信小程序栏目系统架构繁體版

原文原文链接

简介： Flutter从本质上来说仍是一个UI框架，它解决的是一套代码在多端渲染的问题。在渲染管线的设计上更加精简，加上自建渲染引擎，相比ReactNative、Weex以及WebView等方案，具备更好的性能体验。本文将从架构和源码的角度详细分析Flutter渲染机制的设计与实现。较长，同窗们可收藏后再看。前端

写在前面

跨平台技术因为其一码多端的生产力提高而表现出巨大的生命力，从早期的Hybrid App到ReactNative/Weex、小程序/快应用，再到如今的Flutter，跨平台技术一直在解决效率问题的基础上最大化的解决性能和体验问题。这也引出了任何跨平台技术都会面临的核心问题：android

效率：解决在多应用、多平台、多容器上开发效率的问题，一码多端，业务快跑。
性能：解决的是业务的性能和体验问题。

效率做为跨平台技术的基本功能，你们都能作到。问题是谁能把性能和体验作得更好，在渲染技术这块一共有三种方案：git

WebView渲染：依赖WebView进行渲染，在功能和性能上有妥协，例如PhoneGap、Cordova、小程序（有的小程序底层也采用了ReactNative等渲染方案）等。
原生渲染：上层拥抱W3C，经过中间层把前端框架翻译为原生控件，例如ReactNative+React、Weex+Vue的组合，这种方案多了一层转译层，性能上有损耗。随着原生系统的升级，在兼容性上也会有问题。
自建渲染：自建渲染框架，底层使用Skia等图形库进行渲染，例如Flutter、Unity。

Flutter因为其自建渲染引擎，贴近原生的实现方式，得到了优秀的渲染性能。github

Flutter拥有本身的开发工具，开发语言、虚拟机，编译机制，线程模型和渲染管线，和Android相比，它也能够看作一个小型的OS了。web

第一次接触Flutter，能够看看Flutter的创始人Eric以前的访谈《What is Flutter？》，Eric以前致力于Chromium渲染管线的设计与开发，所以Flutter的渲染与Chromium有必定的类似之处，后面咱们会作下类比。算法

后面咱们会从架构和源码的角度分析Flutter渲染机制的设计与实现，在此以前也能够先看看Flutter官方对于渲染机制的分享《How Flutter renders Widgets》。视频+图文的方式会更加直观，能够有一个大致的理解。macos

架构分析

架构设计

从结构上看，Flutter渲染由UI Thread与GPU Thread相互配合完成。canvas

1）UI Thread小程序

对应图中1-5，执行Dart VM中的Dart代码（包含应用程序和Flutter框架代码），主要负责Widget Tree、Element Tree、RenderObject Tree的构建，布局、以及绘制生成绘制指令，生成Layer Tree（保存绘制指令）等工做。微信小程序

2）GPU Thread

对应图中6-7，执行Flutter引擎中图形相关代码（Skia），这个线程经过与GPU通讯，获取Layer Tree并执行栅格化以及合成上屏等操做，将Layer Tree显示在屏幕上。

注：图层树（Layer Tree）是Flutter组织绘制指令的方式，相似于Android Rendering里的View DisplayList，都是组织绘制指令的一种方式。

UI Thread与GPU Thread属于生产者和消费者的角色。

流程设计

咱们知道Android上的渲染都是在VSync信号驱动下进行的，Flutter在Android上的渲染也不例外，它会向Android系统注册并等待VSync信号，等到VSync信号到来之后，调用沿着C++ Engine->Java Engine，到达Dart Framework，开始执行Dart代码，经历Layout、Paint等过程，生成一棵Layer Tree，将绘制指令保存在Layer中，接着进行栅格化和合成上屏。

具体说来：

1）向Android系统注册并等待VSync信号

Flutter引擎启动时，会向Android系统的Choreographer（管理VSync信号的类）注册并接收VSync信号的回调。

2）接收到VSync信号，经过C++ Engine向Dart Framework发起渲染调用

当VSync信号产生之后，Flutter注册的回调被调用，VsyncWaiter::fireCallback() 方法被调用，接着会执行 Animator::BeiginFrame()，最终调用到 Window::BeginFrame() 方法，WIndow实例是链接底层Engine和Dart Framework的重要桥梁，基本上与平台相关的操做都会经过Window实例来链接，例如input事件、渲染、无障碍等。

3）Dart Framework开始在UI线程执行渲染逻辑，生成Layer Tree，并将栅格化任务post到GPU线程执行

Window::BeiginFrame() 接着调用，执行到 RenderBinding::drawFrame() 方法，这个方法会去驱动UI界面上的dirty节点（须要重绘的节点）进行从新布局和绘制，若是渲染过程当中遇到图片，会先放到Worker Thead去加载和解码，而后再放到IO Thread生成图片纹理，因为IO Thread和GPI Thread共享EGL Context，所以IO Thread生成的图片纹理能够被GPU Thread直接访问。

4）GPU线程接收到Layer Tree，进行栅格化以及合成上屏的工做

Dart Framework绘制完成之后会生成绘制指令保存在Layer Tree中，经过 Animator::RenderFrame() 把Layer Tree提交给GPU Thread，GPU Thread接着执行栅格化和上屏显示。以后经过 Animator::RequestFrame() 请求接收系统的下一次VSync信号，如此循环往复，驱动UI界面不断更新。

逐个调用流程比较长，可是核心点没多少，不用纠结调用链，抓住关键实现便可，咱们把里面涉及到的一些主要类用颜色分了个类，对着这个类图，基本能够摸清Flutter的脉络。

绿色：Widget 黄色：Element 红色：RenderObject

以上即是Flutter渲染的总体流程，会有多个线程配合，多个模块参与，抛开冗长的调用链，咱们针对每一步来具体分析。咱们在分析结构时把Flutter的渲染流程分为了7大步，Flutter的timeline也能够清晰地看到这些流程，以下所示：

UI Thread

1）Animate

由 handleBeiginFrame() 方法的transientCallbacks触发，若是没有动画，则该callback为空；若是有动画，则会回调 Ticker.tick() 触发动画Widget更新下一帧的值。

2）Build

由 BuildOwner.buildScope() 触发，主要用来构建或者更新三棵树，Widget Tree、Element Tree和RenderObject Tree。

3）Layout

由 PipelineOwner.flushLayout() 触发，它会调用 RenderView.performLayout()，遍历整棵Render Tree，调用每一个节点的 layout()，根据build过程记录的信息，更新dirty区域RenderObject的排版数据，使得每一个RenderObject最终都能有正确的大小（size）和位置（position，保存在parentData中）。

4）Compositing Bits

由 PipelineOwner.flushCompositingBits() 触发，更新具备dirty合成位置的渲染对象，此阶段每一个渲染对象都会了解其子项是否须要合成，在绘制阶段使用此信息选择如何实现裁剪等视觉效果。

5）Paint

由 PipeOwner.flushPaint() 触发，它会调用 RenderView.paint()。最终触发各个节点的 paint()，最终生成一棵Layer Tree，并把绘制指令保存在Layer中。

6）Submit（Compositing）

由 renderView.compositeFrame() 方法触发，这个地方官方的说法叫Compositing，不过我以为叫Compositing有歧义，由于它并非在合成，而是把Layer Tree提交给GPU Thread，于是我以为叫Submit更合适。

GPU Thread

7）Compositing

由 Render.compositeFrame() 触发，它经过Layer Tree构建一个Scene，传给Window进行最终的光栅化。

GPU Thread经过Skia向GPU绘制一帧数据，GPU将帧信息保存在FrameBuffer里，而后根据VSync信号周期性的从FrameBuffer取出帧数据交给显示器，从而显示出最终的界面。

Rendering Pipeline

Flutter引擎启动时，向Android系统的Choreographer注册并接收VSync信号，GPU硬件产生VSync信号之后，系统便会触发回调，并驱动UI线程进行渲染工做。

1 Animate

触发方法：由 handleBeiginFrame() 方法的transientCallbacks触发

Animate在 handleBeiginFrame() 方法里由transientCallbacks触发，若是没有动画，则该callback为空；若是有动画，则会回调 Ticker._tick() 触发动画Widget更新下一帧的值。

void handleBeginFrame(Duration rawTimeStamp) {
    ...
    try {
      // TRANSIENT FRAME CALLBACKS
      Timeline.startSync('Animate', arguments: timelineWhitelistArguments);
      _schedulerPhase = SchedulerPhase.transientCallbacks;
      final Map<int, _FrameCallbackEntry> callbacks = _transientCallbacks;
      _transientCallbacks = <int, _FrameCallbackEntry>{};
      callbacks.forEach((int id, _FrameCallbackEntry callbackEntry) {
        if (!_removedIds.contains(id))
          _invokeFrameCallback(callbackEntry.callback, _currentFrameTimeStamp, callbackEntry.debugStack);
      });
      ...
    } finally {
      ...
    }
  }

handleBeiginFrame() 处理完成之后，接着调用 handleDrawFrame()，handleDrawFrame() 会触发如下回调：

postFrameCallbacks用来通知监听者绘制已经完成。
pesistentCallbacks用来触发渲染。

这两个回调都是SchedulerBinding内部的回调队列，以下所示：

_transientCallbacks：用于存放一些临时回调，目前是在 Ticker.scheduleTick() 中注册，用来驱动动画。
_persistentCallbacks：用来存放一些持久回调，不能在此回调中再请求新的绘制帧，持久回调一经注册就不嫩嫩移除， RenderBinding.initInstaces().addPersitentFrameCallback() 添加了一个持久回调，用来触发 drawFrame()。
_postFrameCallbacks：在Frame结束时会被调用一次，调用后会被移除，它主要是用来通知监听者这个Frame已经完成。

接着会调用 WidgetBinder.drawFrame() 方法，它会先调用会先调用 BuildOwner.buildScope() 触发树的更新，而后才进行绘制。

@override
void drawFrame() {
  ...
  try {
    if (renderViewElement != null)
      buildOwner.buildScope(renderViewElement);
    super.drawFrame();
    buildOwner.finalizeTree();
  } finally {
    assert(() {
      debugBuildingDirtyElements = false;
      return true;
    }());
  }
  ...
}

接着调用 RenderingBinding.drawFrame() 触发layout、paingt等流程。

void drawFrame() {
  assert(renderView != null);
  pipelineOwner.flushLayout();
  pipelineOwner.flushCompositingBits();
  pipelineOwner.flushPaint();
  if (sendFramesToEngine) {
    renderView.compositeFrame(); // this sends the bits to the GPU
    pipelineOwner.flushSemantics(); // this also sends the semantics to the OS.
    _firstFrameSent = true;
  }
}

以上即是核心流程代码，咱们接着来Build的实现。

2 Build

触发方法：由 BuildOwner.buildScope() 触发。

咱们上面说到，handleDrawFrame() 会触发树的更新，事实上 BuildOwner.buildScope() 会有两种调用时机：

树构建（应用启动时）：咱们上面提到的 runApp() 方法调用的 scheduleAttachRootWidget() 方法，它会构建Widgets Tree、Element Tree与RenderObject Tree三棵树。
树更新（帧绘制与更新时）：这里不会从新构建三棵树，而是只会更新dirty区域的Element。

也便是说树的构建和更新都是由 BuildOwner.buildScope() 方法来完成的。它们的差异在于树构建的时候传入了一个 element.mount(null, null) 回调。在 buildScope() 过程当中会触发这个回调。

这个回调会构建三棵树，为何会有三棵树呢，由于Widget只是对UI元素的一个抽象描述，咱们须要先将其inflate成Element，而后生成对应的RenderObject来驱动渲染，以下所示：

Widget Tree：为Element描述须要的配置，调用createElement方法建立Element，决定Element是否须要更新。Flutter经过查分算法比对Widget树先后的变化，来决定Element的State是否改变。
Element Tree：表示Widget Tree特定位置的一个实例，调用createRenderObject建立RenderObject，同时持有Widget和RenderObject，负责管理Widget的配置和RenderObjec的渲染。Element的状态由Flutter维护，开发人员只须要维护Widget便可。
RenderObject Tree：RenderObject绘制，测量和绘制节点，布局子节点，处理输入事件。

3 Layout

触发方法：由 PipelineOwner.flushLayout() 触发。

相关文档：Understanding constraints
相关源码：PipelineOwner.flushLayout()

Layout是基于单向数据流来实现的，父节点向子节点传递约束（Constraints），子节点向父节点传递大小（Size，保存在父节点的parentData变量中）。先深度遍历RenderObject Tree，而后再递归遍历约束。单向数据流让布局流程变得更简单，性能也更好。

对于RenderObject而言，它只是提供了一套基础的布局协议，没有定义子节点模型、坐标系统和具体的布局协议。它的子类RenderBox则提供了一套笛卡尔坐标体系（和Android&iOS同样），大部分RenderObject类都是直接继承RenderBox来实现的。RenderBox有几个不一样的子类实现，它们各自对应了不一样的布局算法。

RenderFlex：弹性布局，这是一种很常见的布局方式，它对应的是Widget组件Flex、Row和Column。关于这一块的布局算法代码注释里有描述，也能够直接看这篇文章的解释。
RenderStack：栈布局。

咱们再来聊聊Layout流程中涉及的两个概念边界约束（Constraints）和从新布局边界（RelayoutBoundary）。

边界约束（Constraints）：边界约束是父节点用来限制子节点的大小的一种方式，例如BoxConstraints、SliverConstraints等。

RenderBox提供一套BoxConstraints，如图所示，它会提供如下限制：

minWidth
maxWidth
minHeight
maxHeight

利用这种简单的盒模型约束，咱们能够很是灵活的实现不少常见的布局，例如彻底和父节点同样的大小，垂直布局（宽度和父节点同样大）、水平布局（高度和父容器同样大）。

经过Constraints和子节点本身配置的大小信息，就能够最终算出子节点的大小，接下来就须要计算子节点的位置。子节点的位置是由父节点来决定的。

从新布局边界（RelayoutBoundary）：为一个子节点设置从新布局边界，这样当它的大小发生变化时，不会致使父节点从新布局，这是个标志位，在标记dirty的markNeedsLayout()方法中会检查这个标记位来决定是否从新进行布局。

从新布局边界这种机制提高了布局排版的性能。

经过Layout，咱们了解了全部节点的位置和大小，接下来就会去绘制它们。

4 Compositing Bits

触发方法：由 PipelineOwner.flushCompositingBits() 触发。

在Layout以后，在Paint以前会先执行Compositing Bits，它会检查RenderObject是否须要重绘，而后更新RenderObject Tree各个节点的needCompositing标志。若是为true，则须要重绘。

5 Paint

触发方法：由 PipeOwner.flushPaint() 触发。

6 Submit（Compositing）

触发方法：由 renderView.compositeFrame() 方法触发。

Dart层调用入口：compositing.dart widow.dart
C++层实现：scene.cc scene_builder.cc

注：这个地方官方的说法叫Compositing，不过我以为叫Compositing有歧义，由于它并非在合成，而是把Layer Tree提交给GPU Thread，于是我以为叫Submit更合适。

void compositeFrame() {
    Timeline.startSync('Compositing', arguments: timelineArgumentsIndicatingLandmarkEvent);
    try {
      final ui.SceneBuilder builder = ui.SceneBuilder();
      final ui.Scene scene = layer.buildScene(builder);
      if (automaticSystemUiAdjustment)
        _updateSystemChrome();
      _window.render(scene);
      scene.dispose();
      assert(() {
        if (debugRepaintRainbowEnabled || debugRepaintTextRainbowEnabled)
          debugCurrentRepaintColor = debugCurrentRepaintColor.withHue((debugCurrentRepaintColor.hue + 2.0) % 360.0);
        return true;
      }());
    } finally {
      Timeline.finishSync();
    }
  }

建立SceneBuilder对象，并经过 SceneBuilder.addPicture() 将上文中生成的Picture添加到SceneBuilder对象对象中。
经过 SceneBuilder.build() 方法生成Scene对象，接着会经过window.render(scene)将包含绘制指令的Layer Tree提交给CPU线程进行光栅化和合成。

在这个过程当中Dart Framework层的Layer会被转换为C++层使用的flow::layer，Flow模块是一个基于Skia的简单合成器，运行在GPU线程，并向Skia上传指令信息。Flutter Engine使用flow缓存Paint阶段生成的绘制指令和像素信息。咱们在Paint阶段的Layer，它们都与Flow模块里的Layer一一对应。

Graphics Pipeline

7 Raster&Compositing

有了包含渲染指令的Layer Tree之后就能够进行光栅化和合成了。

光栅化是把绘制指令转换成对应的像素数据，合成是把各图层栅格化后的数据进行相关的叠加和特性处理。这个流程称为Graphics Pipeline。

Android、Chromium与Flutter

Android、Chromium、Flutter都做为Google家的明星级项目，它们在渲染机制的设计上既有类似又有不一样，借着这个机会咱们对它们作个比较。

现代渲染流水线的基本设计：

咱们再分别来看看Android、Chromium和Flutter是怎么实现的。

Android渲染流水线：

Chromium渲染流水线：

Flutter渲染流水线：

相互比较：

写在最后

最后的最后，谈一谈我对跨平台生态的理解。

跨平台容器生态至少能够分为三个方面：

前端框架生态

前端框架生态直接面向的是业务，它应该具有两个特色：

拥抱W3C生态
相对稳定性

它应该是拥抱W3C生态的。W3C生态是一个繁荣且充满活力的生态，它会发展的更久更远。试图抛弃W3C生态，自建子集的作法很难走的长远。这从微信小程序、Flutter都推出for web系列就能看出端倪。

它应该是相对稳定的。不能说咱们每换一套容器，前端的业务就须要从新写一遍，例如咱们以前作H5容器，后来作小程序容器，由于DSL不通，前端要花大力气将业务重写。虽然小程序是一码多端，可是我认为这并无解决效率问题，主要存在两个问题：

前端的学习成本增长，小程序的DSL还算简单，Flutter的Widget体系学习起来就须要花上一点时间，这些对于团队来讲都是成本。
业务代码重写，大量逻辑须要梳理，并且老业务并不必定都适合迁移到新容器上，好比小程序原本就是个很轻量的解决方案，可是咱们在上面堆积了不少功能，形成了严重的体验问题。

在这种状况下，业务很难实现快速奔跑。因此说无论底层容器怎么变，前端的框架必定是相对稳定的。而这种稳定性就有赖于容器统一层。

容器统一层

容器统一层是在前端框架和容器层之间的一个层级。它定义了容器提供的基本能力，这些能力就像协议同样，是相对稳定的。

协议是很是重要的，就像OpenGL协议同样，有了OpenGL协议，无论底层的渲染方案如何实现，上层的调用是不用变的。对于咱们的业务也是同样，围绕着容器统一层，咱们须要沉淀通用的解决方案。

统一API解决方案
统一性能解决方案
统一组件解决方案
统一配套设施解决方案
等等

这些东西不能说每搞一套容器，咱们都要大刀阔斧重来一遍，这种作法是有问题的。已经作过的东西，遇到新的技术就推倒重来，只能说明之前定义的方案考虑不周全，没有考虑沉淀统一和扩展的状况。

若是咱们自顾自的一遍遍作着功能重复的技术方案，业务能等着咱们吗。

容器层

容器层的迭代核心是为了在解决效率问题的基础上最大化的解决性能和体验问题。

早期的ReactNative模式解决了效率了问题，可是多了一个通讯层（ReactNative是依靠将虚拟DOM的信息传递给原生，而后原生根据这些布局信息构建对应的原生控件树来实现的原生渲染）存在性能问题，并且这种转译的方式须要适配系统版本，带来更多的兼容性问题。

微信后续又推出了小程序方案，在我看来，小程序方案不像是一个技术方案，它更像是一个商业解决方案，解决了平台大流量规范管理和分发的问题，给业务方提供通用的技术解决方案，固然小程序底层的渲染方案也是多种多样的。

后起之秀Flutter解决的痛点是性能能力，它自建了一套GUI系统，底层直接调用Skia图形库进行渲染（与Android的机制同样），进而实现了原生渲染。可是它基于开发效率、性能以及自身生态等因素的考虑最终选择了Dart，这种作法无疑是直接抛弃了繁荣的前端生态，就跨平台容器的发展历史来看，在解决效率与性能的基础上，最大化的拥抱W3C生态，多是将来最好的方向。Flutter目前也推出了Flutter for Web，从它的思路来看，是先打通Android与iOS，再逐步向Web渗透，咱们期待它的表现。

容器技术是动态向前发展的，咱们今年搞Flutter，明年可能还会搞其余技术方案。在方案变迁的过程当中，咱们须要保证业务快速平滑的过分，而不是每次大刀阔斧的再来一遍。

随着手机性能的提高，WebView的性能也愈来愈好，Flutter又为解决性能问题提供了新的思路，一个基础设施完善，体验至上，一码多端的跨平台容器生态值得期待。

最后的最后

欢迎加入本地生活终端技术部！

本地生活终端技术部隶属于阿里本地生活用户技术部，从事客户端技术研发工做，主要负责本地生活饿了么App 和口碑App 的客户端架构、基础中间件、跨平台技术解决方案，以及帐号、首页、全局购物车、收银台、订单列表、红包卡券、直播、短视频等平台化核心业务链路。目前团队规模50+人，咱们依托阿里强大的终端技术底盘，以及本地生活的业务土壤，致力于打造最优秀的O2O技术团队。

招聘本地生活-客户端开发专家/高级技术专家-杭州/上海/北京，欢迎您的加盟！简历发送至 wushi@alibaba-inc.com

附录

相关平台
[1]Flutter pub.dev
（https://pub.dev/flutter/packages）
相关文档
[1]Flutter 官方文档
（https://flutter.dev/docs/get-started/install/macos）
[2]Flutter for Android developers
（https://flutter.dev/docs/get-started/flutter-for/android-devs）
[3]Flutter Widget Doc
（https://flutter.dev/docs/reference/widgets）
[4]Flutter API Doc（https://api.flutter.dev/）
[5]Dart Doc
（https://dart.dev/guides/language）
相关源码
[1]Dart Framework
（https://github.com/flutter/flutter/tree/master/packages）
[2]Flutter Engine
（https://github.com/flutter/engine）
相关资源
[1]Flutter Render Pipeline
（https://www.youtube.com/watch?v=UUfXWzp0-DU）
[2]How Flutter renders Widgets
（https://www.youtube.com/watch?v=996ZgFRENMs）
[3]深刻了解Flutter的高性能图形渲染 video
（https://www.bilibili.com/video/av48772383）
[4]深刻了解Flutter的高性能图形渲染 ppt
（https://files.flutter-io.cn/events/gdd2018/Deep_Dive_into_Flutter_Graphics_Performance.pdf）