Datasets:
Ekhlass
/
flutter_docs

Dataset card Data Studio Files
xet
 Community
1
text
stringlengths
1
372
flows from child to parent is the geometry. these invariants can reduce
the amount of work required during layout:
if the child has not marked its own layout as dirty, the child can
return immediately from layout, cutting off the walk, as long as the
parent gives the child the same constraints as the child received
during the previous layout.
whenever a parent calls a child’s layout method, the parent indicates
whether it uses the size information returned from the child. if,
as often happens, the parent does not use the size information,
then the parent need not recompute its layout if the child selects
a new size because the parent is guaranteed that the new size will
conform to the existing constraints.
tight constraints are those that can be satisfied by exactly one
valid geometry. for example, if the min and max widths are equal to
each other and the min and max heights are equal to each other,
the only size that satisfies those constraints is one with that
width and height. if the parent provides tight constraints,
then the parent need not recompute its layout whenever the child
recomputes its layout, even if the parent uses the child’s size
in its layout, because the child cannot change size without new
constraints from its parent.
a render object can declare that it uses the constraints provided
by the parent only to determine its geometry. such a declaration
informs the framework that the parent of that render object does
not need to recompute its layout when the child recomputes its layout
even if the constraints are not tight and even if the parent’s
layout depends on the child’s size, because the child cannot change
size without new constraints from its parent.
as a result of these optimizations, when the render object tree contains
dirty nodes, only those nodes and a limited part of the subtree around
them are visited during layout.
<topic_end>
<topic_start>
sublinear widget building
similar to the layout algorithm, flutter’s widget building algorithm
is sublinear. after being built, the widgets are held by the element
tree, which retains the logical structure of the user interface.
the element tree is necessary because the widgets themselves are
immutable, which means (among other things), they cannot remember their
parent or child relationships with other widgets. the element tree also
holds the state objects associated with stateful widgets.
in response to user input (or other stimuli), an element can become dirty,
for example if the developer calls setState() on the associated state
object. the framework keeps a list of dirty elements and jumps directly
to them during the build phase, skipping over clean elements. during
the build phase, information flows unidirectionally down the element
tree, which means each element is visited at most once during the build
phase. once cleaned, an element cannot become dirty again because,
by induction, all its ancestor elements are also
clean4.
because widgets are immutable, if an element has not marked itself as
dirty, the element can return immediately from build, cutting off the walk,
if the parent rebuilds the element with an identical widget. moreover,
the element need only compare the object identity of the two widget
references in order to establish that the new widget is the same as
the old widget. developers exploit this optimization to implement the
reprojection pattern, in which a widget includes a prebuilt child
widget stored as a member variable in its build.
during build, flutter also avoids walking the parent chain using
InheritedWidgets. if widgets commonly walked their parent chain,
for example to determine the current theme color, the build phase
would become O(N²) in the depth of the tree, which can be quite
large due to aggressive composition. to avoid these parent walks,
the framework pushes information down the element tree by maintaining
a hash table of InheritedWidgets at each element. typically, many
elements will reference the same hash table, which changes only at
elements that introduce a new InheritedWidget.
<topic_end>
<topic_start>
linear reconciliation
contrary to popular belief, flutter does not employ a tree-diffing
algorithm. instead, the framework decides whether to reuse elements by
examining the child list for each element independently using an O(N)
algorithm. the child list reconciliation algorithm optimizes for the
following cases:
the general approach is to match up the beginning and end of both child
lists by comparing the runtime type and key of each widget,
potentially finding a non-empty range in the middle of each list
that contains all the unmatched children. the framework then places
the children in the range in the old child list into a hash table
based on their keys. next, the framework walks the range in the new
child list and queries the hash table by key for matches. unmatched
children are discarded and rebuilt from scratch whereas matched children
are rebuilt with their new widgets.
<topic_end>
<topic_start>
tree surgery
reusing elements is important for performance because elements own
two critical pieces of data: the state for stateful widgets and the
underlying render objects. when the framework is able to reuse an element,
the state for that logical part of the user interface is preserved
and the layout information computed previously can be reused,
often avoiding entire subtree walks. in fact, reusing elements is
so valuable that flutter supports non-local tree mutations that
preserve state and layout information.
developers can perform a non-local tree mutation by associating a GlobalKey
with one of their widgets. each global key is unique throughout the
entire application and is registered with a thread-specific hash table.
during the build phase, the developer can move a widget with a global
key to an arbitrary location in the element tree. rather than building