flutter之buildowner

BuildOwner主要用来管理Element的状态：

• 在UI更新过程中、管理需要rebuild的Element
• 在有需要rebuild的Element时，通知引擎在下一帧对其rebuild
• 管理处于”inactive”状态的Element

BuildOwner从何而来

@mustCallSuper
void mount(Element parent, dynamic newSlot) {
  _parent = parent;
  _slot = newSlot;
  _depth = _parent != null ? _parent.depth + 1 : 1;
  _active = true;
  if (parent != null) // Only assign ownership if the parent is non-null
    _owner = parent.owner;
  final Key key = widget.key;
  if (key is GlobalKey) {
    key._register(this);
  }
  _updateInheritance();
}

在Element类的mount方法中可以看出，_owner是从parent得到的。

而根元素的_owner则是通过RootRenderObjectElement的assignOwner方法传入创建的BuildOwner。

BuildOwner的创建则是在WidgetsBinding中，并赋值给Element Tree的根节点RenderObjectToWidgetElement，此后逐级传递给子节点。

一般情况下并不需要我们手动实例化BuildOwner

BuildOwner解析

BuildOwner有两个关键成员变量

/// 存储 InactiveElements
final _InactiveElements _inactiveElements = _InactiveElements();
/// 存储 dirtyElements
final List<Element> _dirtyElements = <Element>[];

Dirty Element

dirty element，就是需要更新的Element

例如在StatefulElement里，我们最常用的更新方法就是调用setState

@protected
void setState(VoidCallback fn) {
  assert(fn != null);
  final dynamic result = fn() as dynamic;
  _element.markNeedsBuild();
}

setState执行传入的函数，然后调用Element的markNeedsBuild方法

void markNeedsBuild() {
  assert(owner != null);
  assert(_debugLifecycleState == _ElementLifecycle.active);
  if (dirty)
    return;
  _dirty = true;
  owner.scheduleBuildFor(this);
}

markNeedsBuild方法，将Element的_dirty属性赋值为true，调用BuildOwner的scheduleBuildFor方法，并传入本身。

void scheduleBuildFor(Element element) {
  if (element._inDirtyList) {
    _dirtyElementsNeedsResorting = true;
    return;
  }
  if (!_scheduledFlushDirtyElements && onBuildScheduled != null) {
    _scheduledFlushDirtyElements = true;
    onBuildScheduled();
  }
  _dirtyElements.add(element);
  element._inDirtyList = true;
}

BuildOwner将传入的Element放入_dirtyElements中。

在绘制新的一帧时，WidgetsBinding.drawFrame会调用BuildOwner.buildScope方法

void buildScope(Element context, [ VoidCallback callback ]) {
  if (callback == null && _dirtyElements.isEmpty)
    return;
  Timeline.startSync('Build', arguments: timelineWhitelistArguments);
  try {
    _scheduledFlushDirtyElements = true;
    // 如果有回调，执行回调
    if (callback != null) {
      Element debugPreviousBuildTarget;
      _dirtyElementsNeedsResorting = false;
      try {
        callback();
      } finally {
      }
    }
    // 对dirty elements进行排序，parent在child前面。确保parent先于child被rebuild，以免child被重复rebuild(parent rebuild会递归调用updatechild)
    _dirtyElements.sort(Element._sort);
    _dirtyElementsNeedsResorting = false;
    int dirtyCount = _dirtyElements.length;
    int index = 0;
    while (index < dirtyCount) {
      try {
        // 依次调用rebuild
        _dirtyElements[index].rebuild();
      } catch (e, stack) {
      }
      index += 1;
      if (dirtyCount < _dirtyElements.length || _dirtyElementsNeedsResorting) {
        _dirtyElements.sort(Element._sort);
        _dirtyElementsNeedsResorting = false;
        dirtyCount = _dirtyElements.length;
        while (index > 0 && _dirtyElements[index - 1].dirty) {
          // It is possible for previously dirty but inactive widgets to move right in the list.
          // We therefore have to move the index left in the list to account for this.
          // We don't know how many could have moved. However, we do know that the only possible
          // change to the list is that nodes that were previously to the left of the index have
          // now moved to be to the right of the right-most cleaned node, and we do know that
          // all the clean nodes were to the left of the index. So we move the index left
          // until just after the right-most clean node.
          index -= 1;
        }
      }
    }
  } finally {
    // 清理_dirtyElements
    for (final Element element in _dirtyElements) {
      assert(element._inDirtyList);
      element._inDirtyList = false;
    }
    _dirtyElements.clear();
    _scheduledFlushDirtyElements = false;
    _dirtyElementsNeedsResorting = null;
    Timeline.finishSync();
  }
}

Inactive Elements

是指Element从Element Tree上被移除到dispose之间，或者被重新插入之间的中间状态。

设计inactive状态的主要目的是实现带有global key的Element可以带着状态在树上任意移动

小结

BuildOwner主要用于收集需要rebuild的Element和inactive状态的Element。

在Element更新中非常关键的部分，从此也看出我们的页面是如何触发更新。