1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

void main() {
  runApp(const MyApp());
}

class MyApp extends StatelessWidget {
  const MyApp({super.key});

  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'Flutter Demo',
      theme: ThemeData(
        colorScheme: ColorScheme.fromSeed(seedColor: Colors.deepPurple),
        useMaterial3: true,
      ),
      home: const MyPage(title: '计数器'),
    );
  }
}

class MyPage extends StatefulWidget {
  const MyPage({super.key, required this.title});

  final String title;

  @override
  State<MyPage> createState() => _MyPageState();
}

class _MyPageState extends State<MyPage> {
  int _counter = 0;

  void _increment() {
    setState(() {
      _counter++;
    });
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        backgroundColor: Theme.of(context).colorScheme.inversePrimary,
        title: Text(widget.title),
      ),
      body: MyChild(counter: _counter),
      floatingActionButton: FloatingActionButton(
        onPressed: _increment,
        tooltip: 'increment',
        child: const Icon(Icons.add),
      ),
    );
  }
}

class MyChild extends StatelessWidget {
  final int counter;

  const MyChild({super.key, required this.counter});

  @override
  Widget build(BuildContext context) {
    debugPrint('build');
    return Center(
      child: Text(
        '$counter',
        style: const TextStyle(
          fontSize: 100,
          color: Colors.black,
        ),
      ),
    );
  }
}

1

I/flutter ( 7101): build

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

