Flutter的绘制流程(1)，2024年最新2024最新中高级HarmonyOS鸿蒙面试题目

先自我介绍一下，小编浙江大学毕业，去过华为、字节跳动等大厂，目前阿里P7

深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年最新HarmonyOS鸿蒙全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上鸿蒙开发知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以添加V获取：vip204888 （备注鸿蒙）

正文

当上一阶段中的buildOwner.buildScope(renderViewElement)函数执行完毕后，就会调用RendererBinding的drawFrame函数，该函数实现非常简洁。

//绘制帧
void drawFrame() {
//对指定组件及其子组件进行大小测量及位置确定
pipelineOwner.flushLayout();
pipelineOwner.flushCompositingBits();
pipelineOwner.flushPaint();
renderView.compositeFrame();
pipelineOwner.flushSemantics(); }

其中flushLayout就是进行组件的大小及位置确定，在该函数中会遍历集合_nodesNeedingLayout并调用集合中每个对象的_layoutWithoutResize函数。

void flushLayout() {
try {
while (_nodesNeedingLayout.isNotEmpty) {
final List dirtyNodes = _nodesNeedingLayout;
_nodesNeedingLayout = [];
for (RenderObject node in dirtyNodes…sort((RenderObject a, RenderObject b) => a.depth - b.depth)) {
//调用RenderObject对象的_layoutWithoutResize函数
if (node._needsLayout && node.owner == this)
node._layoutWithoutResize();
}
}
} finally {…}
}

_layoutWithoutResize函数是私有的，所以不存在重写的问题。那么就直接来看该函数。

void _layoutWithoutResize() {
try {
performLayout();
markNeedsSemanticsUpdate();
} catch (e, stack) {…}
_needsLayout = false;
markNeedsPaint();
}

_layoutWithoutResize函数很简单，就直接调用了performLayout函数。

当然，RenderObject对象的size也不是随便确定的，因为在调用RenderObject的layout函数时，会传递一个继承自Constraints的对象。该对象是一个布局约束，由父传给子，子会根据该对象来决定自己的大小。

3.1. 标记RenderObject

当大小及位置确定后，就又会对RenderObject进行一次标记，这次跟上一阶段的标记大同小异，但这次是标记可绘制的RenderObject对象，然后在后面对这些对象进行重新绘制。标记可绘制的RenderObject对象是通过markNeedsPaint函数来实现的，代码如下。

void markNeedsPaint() {
if (_needsPaint)
return;
_needsPaint = true;
if (isRepaintBoundary) {
//标记需要重新绘制的RenderObject对象
//需要绘制当前图层
if (owner != null) {
owner._nodesNeedingPaint.add(this);
owner.requestVisualUpdate();
}
} else if (parent is RenderObject) {
//没有自己的图层，与父类共用同一图层
final RenderObject parent = this.parent;
//遍历其父RenderObject对象
parent.markNeedsPaint();
} else {
//当是RenderView时，需要自己创建新的图层
if (owner != null)
owner.requestVisualUpdate();
}
}

markNeedsPaint函数中涉及到了一个“重绘边界”的概念。在进入和走出重绘边界时，Flutter会强制切换新的图层，这样就可以避免边界内外的互相影响。当然重绘边界也可以在任何节点手动设置，但是一般不需要我们来实现，Flutter提供的控件默认会在需要设置的地方自动设置。

4. compositingBits阶段：

重绘之前的预处理操作，检查RenderObject是否需要重绘。

在组件的大小及位置确定后，就会进入当前阶段。该阶段主要是做一件事，就是将RenderObject树上新增及删除的RenderObject对象标记为“脏”，方便在下一阶段对这些RenderObject对象进行重绘。具体代码实现是在flushCompositingBits函数中，该函数在Layout阶段后立即调用。

