dependOnInheritedWidgetOfExactType<T extends InheritedWidget> method
- Object? aspect,
Returns the nearest widget of the given type T and creates a dependency
on it, or null if no appropriate widget is found.
The widget found will be a concrete InheritedWidget subclass, and calling dependOnInheritedWidgetOfExactType registers this build context with the returned widget. When that widget changes (or a new widget of that type is introduced, or the widget goes away), this build context is rebuilt so that it can obtain new values from that widget.
This is typically called implicitly from of() static methods, e.g.
Theme.of.
This method should not be called from widget constructors or from State.initState methods, because those methods would not get called again if the inherited value were to change. To ensure that the widget correctly updates itself when the inherited value changes, only call this (directly or indirectly) from build methods, layout and paint callbacks, or from State.didChangeDependencies (which is called immediately after State.initState).
This method should not be called from State.dispose because the element tree is no longer stable at that time. To refer to an ancestor from that method, save a reference to the ancestor in State.didChangeDependencies. It is safe to use this method from State.deactivate, which is called whenever the widget is removed from the tree.
It is also possible to call this method from interaction event handlers (e.g. gesture callbacks) or timers, to obtain a value once, as long as that value is not cached and/or reused later.
Calling this method is O(1) with a small constant factor, but will lead to the widget being rebuilt more often.
Once a widget registers a dependency on a particular type by calling this method, it will be rebuilt, and State.didChangeDependencies will be called, whenever changes occur relating to that widget until the next time the widget or one of its ancestors is moved (for example, because an ancestor is added or removed).
The aspect parameter is only used when T is an
InheritedWidget subclasses that supports partial updates, like
InheritedModel. It specifies what "aspect" of the inherited
widget this context depends on.
Implementation
@override
T? dependOnInheritedWidgetOfExactType<T extends InheritedWidget>({Object? aspect}) {
assert(_debugCheckStateIsActiveForAncestorLookup());
final InheritedElement? ancestor = _inheritedElements?[T];
if (ancestor != null) {
return dependOnInheritedElement(ancestor, aspect: aspect) as T;
}
_hadUnsatisfiedDependencies = true;
return null;
}