/// 有效地沿树传播信息的widgets的基类。
/// Base class for widgets that efficiently propagate information down the tree.
///
/// 要从构建上下文获取特定类型的inherited widget的最近实例，请使用BuildContext.dependOnInheritedWidgetOfExactType。
/// To obtain the nearest instance of a particular type of inherited widget from
/// a build context, use [BuildContext.dependOnInheritedWidgetOfExactType].
///
/// 当以这种方式引用Inherited widgets时，当Inherited widgets本身更改状态时，将导致使用者重建。
/// Inherited widgets, when referenced in this way, will cause the consumer to
/// rebuild when the inherited widget itself changes state.
///
/// 以下是名为FrogColor的inherited widget的骨架
/// The following is a skeleton of an inherited widget called `FrogColor`:
///
/// ```dart
/// class FrogColor extends InheritedWidget {
///   const FrogColor({
///     super.key,
///     required this.color,
///     required super.child,
///   });
///
///   final Color color;
///
///   static FrogColor? maybeOf(BuildContext context) {
///     return context.dependOnInheritedWidgetOfExactType<FrogColor>();
///   }
///
///   static FrogColor of(BuildContext context) {
///     final FrogColor? result = maybeOf(context);
///     assert(result != null, 'No FrogColor found in context');
///     return result!;
///   }
///
///   @override
///   bool updateShouldNotify(FrogColor oldWidget) => color != oldWidget.color;
/// }
/// ```
/// {@end-tool}
///
/// ## 实现“of”和“maybeOf”方法
/// ## Implementing the `of` and `maybeOf` methods
///
/// 约定是在InheritedWidget上提供两个静态方法of和maybeOf ，它们调用BuildContext.dependOnInheritedWidgetOfExactType。
/// 这允许类定义自己的后备逻辑，以防范围内没有widget
/// The convention is to provide two static methods, `of` and `maybeOf`, on the
/// [InheritedWidget] which call
/// [BuildContext.dependOnInheritedWidgetOfExactType]. This allows the class to
/// define its own fallback logic in case there isn't a widget in scope.
///
/// `of` 方法通常返回一个不可为 null 的实例，并在未找到 [InheritedWidget] 时断言，而 `maybeOf` 方法则返回一个可为 null 的实例，并在未找到 [InheritedWidget] 时返回 null。 
/// “of”方法通常通过内部调用“maybeOf”来实现。
/// The `of` method typically returns a non-nullable instance and asserts if the
/// [InheritedWidget] isn't found, and the `maybeOf` method returns a nullable
/// instance, and returns null if the [InheritedWidget] isn't found. The `of`
/// method is typically implemented by calling `maybeOf` internally.
///
/// 有时，“of”和“maybeOf”方法返回一些数据，而不是inherited widget本身；例如，在这种情况下，它可能返回一个 [Color] 而不是“FrogColor”小部件。
/// Sometimes, the `of` and `maybeOf` methods return some data rather than the
/// inherited widget itself; for example, in this case it could have returned a
/// [Color] instead of the `FrogColor` widget.
///
/// 有时，inherited widget是另一个类的实现细节，因此是私有的。
/// 在这种情况下，“of”和“maybeOf”方法通常在公共类上实现。
/// 例如，[Theme]被实现为[StatelessWidget]，它构建了一个私有inherited widget； [Theme.of] 使用 [BuildContext.dependOnInheritedWidgetOfExactType] 查找inherited widget，然后返回其中的 [ThemeData]。
/// Occasionally, the inherited widget is an implementation detail of another
/// class, and is therefore private. The `of` and `maybeOf` methods in that case
/// are typically implemented on the public class instead. For example, [Theme]
/// is implemented as a [StatelessWidget] that builds a private inherited
/// widget; [Theme.of] looks for that private inherited widget using
/// [BuildContext.dependOnInheritedWidgetOfExactType] and then returns the
/// [ThemeData] inside it.
///
/// ## 调用“of”或“maybeOf”方法
/// ## Calling the `of` or `maybeOf` methods
///
/// 使用“of”或“maybeOf”方法时，“context”必须是 [InheritedWidget] 的后代，这意味着它必须位于树中 [InheritedWidget]“下方”。
/// When using the `of` or `maybeOf` methods, the `context` must be a descendant
/// of the [InheritedWidget], meaning it must be "below" the [InheritedWidget]
/// in the tree.
///
/// 在此示例中，使用的“context”是来自 [Builder] 的context，它是“FrogColor” widget的子级，因此这是可行的。
/// In this example, the `context` used is the one from the [Builder], which is
/// a child of the `FrogColor` widget, so this works.
///
/// ```dart
/// // continuing from previous example...
/// class MyPage extends StatelessWidget {
///   const MyPage({super.key});
///
///   @override
///   Widget build(BuildContext context) {
///     return Scaffold(
///       body: FrogColor(
///         color: Colors.green,
///         child: Builder(
///           builder: (BuildContext innerContext) {
///             return Text(
///               'Hello Frog',
///               style: TextStyle(color: FrogColor.of(innerContext).color),
///             );
///           },
///         ),
///       ),
///     );
///   }
/// }
/// ```
/// 在此示例中，使用的“context”是来自“MyOtherPage” widget的上下文，该widget是“FrogColor”widget的父级，因此这不起作用，并且会在调用“FrogColor.of”时断言。
/// In this example, the `context` used is the one from the `MyOtherPage`
/// widget, which is a parent of the `FrogColor` widget, so this does not work,
/// and will assert when `FrogColor.of` is called.
///
/// ```dart
/// // continuing from previous example...
///
/// class MyOtherPage extends StatelessWidget {
///   const MyOtherPage({super.key});
///
///   @override
///   Widget build(BuildContext context) {
///     return Scaffold(
///       body: FrogColor(
///         color: Colors.green,
///         child: Text(
///           'Hello Frog',
///           style: TextStyle(color: FrogColor.of(context).color),
///         ),
///       ),
///     );
///   }
/// }
/// ```

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

abstract class InheritedWidget extends ProxyWidget {

  const InheritedWidget({ super.key, required super.child });

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

  /// 框架是否应该通知继承自此widget的widgets
  /// Whether the framework should notify widgets that inherit from this widget.
  ///
  /// 当这个widget被重建时，有时我们需要重建从这个widget继承的widgets，但有时我们不需要。
  /// 例如，如果这个widget保存的数据与“oldWidget”保存的数据相同，那么我们不需要重建继承“oldWidget”保存数据的widgets。
  /// When this widget is rebuilt, sometimes we need to rebuild the widgets that
  /// inherit from this widget but sometimes we do not. For example, if the data
  /// held by this widget is the same as the data held by `oldWidget`, then we
  /// do not need to rebuild the widgets that inherited the data held by
  /// `oldWidget`.
  ///
  /// 框架通过使用先前占据树中此位置的widget作为参数来调用此函数来区分这些情况。
  /// 保证给定的widget与该对象具有相同的 [runtimeType]。
  /// The framework distinguishes these cases by calling this function with the
  /// widget that previously occupied this location in the tree as an argument.
  /// The given widget is guaranteed to have the same [runtimeType] as this
  /// object.
  @protected
  bool updateShouldNotify(covariant InheritedWidget oldWidget);
}

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104