void flushCompositingBits() {
…
//将RenderObject对象按照深度进行排序
_nodesNeedingCompositingBitsUpdate.sort((RenderObject a, RenderObject b) => a.depth - b.depth);
for (RenderObject node in _nodesNeedingCompositingBitsUpdate) {
if (node._needsCompositingBitsUpdate && node.owner == this)
//将RenderObject对象及其子对象标记为“脏”
node._updateCompositingBits();
}
_nodesNeedingCompositingBitsUpdate.clear();
…
}

nodesNeedingCompositingBitsUpdate是一个集合，只有RenderObject对象的_needsCompositing为true时，才会添加到该集合中。在RenderObject对象创建时，_needsCompositing的值会根据isRepaintBoundary及alwaysNeedsCompositing来共同判断。

RenderObject() {
//isRepaintBoundary决定当前RenderObject是否与父RenderObject分开绘制，默认为false，其值在当前对象的生命周期内无法修改。也就是判断当前对象是否是绘制边界
//alwaysNeedsCompositing为true表示当前RenderObject会一直重绘，如视频播放，默认为false
_needsCompositing = isRepaintBoundary || alwaysNeedsCompositing;
}

然后在向树中添加或者删除RenderObject对象时会调用adoptChild及dropChild函数，而这两个函数都会调用markNeedsCompositingBitsUpdate函数，也就在markNeedsCompositingBitsUpdate函数内完成了将当前对象添加到集合中的操作。

//向树中添加当前节点
@override
void adoptChild(RenderObject child) {
setupParentData(child);
markNeedsLayout();
//将当前对象的_needsCompositingBitsUpdate值标为true
markNeedsCompositingBitsUpdate();
markNeedsSemanticsUpdate();
super.adoptChild(child);
}
//从树中移除当前节点
@override
void dropChild(RenderObject child) {
child._cleanRelayoutBoundary();
child.parentData.detach();
child.parentData = null;
super.dropChild(child);
markNeedsLayout();
//将当前对象的_needsCompositingBitsUpdate值标为true
markNeedsCompositingBitsUpdate();
markNeedsSemanticsUpdate();
}
//
void markNeedsCompositingBitsUpdate() {
if (_needsCompositingBitsUpdate)
return;
_needsCompositingBitsUpdate = true;
if (parent is RenderObject) {
final RenderObject parent = this.parent;
if (parent._needsCompositingBitsUpdate)
return;
if (!isRepaintBoundary && !parent.isRepaintBoundary) {
parent.markNeedsCompositingBitsUpdate();
return;
}
}
//将当前对象或者其父对象添加到_nodesNeedingCompositingBitsUpdate集合中
if (owner != null)
owner._nodesNeedingCompositingBitsUpdate.add(this);
}

这样就会在调用flushCompositingBits函数时，就会调用_updateCompositingBits函数来判断是否将这些对象及子对象标记为“脏”，然后在下一阶段进行绘制。

void _updateCompositingBits() {
//表示已经处理过，
if (!_needsCompositingBitsUpdate)
return;
final bool oldNeedsCompositing = _needsCompositing;
_needsCompositing = false;
//访问其子对象
visitChildren((RenderObject child) {
child._updateCompositingBits();
if (child.needsCompositing)
_needsCompositing = true;
});
//如果是绘制边界或者需要一直重绘
if (isRepaintBoundary || alwaysNeedsCompositing)
_needsCompositing = true;
if (oldNeedsCompositing != _needsCompositing) {
//将当前对象标记为“脏”，
markNeedsPaint();
}
_needsCompositingBitsUpdate = false;
}

5. 绘制阶段：

根据Widget大小及位置来绘制UI。

通过调用flushPaint函数就可以重绘已经标记的“脏”RenderObject对象及其子对象。

void flushPaint() {
try {
final List dirtyNodes = _nodesNeedingPaint;
_nodesNeedingPaint = [];
//根据节点深度进行排序
for (RenderObject node in dirtyNodes…sort((RenderObject a, RenderObject b) => b.depth - a.depth)) {
if (node._needsPaint && node.owner == this) {
//当前对象是否与layer进行关联
if (node._layer.attached) {
//在图层上绘制UI
PaintingContext.repaintCompositedChild(node);
} else {
//跳过UI绘制，但当前节点为“脏”的状态不会改变
node._skippedPaintingOnLayer();
}
}
}
} finally {}
}

