text stringlengths 1 474 |
|---|
layout and building widgets as well as data structures that make tree |
surgery efficient and that have a number of constant-factor optimizations. |
With some additional details, this design also makes it easy for developers |
to create infinite scrolling lists using callbacks that build exactly those |
widgets that are visible to the user.<topic_end> |
<topic_start> |
Aggressive composability |
One of the most distinctive aspects of Flutter is its aggressive |
composability. Widgets are built by composing other widgets, |
which are themselves built out of progressively more basic widgets. |
For example, Padding is a widget rather than a property of other widgets. |
As a result, user interfaces built with Flutter consist of many, |
many widgets.The widget building recursion bottoms out in RenderObjectWidgets, |
which are widgets that create nodes in the underlying render tree. |
The render tree is a data structure that stores the geometry of the user |
interface, which is computed during layout and used during painting and |
hit testing. Most Flutter developers do not author render objects directly |
but instead manipulate the render tree using widgets.In order to support aggressive composability at the widget layer, |
Flutter uses a number of efficient algorithms and optimizations at |
both the widget and render tree layers, which are described in the |
following subsections.<topic_end> |
<topic_start> |
Sublinear layout |
With a large number of widgets and render objects, the key to good |
performance is efficient algorithms. Of paramount importance is the |
performance of layout, which is the algorithm that determines the |
geometry (for example, the size and position) of the render objects. |
Some other toolkits use layout algorithms that are O(N²) or worse |
(for example, fixed-point iteration in some constraint domain). |
Flutter aims for linear performance for initial layout, and sublinear |
layout performance in the common case of subsequently updating an |
existing layout. Typically, the amount of time spent in layout should |
scale more slowly than the number of render objects.Flutter performs one layout per frame, and the layout algorithm works |
in a single pass. Constraints are passed down the tree by parent |
objects calling the layout method on each of their children. |
The children recursively perform their own layout and then return |
geometry up the tree by returning from their layout method. Importantly, |
once a render object has returned from its layout method, that render |
object will not be visited again1 |
until the layout for the next frame. This approach combines what might |
otherwise be separate measure and layout passes into a single pass and, |
as a result, each render object is visited at most |
twice2 during layout: once on the way |
down the tree, and once on the way up the tree.Flutter has several specializations of this general protocol. |
The most common specialization is RenderBox, which operates in |
two-dimensional, cartesian coordinates. In box layout, the constraints |
are a min and max width and a min and max height. During layout, |
the child determines its geometry by choosing a size within these bounds. |
After the child returns from layout, the parent decides the child’s |
position in the parent’s coordinate system3. |
Note that the child’s layout cannot depend on its position, |
as the position is not determined until after the child |
returns from the layout. As a result, the parent is free to reposition |
the child without needing to recompute its layout.More generally, during layout, the only information that flows from |
parent to child are the constraints and the only information that |
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, |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.