Flutter 状态管理之 InheritedWidget 使用和分析

class DataModelWidget extends InheritedWidget {
  const DataModelWidget(
      {super.key,
      required super.child,
      required this.name,
      required this.changeName});

  // 当数据发生改变时，才会通知到子控件
  @override
  bool updateShouldNotify(covariant DataModelWidget oldWidget) {
    return oldWidget.name != name;
  }

  // 定义 static 快捷方法，方便在子控件中获取共享数据
  // 当子控件通过 of 方法使用了 InheritedWidget 中的数据，注册依赖关系
  // 此时数据变动会触发 didChangeDependencies 方法
  static DataModelWidget? of(BuildContext context) {
    return context.dependOnInheritedWidgetOfExactType<DataModelWidget>();
  }

  // 共享的数据
  final String name;
  final Function changeName;
}

class _DashboardState extends State<Dashboard> {
  String _name = "glumes";

  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      home: Scaffold(
        body: SafeArea(
          child: Row(
            children: <Widget>[
              // 初始化 InheritedWidget 并传递对应参数
              DataModelWidget(      
                name: _name,
                changeName: _changeUserName,
                child: const ContentBoard(),
              )
            ],
          ),
        ),
      ),
    );
  }
  // 右边栏调用 _changeUserName 方法修改共享数据的值
  void _changeUserName(String userName) {
    setState(() {
      _name = userName;
    });
  }
}

// 左边栏
Text("名称：${DataModelWidget.of(context)!.name}"),

@override
void didChangeDependencies() {
  super.didChangeDependencies();
  Log.d("left sidebar change dependencies");
}

// 右边栏
ElevatedButton(
  onPressed: () {
    DataModelWidget.of(context)!.changeName("change name ${count.toString()}");
    count++;
  },
  child: const Text("修改名称")),

@override
void didChangeDependencies() {
  super.didChangeDependencies();
  Log.d("right sidebar change dependencies");
}

static DataModelWidget? of2(BuildContext context) {
  return context.getElementForInheritedWidgetOfExactType<DataModelWidget>()!.widget
      as DataModelWidget;
}

// Container 的 build 方法
Widget build(BuildContext context) {
  Widget? current = child;

  final EdgeInsetsGeometry? effectivePadding = _paddingIncludingDecoration;
  if (effectivePadding != null) {
    current = Padding(padding: effectivePadding, child: current);
  }

  if (color != null) {
    current = ColoredBox(color: color!, child: current);
  }

  if (decoration != null) {
    current = DecoratedBox(decoration: decoration!, child: current);
  }

  if (constraints != null) {
    current = ConstrainedBox(constraints: constraints!, child: current);
  }

  if (margin != null) {
    current = Padding(padding: margin!, child: current);
  }

  if (transform != null) {
    current = Transform(transform: transform!, alignment: transformAlignment, child: current);
  }

  return current!;
}

void runApp(Widget app) {
  final WidgetsBinding binding = WidgetsFlutterBinding.ensureInitialized();
  binding
    ..scheduleAttachRootWidget(binding.wrapWithDefaultView(app))
    ..scheduleWarmUpFrame();
}

void scheduleAttachRootWidget(Widget rootWidget) {
  Timer.run(() {
    attachRootWidget(rootWidget);
  });
}

// 最终把传入的 Widget 挂到 RootWidget 下面
void attachRootWidget(Widget rootWidget) {
  attachToBuildOwner(RootWidget(
    debugShortDescription: '[root]',
    child: rootWidget,
  ));
}

// 创建 RootElement 
void attachToBuildOwner(RootWidget widget) {
  final bool isBootstrapFrame = rootElement == null;
  _readyToProduceFrames = true;
  _rootElement = widget.attach(buildOwner!, rootElement as RootElement?);
  if (isBootstrapFrame) {
    SchedulerBinding.instance.ensureVisualUpdate();
  }
}

@override
RootElement createElement() => RootElement(this);

RootElement attach(BuildOwner owner, [ RootElement? element ]) {
  if (element == null) {
    owner.lockState(() {
      element = createElement();
      element!.assignOwner(owner);
    });
    owner.buildScope(element!, () {
      element!.mount(/* parent */ null, /* slot */ null);
    });
  } else {
    element._newWidget = this;
    element.markNeedsBuild();
  }
  return element!;
}

// RootElement 的 mount 实现
void mount(Element? parent, Object? newSlot) {
  super.mount(parent, newSlot);
  _rebuild();
  super.performRebuild(); // clears the "dirty" flag
}