flushPaint函数中，每次遍历“脏”RenderObject对象时，都会进行一次排序，避免重复绘制。然后在判断当前对象是否与Layer进行关联，如果没有关联，则无法进行绘制，但不会清除“脏”标记。下面来看repaintCompositedChild函数的实现。

static void repaintCompositedChild(RenderObject child, { bool
_repaintCompositedChild(
child,
debugAlsoPaintedParent: debugAlsoPaintedParent,
);
}

static void _repaintCompositedChild(
RenderObject child, {
bool debugAlsoPaintedParent = false,
PaintingContext childContext,
}) {
//拿到Layer对象
OffsetLayer childLayer = child._layer;
if (childLayer == null) {
//创建新的Layer对象
child._layer = childLayer = OffsetLayer();
} else {
//移除Layer对象的后继节点
childLayer.removeAllChildren();
}
//创建context对象
childContext ??= PaintingContext(child._layer, child.paintBounds);
//调用paint函数开始绘制
child._paintWithContext(childContext, Offset.zero);
childContext.stopRecordingIfNeeded();
}

5.1. Layer

在该函数中主要是对Layer对象的处理，然后调用_paintWithContext函数，在_paintWithContext函数中就会调用paint这个函数，从而实现UI的绘制。至此，就完成了UI的绘制，下面再来看一个被忽略的对象——Layer。

Layer是“图层”意思，在Flutter中是最容易被忽略但又无比重要的一个类。它非常贴近底层，可以很容易的看到调用Native方法。

Layer跟其他三棵树一样，也是一棵树，有“脏”状态的标记、更新等操作。不同的是，Layer是一个双链表结构，在每个Layer对象中都会指向其前置节点与后置节点（叶子Layer的后置节点为null）。

abstract class Layer extends AbstractNode with DiagnosticableTreeMixin {
//返回父节点
@override
ContainerLayer get parent => super.parent;

//当前节点状态，为true表示当前节点是“脏”数据。需要重绘
bool _needsAddToScene = true;

//将当前节点标记为“脏”
@protected
@visibleForTesting
void markNeedsAddToScene() {
// Already marked. Short-circuit.
if (_needsAddToScene) {
return;
}
_needsAddToScene = true;
}

@protected
bool get alwaysNeedsAddToScene => false;

//这个是一个非常重要的东西，主要用于节点数据的缓存。存储当前节点的渲染数据，如果当前节点不需要更新，就直接拿存储的数据使用。
@protected
ui.EngineLayer get engineLayer => _engineLayer;

//更改当前节点的数据
@protected
set engineLayer(ui.EngineLayer value) {
_engineLayer = value;
if (parent != null && !parent.alwaysNeedsAddToScene) {
//将父节点标记需要更新的状态
parent.markNeedsAddToScene();
}
}
}
ui.EngineLayer _engineLayer;

//更新当前节点状态，如果_needsAddToScene为true，则将当前节点标记为“脏”
@protected
@visibleForTesting
void updateSubtreeNeedsAddToScene() {
_needsAddToScene = _needsAddToScene || alwaysNeedsAddToScene;
}

//指向后置节点
Layer get nextSibling => _nextSibling;
Layer _nextSibling;

//指向前置节点
Layer get previousSibling => _previousSibling;
Layer _previousSibling;

//将子节点从Layer树中移除
@override
void dropChild(AbstractNode child) {
if (!alwaysNeedsAddToScene) {
markNeedsAddToScene();
}
super.dropChild(child);
}
//将当前节点添加到Layer树中
@override
void adoptChild(AbstractNode child) {
if (!alwaysNeedsAddToScene) {
markNeedsAddToScene();
}
super.adoptChild(child);
}

//将当前节点从Layer树中移除
@mustCallSuper
void remove() {
parent?._removeChild(this);
}

void addToScene(ui.SceneBuilder builder, [ Offset layerOffset = Offset.zero ]);

void _addToSceneWithRetainedRendering(ui.SceneBuilder builder) {
//使用当前节点的缓存的数据
if (!_needsAddToScene && _engineLayer != null) {
builder.addRetained(_engineLayer);
return;
}
addToScene(builder);
//将当前节点标记为“干净”的
_needsAddToScene = false;
}
}