void main() {
  runApp(const MyApp());
}

class MyApp extends StatelessWidget {
  const MyApp({super.key});

  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'Flutter Demo',
      theme: ThemeData(
        colorScheme: ColorScheme.fromSeed(seedColor: Colors.deepPurple),
        useMaterial3: true,
      ),
      home: const MyPage(title: '计数器'),
    );
  }
}

class MyPage extends StatefulWidget {
  const MyPage({super.key, required this.title});

  final String title;

  @override
  State<MyPage> createState() => _MyPageState();
}

class _MyPageState extends State<MyPage> {
  int _counter = 0;

  void _increment() {
    setState(() {
      _counter++;
    });
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        backgroundColor: Theme.of(context).colorScheme.inversePrimary,
        title: Text(widget.title),
      ),
      body: MyParent(
        counter: _counter,
        child: const MyChild(),
      ),
      floatingActionButton: FloatingActionButton(
        onPressed: _increment,
        tooltip: 'increment',
        child: const Icon(Icons.add),
      ),
    );
  }
}

class MyParent extends InheritedWidget {
  final int counter;

  const MyParent({super.key, required this.counter, required super.child});

  static MyParent? maybeOf(BuildContext context) =>
      context.dependOnInheritedWidgetOfExactType<MyParent>();

  static MyParent of(BuildContext context) {
    final MyParent? result = maybeOf(context);
    assert(result != null, 'No MyParent found in context');
    return result!;
  }

  @override
  bool updateShouldNotify(covariant MyParent oldWidget) => counter != oldWidget.counter;
}

class MyChild extends StatefulWidget {
  const MyChild({super.key});

  @override
  State<MyChild> createState() => _MyChildState();
}

class _MyChildState extends State<MyChild> {
  @override
  void didChangeDependencies() {
    super.didChangeDependencies();
    debugPrint('didChangeDependencies');
  }

  @override
  Widget build(BuildContext context) {
    debugPrint('build');
    return Center(
      child: Text(
        '${MyParent.of(context).counter}',
        style: const TextStyle(
          fontSize: 100,
          color: Colors.black,
        ),
      ),
    );
  }
}

1
2

I/flutter ( 7101): didChangeDependencies
I/flutter ( 7101): build

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

@override
T? dependOnInheritedWidgetOfExactType<T extends InheritedWidget>({Object? aspect}) {
  assert(_debugCheckStateIsActiveForAncestorLookup());
  // 分析1
  final InheritedElement? ancestor = _inheritedElements == null ? null : _inheritedElements![T];
  // 分析2
  if (ancestor != null) {
    return dependOnInheritedElement(ancestor, aspect: aspect) as T;
  }
  // 分析3
  _hadUnsatisfiedDependencies = true;
  return null;
}

1

PersistentHashMap<Type, InheritedElement>? _inheritedElements;

1
2
3
4

void _updateInheritance() {
  assert(_lifecycleState == _ElementLifecycle.active);
  _inheritedElements = _parent?._inheritedElements;
}

1
2
3
4
5
6
7

@override
void _updateInheritance() {
  assert(_lifecycleState == _ElementLifecycle.active);
  final PersistentHashMap<Type, InheritedElement> incomingWidgets =
      _parent?._inheritedElements ?? const PersistentHashMap<Type, InheritedElement>.empty();
  _inheritedElements = incomingWidgets.put(widget.runtimeType, this);
}

1
2
3
4
5
6
7

@override
InheritedWidget dependOnInheritedElement(InheritedElement ancestor, { Object? aspect }) {
  _dependencies ??= HashSet<InheritedElement>();
  _dependencies!.add(ancestor);
  ancestor.updateDependencies(this, aspect);
  return ancestor.widget as InheritedWidget;
}