// Element 基类的 mount 实现
void mount(Element? parent, Object? newSlot) {
  // 更新 parent 和 slot 的状态
  _parent = parent;
  _slot = newSlot;
  _lifecycleState = _ElementLifecycle.active;
  _depth = _parent != null ? _parent!.depth + 1 : 1;
  if (parent != null) {
    // Only assign ownership if the parent is non-null. If parent is null
    // (the root node), the owner should have already been assigned.
    // See RootRenderObjectElement.assignOwner().
    _owner = parent.owner;
  }
  final Key? key = widget.key;
  if (key is GlobalKey) {
    owner!._registerGlobalKey(key, this);
  }
  _updateInheritance();
  attachNotificationTree();
}

void _updateInheritance() {
  _inheritedElements = _parent?._inheritedElements;
}

Element? _child;

void _rebuild() {
  try {
    // RootElement 首次创建新的 _child 
    _child = updateChild(_child, (widget as RootWidget).child, /* slot */ null);
  }
}  

Element? updateChild(Element? child, Widget? newWidget, Object? newSlot) {
  final Element newChild;
  if (child != null) {
    // 省略一大串代码
  } else {
    newChild = inflateWidget(newWidget, newSlot);
  }
}

// Element 基类中定义的变量 _inheritedElements 和 _dependencies
PersistentHashMap<Type, InheritedElement>? _inheritedElements;
Set<InheritedElement>? _dependencies;

// Element 基类中的实现
void _updateInheritance() {
  _inheritedElements = _parent?._inheritedElements;
}

// InheritedElement 类中的实现
void _updateInheritance() {
  final PersistentHashMap<Type, InheritedElement> incomingWidgets =
      _parent?._inheritedElements ?? const PersistentHashMap<Type, InheritedElement>.empty();
  _inheritedElements = incomingWidgets.put(widget.runtimeType, this);
}

@override
T? dependOnInheritedWidgetOfExactType<T extends InheritedWidget>({Object? aspect}) {
  // 如果 Widget 树上的父节点有 InheritedWidget ，那么 _inheritedElements 就不会为 null .
  final InheritedElement? ancestor = _inheritedElements == null ? null : _inheritedElements![T];
  if (ancestor != null) {
  // 当前节点和 InheritedWidget 注册依赖关系
    return dependOnInheritedElement(ancestor, aspect: aspect) as T;
  }
  _hadUnsatisfiedDependencies = true;
  return null;
}

@override
InheritedWidget dependOnInheritedElement(InheritedElement ancestor, { Object? aspect }) {
  _dependencies ??= HashSet<InheritedElement>();
  // 当前节点添加依赖的 InheritedElement
  _dependencies!.add(ancestor);
  // InheritedElement 同样也添加被依赖的节点
  ancestor.updateDependencies(this, aspect);
  return ancestor.widget as InheritedWidget;
}

// InheritedElement 更新依赖
class InheritedElement extends ProxyElement {

  final Map<Element, Object?> _dependents = HashMap<Element, Object?>();

  void updateDependencies(Element dependent, Object? aspect) {
    setDependencies(dependent, null);
  }

  void setDependencies(Element dependent, Object? value) {
    _dependents[dependent] = value;
  }
}

@override
InheritedElement? getElementForInheritedWidgetOfExactType<T extends InheritedWidget>() {
  final InheritedElement? ancestor = _inheritedElements == null ? null : _inheritedElements![T];
  return ancestor;
}

class InheritedElement extends ProxyElement {
  void updated(InheritedWidget oldWidget) {
    if ((widget as InheritedWidget).updateShouldNotify(oldWidget)) {
      // 调用基类 ProxyElement 的 updated 方法，从而调用 notifyClients 方法
      super.updated(oldWidget);
    }
  }

  // 通知被依赖的子节点有内容更新了，调用子节点的 didChangeDependencies 方法
  @override
  void notifyClients(InheritedWidget oldWidget) {
    for (final Element dependent in _dependents.keys) {
      notifyDependent(oldWidget, dependent);
    }
  }

  void notifyDependent(covariant InheritedWidget oldWidget, Element dependent) {
    dependent.didChangeDependencies();
  }
}

abstract class ProxyElement extends ComponentElement {
  void updated(covariant ProxyWidget oldWidget) {
    notifyClients(oldWidget);
  }
}

void didChangeDependencies() {
  markNeedsBuild();
}