5.2. Layer节点的添加

previousSibling与nextSibling分别是Layer的前置节点与后置节点，当向Layer树中添加Layer节点时，也会将当前Layer设置为父节点的后置节点，父节点设置为当前节点的前置节点。这样，就形成了一颗树。

class ContainerLayer extends Layer {
…
//将当前节点及其链表上的所有子节点都加入到Layer树中
@override
void attach(Object owner) {
super.attach(owner);
Layer child = firstChild;
while (child != null) {
child.attach(owner);
child = child.nextSibling;
}
}

//将当前节点及其链表上的所有子节点都从Layer树中移除
@override
void detach() {
super.detach();
Layer child = firstChild;
while (child != null) {
child.detach();
child = child.nextSibling;
}
}
//将child添加到链表中
void append(Layer child) {
adoptChild(child);
child._previousSibling = lastChild;
if (lastChild != null)
lastChild._nextSibling = child;
_lastChild = child;
_firstChild ??= child;
}
…
}

在上述的append函数中就将子节点添加到Layer树并加入到双链表中。在adoptChild函数中最终会调用attach函数，从而完成Layer树的添加。

5.3. Layer的状态更新

class ContainerLayer extends Layer {
…
//更新Layer节点的状态。
@override
void updateSubtreeNeedsAddToScene() {
super.updateSubtreeNeedsAddToScene();
Layer child = firstChild;
while (child != null) {
child.updateSubtreeNeedsAddToScene();
_needsAddToScene = _needsAddToScene || child._needsAddToScene;
child = child.nextSibling;
}
}
…
}

updateSubtreeNeedsAddToScene函数就是更新Layer的状态，可以发现，在更新当前Layer的状态时，也会更新其所有子Layer的状态。

6. compositing阶段：

将UI数据发送给GPU处理。

该阶段主要是将更新后的数据传递给GPU。这时候调用的是compositeFrame函数，该函数很简单，就是调用了一个Native函数。

void compositeFrame() {
Timeline.startSync(‘Compositing’, arguments: timelineWhitelistArguments);
try {
final ui.SceneBuilder builder = ui.SceneBuilder();
final ui.Scene scene = layer.buildScene(builder);
if (automaticSystemUiAdjustment)
_updateSystemChrome();
//更新后数据交给GPU处理
_window.render(scene);
scene.dispose();
} finally {
Timeline.finishSync();
}
}

7. semantics阶段：

与平台的辅助功能相关。

在向GPU发送数据后，Flutter还会调用flushSemantics函数。该函数与系统的辅助功能相关，一般情况下是不做任何处理。

8. finalization阶段：

主要是从Element树中移除无用的Element对象及处理绘制结束回调。

在该阶段，主要是将Element对象从树中移除及处理添加在_postFrameCallbacks集合中的回调函数。由于该回调函数是在绘制结束时调用，所以在该回调函数中，context已经创建成功。

其他：

flushLayout触发布局，将RenderObject树的dirty节点通过调用performLayout方法进行逐一布局，我们先看一下RenderPadding中的实现