1

Set<InheritedElement>? _dependencies;

1
2
3
4

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

1
2
3
4

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

1

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

@override
T? getInheritedWidgetOfExactType<T extends InheritedWidget>() {
  return getElementForInheritedWidgetOfExactType<T>()?.widget as T?;
}

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

1
2
3

if (ancestor != null) {
  return dependOnInheritedElement(ancestor, aspect: aspect) as T;
}

1
2
3
4
5
6
7
8
9

@override
void update(ProxyWidget newWidget) {
  final ProxyWidget oldWidget = widget as ProxyWidget;
  assert(widget != newWidget);
  super.update(newWidget);
  assert(widget == newWidget);
  updated(oldWidget);
  rebuild(force: true);
}

1
2
3
4
5
6

@override
void updated(InheritedWidget oldWidget) {
  if ((widget as InheritedWidget).updateShouldNotify(oldWidget)) {
    super.updated(oldWidget);
  }
}

1
2
3
4

@protected
void updated(covariant ProxyWidget oldWidget) {
  notifyClients(oldWidget);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

@override
void notifyClients(InheritedWidget oldWidget) {
  assert(_debugCheckOwnerBuildTargetExists('notifyClients'));
  for (final Element dependent in _dependents.keys) {
    assert(() {
      // check that it really is our descendant
      Element? ancestor = dependent._parent;
      while (ancestor != this && ancestor != null) {
        ancestor = ancestor._parent;
      }
      return ancestor == this;
    }());
    // check that it really depends on us
    assert(dependent._dependencies!.contains(this));
    notifyDependent(oldWidget, dependent);
  }
}

1
2
3
4

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

1
2
3
4
5

@override
void didChangeDependencies() {
  super.didChangeDependencies();
  _didChangeDependencies = true;
}

1
2
3
4
5
6

@mustCallSuper
void didChangeDependencies() {
  assert(_lifecycleState == _ElementLifecycle.active); // otherwise markNeedsBuild is a no-op
  assert(_debugCheckOwnerBuildTargetExists('didChangeDependencies'));
  markNeedsBuild();
}

1
2
3
4
5
6
7
8

@override
void performRebuild() {
  if (_didChangeDependencies) {
    state.didChangeDependencies();
    _didChangeDependencies = false;
  }
  super.performRebuild();
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

@mustCallSuper
void deactivate() {
  assert(_lifecycleState == _ElementLifecycle.active);
  assert(_widget != null); // Use the private property to avoid a CastError during hot reload.
  if (_dependencies != null && _dependencies!.isNotEmpty) {
    for (final InheritedElement dependency in _dependencies!) {
      dependency._dependents.remove(this);
    }
    // 为了方便起见，我们实际上并没有清除此处的列表，尽管它不再代表我们注册的内容。
    // 如果我们永远不会被重用，那也没关系。
    // 如果这样做，那么我们将在 activate() 中清除该列表。
    // 这样做的好处是，它允许 Element 的 activate() 实现根据我们这里是否有依赖关系来决定是否重建。
    // For expediency, we don't actually clear the list here, even though it's
    // no longer representative of what we are registered with. If we never
    // get re-used, it doesn't matter. If we do, then we'll clear the list in
    // activate(). The benefit of this is that it allows Element's activate()
    // implementation to decide whether to rebuild based on whether we had
    // dependencies here.
  }
  _inheritedElements = null;
  _lifecycleState = _ElementLifecycle.inactive;
}

1
2
3
4
5
6

@override
void notifyClients(InheritedWidget oldWidget) {
  for (final Element dependent in _dependents.keys) {
    notifyDependent(oldWidget, dependent);
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

@mustCallSuper
void activate() {
  assert(_lifecycleState == _ElementLifecycle.inactive);
  assert(owner != null);
  // 是否有依赖关系
  final bool hadDependencies = (_dependencies != null && _dependencies!.isNotEmpty) || _hadUnsatisfiedDependencies;
  _lifecycleState = _ElementLifecycle.active;
  // 我们在 deactivate 中注销了我们的依赖项，但从未清除过列表
  // We unregistered our dependencies in deactivate, but never cleared the list.
  // 由于我们将被重用，所以现在让我们清除我们的列表。
  // Since we're going to be reused, let's clear our list now.
  _dependencies?.clear();
  _hadUnsatisfiedDependencies = false;
  _updateInheritance();
  attachNotificationTree();
  if (_dirty) {
    owner!.scheduleBuildFor(this);
  }
  // 如果有有依赖关系，执行didChangeDependencies进行重建
  if (hadDependencies) {
    didChangeDependencies();
  }
}

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116

/// 一种 [InheritedWidget]，旨在用作模型的基类，其依赖项可能仅依赖于整个模型的一部分或“方面”。
/// An [InheritedWidget] that's intended to be used as the base class for models
/// whose dependents may only depend on one part or "aspect" of the overall
/// model.
///
/// 当inherited widget根据 [InheritedWidget.updateShouldNotify] 发生更改时，inherited widget的依赖项将无条件重建。
/// 此widget类似，只是依赖项不会无条件重建。
/// An inherited widget's dependents are unconditionally rebuilt when the
/// inherited widget changes per [InheritedWidget.updateShouldNotify]. This
/// widget is similar except that dependents aren't rebuilt unconditionally.
///
/// 依赖于 [InheritedModel] 的Widgets用一个值来限定其依赖关系，该值指示它们所依赖的模型的“方面”。
/// 当重建模型时，依赖项也将被重建，但前提是模型中存在与它们提供的方面相对应的更改。
/// Widgets that depend on an [InheritedModel] qualify their dependence with a
/// value that indicates what "aspect" of the model they depend on. When the
/// model is rebuilt, dependents will also be rebuilt, but only if there was a
/// change in the model that corresponds to the aspect they provided.
///
/// 类型参数“T”是模型方面对象的类型。
/// The type parameter `T` is the type of the model aspect objects.
/// 
/// Widgets使用静态方法创建对 [InheritedModel] 的依赖：[InheritedModel.inheritFrom]。
/// 此方法的“context”参数定义模型更改时将重建的子树。
/// 通常，“inheritFrom”方法是从特定于模型的静态“maybeOf”或“of”方法调用的，这是许多查找事物的 Flutter 框架类中存在的约定。例如：
/// Widgets create a dependency on an [InheritedModel] with a static method:
/// [InheritedModel.inheritFrom]. This method's `context` parameter defines the
/// subtree that will be rebuilt when the model changes. Typically the
/// `inheritFrom` method is called from a model-specific static `maybeOf` or
/// `of` methods, a convention that is present in many Flutter framework classes
/// which look things up. For example:
///
/// ```dart
/// class MyModel extends InheritedModel<String> {
///   const MyModel({super.key, required super.child});
///
///   // ...
///   static MyModel? maybeOf(BuildContext context, [String? aspect]) {
///     return InheritedModel.inheritFrom<MyModel>(context, aspect: aspect);
///   }
///
///   // ...
///   static MyModel of(BuildContext context, [String? aspect]) {
///     final MyModel? result = maybeOf(context, aspect);
///     assert(result != null, 'Unable to find an instance of MyModel...');
///     return result!;
///   }
/// }
/// ```
///
/// 调用 `MyModel.of(context, 'foo')` 或 `MyModel.maybeOf(context, 'foo')` 意味着仅当 `MyModel` 的 `foo` aspect发生更改时才应该重建 `context`。
/// 如果“aspect”为空，则模型支持所有aspects。
/// Calling `MyModel.of(context, 'foo')` or `MyModel.maybeOf(context,
/// 'foo')` means that `context` should only be rebuilt when the `foo` aspect of
/// `MyModel` changes. If the `aspect` is null, then the model supports all
/// aspects.
///
/// {@tool snippet}
/// 重建inherited model时， [updateShouldNotify] 和 [updateShouldNotifyDependent] 方法用于决定应该重建什么。
/// 如果 [updateShouldNotify] 返回 true，则针对每个依赖项及其依赖的aspect对象集测试inherited model的 [updateShouldNotifyDependent] 方法。
/// [updateShouldNotify Dependent] 方法必须将aspectj依赖项集与模型本身的更改进行比较。例如：
/// When the inherited model is rebuilt the [updateShouldNotify] and
/// [updateShouldNotifyDependent] methods are used to decide what should be
/// rebuilt. If [updateShouldNotify] returns true, then the inherited model's
/// [updateShouldNotifyDependent] method is tested for each dependent and the
/// set of aspect objects it depends on. The [updateShouldNotifyDependent]
/// method must compare the set of aspect dependencies with the changes in the
/// model itself. For example:
///
/// ```dart
/// class ABModel extends InheritedModel<String> {
///   const ABModel({
///    super.key,
///    this.a,
///    this.b,
///    required super.child,
///   });
///
///   final int? a;
///   final int? b;
///
///   @override
///   bool updateShouldNotify(ABModel oldWidget) {
///     return a != oldWidget.a || b != oldWidget.b;
///   }
///
///   @override
///   bool updateShouldNotifyDependent(ABModel oldWidget, Set<String> dependencies) {
///     return (a != oldWidget.a && dependencies.contains('a'))
///       || (b != oldWidget.b && dependencies.contains('b'));
///   }
///
///   // ...
/// }
/// ```
/// {@end-tool}
///
/// 在前面的示例中，[updateShouldNotify Dependent] 检查的依赖项只是传递给“dependOnInheritedWidgetOfExactType”的aspect字符串。
/// 它们被表示为一个 [Set]，因为一个 Widget 可以依赖于模型的多个aspect。
/// 如果一个widget依赖于模型但没有指定某个aspect，那么模型中的更改将导致widget无条件地重建。
/// In the previous example the dependencies checked by
/// [updateShouldNotifyDependent] are just the aspect strings passed to
/// `dependOnInheritedWidgetOfExactType`. They're represented as a [Set] because
/// one Widget can depend on more than one aspect of the model. If a widget
/// depends on the model but doesn't specify an aspect, then changes in the
/// model will cause the widget to be rebuilt unconditionally.
///
/// {@tool dartpad}
/// 此示例演示如何实现 [InheritedModel] 以基于合格的依赖关系重建widget。
/// 当点击“调整logo”按钮时，仅重建logo widget，而背景widget不受影响。
/// This example shows how to implement [InheritedModel] to rebuild a widget
/// based on a qualified dependence. When tapped on the "Resize Logo" button
/// only the logo widget is rebuilt while the background widget remains
/// unaffected.
///
/// ** See code in examples/api/lib/widgets/inherited_model/inherited_model.0.dart **
abstract class InheritedModel<T> extends InheritedWidget

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

/// [Listenable] [notifier] 的inherited widget，当触发 [notifier] 时更新其依赖项。
/// An inherited widget for a [Listenable] [notifier], which updates its
/// dependencies when the [notifier] is triggered.
///
/// 这是 [InheritedWidget] 的变体，专门用于 [Listenable] 的子类，例如 [ChangeNotifier] 或 [ValueNotifier]。
/// This is a variant of [InheritedWidget], specialized for subclasses of
/// [Listenable], such as [ChangeNotifier] or [ValueNotifier].
///
/// 每当[notifier]发送通知或每当[notifier]的身份发生变化时，依赖项都会收到通知。
/// Dependents are notified whenever the [notifier] sends notifications, or
/// whenever the identity of the [notifier] changes.
///
/// 多个通知被合并，因此即使 [notifier] 在两帧之间触发多次，依赖项也仅重建一次。
/// Multiple notifications are coalesced, so that dependents only rebuild once
/// even if the [notifier] fires multiple times between two frames.
///
/// 通常，该类是一个类的子类，该类提供一个“of”静态方法，该方法使用该类调用 [BuildContext.dependOnInheritedWidgetOfExactType]。
/// Typically this class is subclassed with a class that provides an `of` static
/// method that calls [BuildContext.dependOnInheritedWidgetOfExactType] with that
/// class.
///
/// [updateShouldNotify] 方法也可以被重写，以在 [notifier] 本身发生更改的情况下更改逻辑。
/// 如果 [notifier] 发生更改，则使用旧的 [notifier] 调用 [updateShouldNotify] 方法。
/// 当它返回 true 时，依赖项被标记为需要在该框架中重建。
/// The [updateShouldNotify] method may also be overridden, to change the logic
/// in the cases where [notifier] itself is changed. The [updateShouldNotify]
/// method is called with the old [notifier] in the case of the [notifier] being
/// changed. When it returns true, the dependents are marked as needing to be
/// rebuilt this frame.
///
/// {@tool dartpad}
/// 此示例显示了三个旋转方块，它们使用祖先 [InheritedNotifier] (`SpinModel`) 上的notifier的值来进行旋转。
/// [InheritedNotifier] 不需要了解子级，并且 `notifier` 参数不需要是动画控制器，它可以是任何实现 [Listenable] 的东西（如 [ChangeNotifier]）。
/// This example shows three spinning squares that use the value of the notifier
/// on an ancestor [InheritedNotifier] (`SpinModel`) to give them their
/// rotation. The [InheritedNotifier] doesn't need to know about the children,
/// and the `notifier` argument doesn't need to be an animation controller, it
/// can be anything that implements [Listenable] (like a [ChangeNotifier]).
///
/// `SpinModel` 类可以轻松地侦听另一个 [Listenable] 对象（例如，保留输入或数据模型值的值的单独对象），并从中获取值。
/// 后代也不需要拥有 [InheritedNotifier] 的实例即可使用它，他们只需要知道他们的祖先中有一个实例即可。
/// 这有助于将widgets与其模型解耦。
/// The `SpinModel` class could just as easily listen to another object (say, a
/// separate object that keeps the value of an input or data model value) that
/// is a [Listenable], and get the value from that. The descendants also don't
/// need to have an instance of the [InheritedNotifier] in order to use it, they
/// just need to know that there is one in their ancestry. This can help with
/// decoupling widgets from their models.
///
/// ** See code in examples/api/lib/widgets/inherited_notifier/inherited_notifier.0.dart **
/// {@end-tool}
abstract class InheritedNotifier<T extends Listenable> extends InheritedWidget

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

/// 一个 [InheritedWidget]，定义 [child] 子树所依赖的视觉属性，例如颜色和文本样式。
/// An [InheritedWidget] that defines visual properties like colors
/// and text styles, which the [child]'s subtree depends on.
///
/// [captureAll] 和 [CapturedThemes.wrap] 使用 [wrap] 方法来构造一个widget，该widget将把子项包装在widget树的指定部分中存在的所有inherited themes中。
/// The [wrap] method is used by [captureAll] and [CapturedThemes.wrap] to
/// construct a widget that will wrap a child in all of the inherited themes
/// which are present in a specified part of the widget tree.
///
/// 在与其内置环境不同的上下文中显示的widget，就像新路由或overlay的内容一样，将能够看到它所构建的上下文的祖先inherited themes。
/// A widget that's shown in a different context from the one it's built in,
/// like the contents of a new route or an overlay, will be able to see the
/// ancestor inherited themes of the context it was built in.
///
/// {@tool dartpad}
/// 此示例演示了如何使用 InheritedTheme.capture() 来使用inherited themes来包装新route的内容，这些主题在构建route时存在，但在实际显示route时不存在。
/// This example demonstrates how `InheritedTheme.capture()` can be used
/// to wrap the contents of a new route with the inherited themes that
/// are present when the route was built - but are not present when route
/// is actually shown.
///
/// 如果相同的代码在没有 `InheritedTheme.capture() 的情况下运行，则新route的 Text widget将继承“omething must be wrong”反馈文本样式，而不是 MyApp 中定义的默认文本样式。
/// If the same code is run without `InheritedTheme.capture(), the
/// new route's Text widget will inherit the "something must be wrong"
/// fallback text style, rather than the default text style defined in MyApp.
///
/// ** See code in examples/api/lib/widgets/inherited_theme/inherited_theme.0.dart **
/// {@end-tool}
abstract class InheritedTheme extends InheritedWidget