@override
void performLayout() {
_resolve();//解析padding参数
if (child == null) {//如果没有child，直接将constraints与padding综合计算得出自己的size
size = constraints.constrain(Size(
_resolvedPadding.left + _resolvedPadding.right,
_resolvedPadding.top + _resolvedPadding.bottom
));
return;
}
final BoxConstraints innerConstraints = constraints.deflate(_resolvedPadding);//将padding减去，生成新的约束innerConstraints
child.layout(innerConstraints, parentUsesSize: true);//用新的约束去布局child
final BoxParentData childParentData = child.parentData;
childParentData.offset = Offset(_resolvedPadding.left, _resolvedPadding.top);//设置childParentData的offset值
size = constraints.constrain(Size(//将constraints与padding以及child的sieze综合计算得出自己的size
_resolvedPadding.left + child.size.width + _resolvedPadding.right,
_resolvedPadding.top + child.size.height + _resolvedPadding.bottom
));
}

可以看到RenderPadding中的布局分两种情况。如果没有child，那么就直接拿parent传过来的约束以及padding来确定自己的大小；否则就先去布局child，让后再拿parent传过来的约束和padding以及child的size来确定自己的大小。RenderPadding是典型的单child的RenderBox，我们看一下多个child的RenderBox。例如RenderFlow

@override
void performLayout() {
size = _getSize(constraints);//直接先确定自己的size
int i = 0;
_randomAccessChildren.clear();
RenderBox child = firstChild;
while (child != null) {//遍历孩子
_randomAccessChildren.add(child);
final BoxConstraints innerConstraints = _delegate.getConstraintsForChild(i, constraints);//获取child的约束，此方法为抽象
child.layout(innerConstraints, parentUsesSize: true);//布局孩子
final FlowParentData childParentData = child.parentData;
childParentData.offset = Offset.zero;
child = childParentData.nextSibling;
i += 1;
}
}

可以看到RenderFlow的size直接就根据约束来确定了，并没去有先布局孩子，所以RenderFlow的size不依赖与孩子，后面依旧是对每一个child依次进行布局。

还有一种比较典型的树尖类型的RenderBox，LeafRenderObjectWidget子类创建的RenderObject对象都是，他们没有孩子，他们才是最终需要渲染的对象，例如

@override
void performLayout() {
size = _sizeForConstraints(constraints);
}

非常简单就通过约束确定自己的大小就结束了。所以performLayout过程就是两点，确定自己的大小以及布局孩子。我们上面提到的都是RenderBox的子类，这些RenderObject约束都是通过BoxConstraints来完成，但是RenderSliver的子类的约束是通过SliverConstraints来完成，虽然他们对child的约束方式不同，但他们在布局过程需要执行的操作都是一致的。

绘制

布局完成了，PipelineOwner就通过flushPaint来进行绘制

void flushPaint() {
try {
final List dirtyNodes = _nodesNeedingPaint;
_nodesNeedingPaint = [];
// 对dirty nodes列表进行排序，最深的在第一位
for (RenderObject node in dirtyNodes…sort((RenderObject a, RenderObject b) => b.depth - a.depth)) {
assert(node._layer != null);
if (node._needsPaint && node.owner == this) {
if (node._layer.attached) {
PaintingContext.repaintCompositedChild(node);
} else {
node._skippedPaintingOnLayer();
}
}
}
} finally {}
}

PaintingContext.repaintCompositedChild(node)会调用到child._paintWithContext(childContext, Offset.zero)方法，进而调用到child的paint方法，我们来看一下第一次绘制的情况，dirty的node就应该是RenderView，跟进RenderView的paint方法

@override
void paint(PaintingContext context, Offset offset) {
if (child != null)
context.paintChild(child, offset);//直接绘制child
}

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加V获取：vip204888 （备注鸿蒙）

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

} else {
node._skippedPaintingOnLayer();
}
}
}
} finally {}
}

PaintingContext.repaintCompositedChild(node)会调用到child._paintWithContext(childContext, Offset.zero)方法，进而调用到child的paint方法，我们来看一下第一次绘制的情况，dirty的node就应该是RenderView，跟进RenderView的paint方法

@override
void paint(PaintingContext context, Offset offset) {
if (child != null)
context.paintChild(child, offset);//直接绘制child
}

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加V获取：vip204888 （备注鸿蒙）
[外链图片转存中…(img-G7asVIRO-1713286321767)]

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！