id
stringlengths 14
17
| text
stringlengths 23
1.11k
| source
stringlengths 35
114
|
|---|---|---|
755388d97e71-2 | TextSelectionThemeData
cursorColor:
Colors
red
selectionColor:
Colors
green
selectionHandleColor:
Colors
blue
Default changes
If you weren’t using these properties explicitly,
but depended on the previous default colors used
for text selection you can add a new field to your
ThemeData for your app to return to the old defaults
as shown:
// Old defaults for a light theme
ThemeData
textSelectionTheme:
TextSelectionThemeData
cursorColor:
const
Color
fromRGBO
66
133
244
1.0
),
selectionColor:
const | https://docs.flutter.dev/release/breaking-changes/text-selection-theme/index.html |
755388d97e71-3 | ),
selectionColor:
const
Color
0xff90caf9
),
selectionHandleColor:
const
Color
0xff64b5f6
),
// Old defaults for a dark theme
ThemeData
textSelectionTheme:
TextSelectionThemeData
cursorColor:
const
Color
fromRGBO
66
133
244
1.0
),
selectionColor:
const
Color
0xff64ffda
),
selectionHandleColor:
const | https://docs.flutter.dev/release/breaking-changes/text-selection-theme/index.html |
755388d97e71-4 | ),
selectionHandleColor:
const
Color
0xff1de9b6
),
If you are fine with the new defaults,
but have failing golden file tests, you
can update your master golden files using the
following command:
test
-update-goldens
Timeline
Landed in version: 1.23.0-4.0.pre
In stable release: 2.0.0
References
API documentation:
TextSelectionThemeData
ThemeData
Relevant PRs:
PR 62014: TextSelectionTheme support | https://docs.flutter.dev/release/breaking-changes/text-selection-theme/index.html |
4d93fec24c1b-0 | ThemeData's accent properties have been deprecated
Summary
Context
Description of change
Migration guide
Application theme
accentColor
accentColorBrightness
accentTextTheme
accentIconTheme
Timeline
References
Summary
The ThemeData accentColor, accentColorBrightness, accentIconTheme and
accentTextTheme properties have been deprecated.
Material Design spec no longer specifies or uses an “accent”
color for the Material components. The default values for component
colors are derived from the overall theme’s
color scheme. The
secondary color is now typically used instead of
onSecondary color is used when a contrasting
color is needed.
Context
This was a small part of the Material Theme System Updates project. | https://docs.flutter.dev/release/breaking-changes/theme-data-accent-properties/index.html |
4d93fec24c1b-1 | This was a small part of the Material Theme System Updates project.
As of Flutter 1.17, the ThemeData accent properties - accentColor,
accentColorBrightness, accentIconTheme, and accentTextTheme - were no
longer used by the Material library. They had been replaced by
dependencies on the theme’s colorScheme and textTheme properties as
part of the long-term goal of making the default configurations of the
material components depend almost exclusively on these two
properties.
The motivation for these changes is to make the theme system easier to
understand and use. The default colors for all components are to be
defined by the components themselves and based on the color
scheme. The defaults for specific component types can be overridden
with component-specific themes like FloatingActionButtonThemeData or
CheckBoxTheme. Previously, properties like accentColor were used by a
handful of component types and only in some situations, which made it
difficult to understand the implications of overriding them.
Description of change | https://docs.flutter.dev/release/breaking-changes/theme-data-accent-properties/index.html |
4d93fec24c1b-2 | Description of change
The ThemeData accentColor, accentColorBrightness, accentIconTheme and
accentTextTheme properties have been deprecated because the Material
library no longer uses them.
Migration guide
Application theme
ThemeData values no longer need to specify accentColor,
accentColorBrightness, accentIconTheme, or accentTextTheme.
To configure the appearance of the material components in about the
same way as before, specify the color scheme’s secondary color
instead of accentColor.
Code before migration:
MaterialApp
theme:
ThemeData
accentColor:
myColor
),
// ...
);
Code after migration:
final
ThemeData
theme
ThemeData
(); | https://docs.flutter.dev/release/breaking-changes/theme-data-accent-properties/index.html |
4d93fec24c1b-3 | theme
ThemeData
();
MaterialApp
theme:
theme
copyWith
colorScheme:
theme
colorScheme
copyWith
secondary:
myColor
),
),
//...
accentColor
The closest backwards compatible ColorScheme color is
ColorScheme.secondary. To hew most closely to the latest Material
Design guidelines one can substitute ColorScheme.primary instead.
If a contrasting color is needed then use ColorScheme.onSecondary.
Custom components that used to look up the theme’s accentColor, can look up
the ColorScheme.secondary instead.
Code before migration:
Color
myColor
Theme
of | https://docs.flutter.dev/release/breaking-changes/theme-data-accent-properties/index.html |
4d93fec24c1b-4 | myColor
Theme
of
context
accentColor
Code after migration:
Color
myColor
Theme
of
context
colorScheme
secondary
accentColorBrightness
The static ThemeData.estimateBrightnessForColor() method can be used
to compute the brightness of any color.
accentTextTheme
This was white TextStyles for dark themes, black
TextStyles for light themes. In most cases textTheme can be used
instead. A common idiom was to refer to one TextStyle from
accentTextTheme, since the text style’s color was guaranteed to contrast
well with the accent color (now ColorScheme.secondaryColor). To get
the same result now, specify the text style’s color as
ColorScheme.onSecondary: | https://docs.flutter.dev/release/breaking-changes/theme-data-accent-properties/index.html |
4d93fec24c1b-5 | Code before migration:
TextStyle
style
Theme
of
context
accentTextTheme
headline1
Code after migration:
final
ThemeData
theme
Theme
of
context
);
TextStyle
style
theme
textTheme
headline1
copyWith
color:
theme
colorScheme
onSecondary
accentIconTheme | https://docs.flutter.dev/release/breaking-changes/theme-data-accent-properties/index.html |
4d93fec24c1b-6 | onSecondary
accentIconTheme
This property had only been used to configure the color of icons
within a FloatingActionButton. It’s now possible to configure the icon
color directly or with the FloatingActionButtonThemeData. See
FloatingActionButton and ThemeData’s accent properties.
Timeline
Landed in version: 2.3.0-0.1.pre
In stable release: 2.5
References
API documentation:
ColorScheme
FloatingActionButton
FloatingActionButtonThemeData
TextStyle
TextTheme
Theme
ThemeData
Relevant issues:
Issue #56918
Relevant PRs:
PR #81336
Other:
Material Theme System Updates | https://docs.flutter.dev/release/breaking-changes/theme-data-accent-properties/index.html |
d794e2617d0f-0 | ThemeData's toggleableActiveColor property has been deprecated
Summary
Context
Description of change
Migration guide
Timeline
References
Summary
Context
The migration of widgets that depend on ThemeData.toggleableActiveColor
to ColorScheme.secondary caused the toggleableActiveColor property
to be unnecessary. This property will eventually be removed, as per Flutter’s
deprecation policy.
Description of change
The widgets using ThemeData.toggleableActiveColor color for the
active/selected state now use ColorScheme.secondary.
Migration guide
Toggleable widgets’ active/selected color can generally be customized in 3 ways
Using ThemeData’s ColorScheme.secondary. | https://docs.flutter.dev/release/breaking-changes/toggleable-active-color/index.html |
d794e2617d0f-1 | Using ThemeData’s ColorScheme.secondary.
Using components themes SwitchThemeData, ListTileThemeData, CheckboxThemeData,
and RadioThemeData.
By customizing the widget’s color properties.
Code before migration:
MaterialApp
theme:
ThemeData
toggleableActiveColor:
myColor
),
// ...
);
Code after migration:
final
ThemeData
theme
ThemeData
();
MaterialApp
theme:
theme
copyWith
switchTheme:
SwitchThemeData
thumbColor:
MaterialStateProperty
resolveWith
Color
>( | https://docs.flutter.dev/release/breaking-changes/toggleable-active-color/index.html |
d794e2617d0f-2 | resolveWith
Color
>(
Set
MaterialState
states
if
states
contains
MaterialState
disabled
))
return
null
if
states
contains
MaterialState
selected
))
return
myColor
return
null
}),
trackColor:
MaterialStateProperty
resolveWith
Color
>(
Set
MaterialState
states
if
states
contains
MaterialState
disabled
)) | https://docs.flutter.dev/release/breaking-changes/toggleable-active-color/index.html |
d794e2617d0f-3 | MaterialState
disabled
))
return
null
if
states
contains
MaterialState
selected
))
return
myColor
return
null
}),
),
radioTheme:
RadioThemeData
fillColor:
MaterialStateProperty
resolveWith
Color
>(
Set
MaterialState
states
if
states
contains
MaterialState
disabled
))
return
null
if
states
contains
MaterialState | https://docs.flutter.dev/release/breaking-changes/toggleable-active-color/index.html |
d794e2617d0f-4 | states
contains
MaterialState
selected
))
return
myColor
return
null
}),
),
checkboxTheme:
CheckboxThemeData
fillColor:
MaterialStateProperty
resolveWith
Color
>(
Set
MaterialState
states
if
states
contains
MaterialState
disabled
))
return
null
if
states
contains
MaterialState
selected
))
return
myColor
return | https://docs.flutter.dev/release/breaking-changes/toggleable-active-color/index.html |
d794e2617d0f-5 | return
myColor
return
null
}),
),
),
//...
Timeline
In stable release: 3.7
References
API documentation:
ThemeData.toggleableActiveColor
ColorScheme.secondary
Relevant issues:
Switch widget color doesn’t use ColorScheme
Relevant PRs:
Deprecate toggleableActiveColor. | https://docs.flutter.dev/release/breaking-changes/toggleable-active-color/index.html |
2cc52fb00a77-0 | Trackpad gestures can trigger GestureRecognizer
Summary
Context
Description of change
Migration guide
For gesture interactions suitable for trackpad usage
Using GestureDetector
Using GestureRecognizer and Listener
Using raw Listener
For gesture interactions not suitable for trackpad usage
Using GestureDetector
Using RawGestureRecognizer
Using GestureRecognizer and Listener
Timeline
References
Summary
Trackpad gestures on most platforms now send PointerPanZoom sequences and
can trigger pan, drag, and scale GestureRecognizer callbacks.
Context | https://docs.flutter.dev/release/breaking-changes/trackpad-gestures/index.html |
2cc52fb00a77-1 | Context
Scrolling on Flutter Desktop prior to version 3.3.0 used PointerScrollEvent
messages to represent discrete scroll deltas. This system worked well for mouse
scroll wheels, but wasn’t a good fit for trackpad scrolling. Trackpad scrolling
is expected to cause momentum, which depends not only on the scroll deltas, but
also the timing of when fingers are released from the trackpad. In addition, trackpad
pinching-to-zoom could not be represented.
This means both that code designed only for touch interactions might trigger upon
trackpad interaction, and that code designed to handle all desktop scrolling
might now only trigger upon mouse scrolling, and not trackpad scrolling.
Description of change
The Flutter engine has been updated on all possible platforms to recognize
trackpad gestures and send them to the framework as PointerPanZoom events
instead of as PointerScrollSignal events. PointerScrollSignal events will
still be used to represent scrolling on a mouse wheel. | https://docs.flutter.dev/release/breaking-changes/trackpad-gestures/index.html |
2cc52fb00a77-2 | Depending on the platform and specific trackpad model, the new system might not
be used, if not enough data is provided to the Flutter engine by platform APIs.
This includes on Windows, where trackpad gesture support is dependent on the
trackpad’s driver, and the Web platform, where not enough data is provided by
browser APIs, and trackpad scrolling must still use the old `PointerScrollSignal
system.
Developers should be prepared to receive both types of events and ensure their apps
or packages handle them in the appropriate manner.
Listener now has three new callbacks: onPointerPanZoomStart,
onPointerPanZoomUpdate, and onPointerPanZoomEnd which can be used to observe
trackpad scrolling and zooming events.
void
main
()
runApp
Foo
());
class
Foo
extends
StatelessWidget
@override
Widget | https://docs.flutter.dev/release/breaking-changes/trackpad-gestures/index.html |
2cc52fb00a77-3 | StatelessWidget
@override
Widget
build
BuildContext
context
return
Listener
onPointerSignal:
PointerSignalEvent
event
if
event
is
PointerScrollEvent
debugPrint
'mouse scrolled
${event.scrollDelta}
);
},
onPointerPanZoomStart:
PointerPanZoomStartEvent
event
debugPrint
'trackpad scroll started'
);
},
onPointerPanZoomUpdate:
PointerPanZoomUpdateEvent
event
debugPrint
'trackpad scrolled | https://docs.flutter.dev/release/breaking-changes/trackpad-gestures/index.html |
2cc52fb00a77-4 | event
debugPrint
'trackpad scrolled
${event.panDelta}
);
},
onPointerPanZoomEnd:
PointerPanZoomEndEvent
event
debugPrint
'trackpad scroll ended'
);
},
child:
Container
()
);
PointerPanZoomUpdateEvent contains a pan field to represent the cumulative
pan of the current gesture, a panDelta field to represent the difference in pan
since the last event, a scale event to represent the cumulative zoom of the
current gesture, and a rotation event to represent the cumulative rotation
(in radians) of the current gesture. | https://docs.flutter.dev/release/breaking-changes/trackpad-gestures/index.html |
2cc52fb00a77-5 | GestureRecognizers now have methods to all the trackpad events from one
continuous trackpad gesture. Calling the addPointerPanZoom method on a
GestureRecognizer with a PointerPanZoomStartEvent will cause the recognizer
to register its interest in that trackpad interaction, and resolve conflicts
between multiple GestureRecognizers that could potentially respond to the
gesture.
The following example shows the proper use of Listener and GestureRecognizer
to respond to trackpad interactions.
void
main
()
runApp
Foo
());
class
Foo
extends
StatefulWidget
late
final
PanGestureRecognizer
recognizer
@override
void
initState
()
super
initState
(); | https://docs.flutter.dev/release/breaking-changes/trackpad-gestures/index.html |
2cc52fb00a77-6 | super
initState
();
recognizer
PanGestureRecognizer
()
onStart
_onPanStart
onUpdate
_onPanUpdate
onEnd
_onPanEnd
void
_onPanStart
DragStartDetails
details
debugPrint
'onStart'
);
void
_onPanUpdate
DragUpdateDetails
details
debugPrint
'onUpdate'
);
void
_onPanEnd
DragEndDetails
details
debugPrint
'onEnd'
);
@override
Widget | https://docs.flutter.dev/release/breaking-changes/trackpad-gestures/index.html |
2cc52fb00a77-7 | );
@override
Widget
build
BuildContext
context
return
Listener
onPointerDown:
recognizer
addPointer
onPointerPanZoomStart:
recognizer
addPointerPanZoom
child:
Container
()
);
When using GestureDetector, this is done automatically, so code such as the
following example will issue its gesture update callbacks in response to both
touch and trackpad panning.
void
main
()
runApp
Foo
());
class
Foo
extends
StatelessWidget
@override
Widget | https://docs.flutter.dev/release/breaking-changes/trackpad-gestures/index.html |
2cc52fb00a77-8 | StatelessWidget
@override
Widget
build
BuildContext
context
return
GestureDetector
onPanStart:
details
debugPrint
'onStart'
);
},
onPanUpdate:
details
debugPrint
'onUpdate'
);
},
onPanEnd:
details
debugPrint
'onEnd'
);
child:
Container
()
);
Migration guide
Migration steps depend on whether you want each gesture interaction in your
app to be usable via a trackpad, or whether it should be restricted to only
touch and mouse usage. | https://docs.flutter.dev/release/breaking-changes/trackpad-gestures/index.html |
2cc52fb00a77-9 | For gesture interactions suitable for trackpad usage
Using GestureDetector
No change is needed, GestureDetector automatically processes trackpad
gesture events and triggers callbacks if recognized.
Using GestureRecognizer and Listener
Ensure that onPointerPanZoomStart is passed through to each recognizer from the
Listener. The addPointerPanZoom method of `GestureRecognizer must be called
for it to show interest and start tracking each trackpad gesture.
Code before migration:
void
main
()
runApp
Foo
());
class
Foo
extends
StatefulWidget
late
final
PanGestureRecognizer
recognizer
@override
void
initState
()
super | https://docs.flutter.dev/release/breaking-changes/trackpad-gestures/index.html |
2cc52fb00a77-10 | initState
()
super
initState
();
recognizer
PanGestureRecognizer
()
onStart
_onPanStart
onUpdate
_onPanUpdate
onEnd
_onPanEnd
void
_onPanStart
DragStartDetails
details
debugPrint
'onStart'
);
void
_onPanUpdate
DragUpdateDetails
details
debugPrint
'onUpdate'
);
void
_onPanEnd
DragEndDetails
details
debugPrint
'onEnd'
); | https://docs.flutter.dev/release/breaking-changes/trackpad-gestures/index.html |
2cc52fb00a77-11 | debugPrint
'onEnd'
);
@override
Widget
build
BuildContext
context
return
Listener
onPointerDown:
recognizer
addPointer
child:
Container
()
);
Code after migration:
void
main
()
runApp
Foo
());
class
Foo
extends
StatefulWidget
late
final
PanGestureRecognizer
recognizer
@override
void
initState
()
super
initState | https://docs.flutter.dev/release/breaking-changes/trackpad-gestures/index.html |
2cc52fb00a77-12 | ()
super
initState
();
recognizer
PanGestureRecognizer
()
onStart
_onPanStart
onUpdate
_onPanUpdate
onEnd
_onPanEnd
void
_onPanStart
DragStartDetails
details
debugPrint
'onStart'
);
void
_onPanUpdate
DragUpdateDetails
details
debugPrint
'onUpdate'
);
void
_onPanEnd
DragEndDetails
details
debugPrint
'onEnd'
);
@override | https://docs.flutter.dev/release/breaking-changes/trackpad-gestures/index.html |
2cc52fb00a77-13 | 'onEnd'
);
@override
Widget
build
BuildContext
context
return
Listener
onPointerDown:
recognizer
addPointer
onPointerPanZoomStart:
recognizer
addPointerPanZoom
child:
Container
()
);
Using raw Listener
The following code using PointerScrollSignal will no longer be called upon all
desktop scrolling. PointerPanZoomUpdate events should be captured to receive
trackpad gesture data.
Code before migration:
void
main
()
runApp
Foo
());
class
Foo
extends | https://docs.flutter.dev/release/breaking-changes/trackpad-gestures/index.html |
2cc52fb00a77-14 | class
Foo
extends
StatelessWidget
@override
Widget
build
BuildContext
context
return
Listener
onPointerSignal:
PointerSignalEvent
event
if
event
is
PointerScrollEvent
debugPrint
'scroll wheel event'
);
child:
Container
()
);
Code after
void
main
()
runApp
Foo
());
class
Foo
extends
StatelessWidget
@override | https://docs.flutter.dev/release/breaking-changes/trackpad-gestures/index.html |
2cc52fb00a77-15 | extends
StatelessWidget
@override
Widget
build
BuildContext
context
return
Listener
onPointerSignal:
PointerSignalEvent
event
if
event
is
PointerScrollEvent
debugPrint
'scroll wheel event'
);
},
onPointerPanZoomUpdate:
PointerPanZoomUpdateEvent
event
debugPrint
'trackpad scroll event'
);
child:
Container
()
); | https://docs.flutter.dev/release/breaking-changes/trackpad-gestures/index.html |
2cc52fb00a77-16 | Container
()
);
Please note: Use of raw Listener in this way could cause conflicts with other
gesture interactions as it doesn’t participate in the gesture disambiguation arena.
For gesture interactions not suitable for trackpad usage
Using GestureDetector
Code before migration:
void
main
()
runApp
Foo
());
class
Foo
extends
StatelessWidget
@override
Widget
build
BuildContext
context
return
GestureDetector
onPanStart:
details
debugPrint
'onStart'
);
},
onPanUpdate: | https://docs.flutter.dev/release/breaking-changes/trackpad-gestures/index.html |
2cc52fb00a77-17 | );
},
onPanUpdate:
details
debugPrint
'onUpdate'
);
},
onPanEnd:
details
debugPrint
'onEnd'
);
child:
Container
()
);
Code after migration (Flutter 3.3.0):
// Example of code after the change.
void
main
()
runApp
Foo
());
class
Foo
extends
StatelessWidget
@override
Widget
build
BuildContext
context
return | https://docs.flutter.dev/release/breaking-changes/trackpad-gestures/index.html |
2cc52fb00a77-18 | BuildContext
context
return
RawGestureDetector
gestures:
PanGestureRecognizer:
GestureRecognizerFactoryWithHandlers
PanGestureRecognizer
>(
()
PanGestureRecognizer
supportedDevices:
PointerDeviceKind
touch
PointerDeviceKind
mouse
PointerDeviceKind
stylus
PointerDeviceKind
invertedStylus
// Do not include PointerDeviceKind.trackpad
),
recognizer
recognizer
onStart
details
debugPrint
'onStart'
);
onUpdate
details
debugPrint | https://docs.flutter.dev/release/breaking-changes/trackpad-gestures/index.html |
2cc52fb00a77-19 | onUpdate
details
debugPrint
'onUpdate'
);
onEnd
details
debugPrint
'onEnd'
);
};
},
),
},
child:
Container
()
);
Code after migration: (Flutter 3.4.0):
void
main
()
runApp
Foo
());
class
Foo
extends
StatelessWidget
@override
Widget
build
BuildContext
context
return
GestureDetector | https://docs.flutter.dev/release/breaking-changes/trackpad-gestures/index.html |
2cc52fb00a77-20 | context
return
GestureDetector
supportedDevices:
PointerDeviceKind
touch
PointerDeviceKind
mouse
PointerDeviceKind
stylus
PointerDeviceKind
invertedStylus
// Do not include PointerDeviceKind.trackpad
},
onPanStart:
details
debugPrint
'onStart'
);
},
onPanUpdate:
details
debugPrint
'onUpdate'
);
},
onPanEnd:
details
debugPrint
'onEnd'
);
child:
Container | https://docs.flutter.dev/release/breaking-changes/trackpad-gestures/index.html |
2cc52fb00a77-21 | );
child:
Container
()
);
Using RawGestureRecognizer
Explicitly ensure that supportedDevices
doesn’t include PointerDeviceKind.trackpad.
Code before migration:
void
main
()
runApp
Foo
());
class
Foo
extends
StatelessWidget
@override
Widget
build
BuildContext
context
return
RawGestureDetector
gestures:
PanGestureRecognizer:
GestureRecognizerFactoryWithHandlers
PanGestureRecognizer
>(
()
PanGestureRecognizer
(), | https://docs.flutter.dev/release/breaking-changes/trackpad-gestures/index.html |
2cc52fb00a77-22 | ()
PanGestureRecognizer
(),
recognizer
recognizer
onStart
details
debugPrint
'onStart'
);
onUpdate
details
debugPrint
'onUpdate'
);
onEnd
details
debugPrint
'onEnd'
);
};
},
),
},
child:
Container
()
);
Code after migration:
// Example of code after the change.
void
main
()
runApp
Foo
()); | https://docs.flutter.dev/release/breaking-changes/trackpad-gestures/index.html |
2cc52fb00a77-23 | runApp
Foo
());
class
Foo
extends
StatelessWidget
@override
Widget
build
BuildContext
context
return
RawGestureDetector
gestures:
PanGestureRecognizer:
GestureRecognizerFactoryWithHandlers
PanGestureRecognizer
>(
()
PanGestureRecognizer
supportedDevices:
PointerDeviceKind
touch
PointerDeviceKind
mouse
PointerDeviceKind
stylus
PointerDeviceKind
invertedStylus
// Do not include PointerDeviceKind.trackpad
), | https://docs.flutter.dev/release/breaking-changes/trackpad-gestures/index.html |
2cc52fb00a77-24 | // Do not include PointerDeviceKind.trackpad
),
recognizer
recognizer
onStart
details
debugPrint
'onStart'
);
onUpdate
details
debugPrint
'onUpdate'
);
onEnd
details
debugPrint
'onEnd'
);
};
},
),
},
child:
Container
()
);
Using GestureRecognizer and Listener | https://docs.flutter.dev/release/breaking-changes/trackpad-gestures/index.html |
2cc52fb00a77-25 | ()
);
Using GestureRecognizer and Listener
After upgrading to Flutter 3.3.0, there won’t be a change in behavior, as
addPointerPanZoom must be called on each GestureRecognizer to allow
it to track gestures. The following code won’t receive pan gesture callbacks
when the trackpad is scrolled:
void
main
()
runApp
Foo
());
class
Foo
extends
StatefulWidget
late
final
PanGestureRecognizer
recognizer
@override
void
initState
()
super
initState
();
recognizer
PanGestureRecognizer
() | https://docs.flutter.dev/release/breaking-changes/trackpad-gestures/index.html |
2cc52fb00a77-26 | recognizer
PanGestureRecognizer
()
onStart
_onPanStart
onUpdate
_onPanUpdate
onEnd
_onPanEnd
void
_onPanStart
DragStartDetails
details
debugPrint
'onStart'
);
void
_onPanUpdate
DragUpdateDetails
details
debugPrint
'onUpdate'
);
void
_onPanEnd
DragEndDetails
details
debugPrint
'onEnd'
);
@override
Widget
build
BuildContext
context | https://docs.flutter.dev/release/breaking-changes/trackpad-gestures/index.html |
2cc52fb00a77-27 | build
BuildContext
context
return
Listener
onPointerDown:
recognizer
addPointer
// recognizer.addPointerPanZoom is not called
child:
Container
()
);
Timeline
Landed in version: 3.3.0-0.0.pre
In stable release: 3.3.0
References
API documentation:
GestureDetector
RawGestureDetector
GestureRecognizer
Design Document
Flutter Trackpad Gestures
Relevant issues:
Issue 23604
Relevant PRs:
Support trackpad gestures in framework
iPad trackpad gestures | https://docs.flutter.dev/release/breaking-changes/trackpad-gestures/index.html |
2cc52fb00a77-28 | Support trackpad gestures in framework
iPad trackpad gestures
Linux trackpad gestures
Mac trackpad gestures
Win32 trackpad gestures
ChromeOS/Android trackpad gestures | https://docs.flutter.dev/release/breaking-changes/trackpad-gestures/index.html |
d697292de87b-0 | Use maxLengthEnforcement instead of maxLengthEnforced
Summary
Context
Description of change
Migration guide
Default values of maxLengthEnforcement
To enforce the limit all the time
To not enforce the limitation
To enforce the limit, but not for composing text
Be wary of assuming input will not use composing regions
Timeline
References
Summary
To control the behavior of maxLength in the
LengthLimitingTextInputFormatter, use maxLengthEnforcement
instead of the now-deprecated maxLengthEnforced.
Context
The maxLengthEnforced parameter was used to decide
whether text fields should truncate the input value
when it reaches the maxLength limit, or whether
(for TextField and TextFormField)
a warning message should instead be shown in the
character count when the length of the user input
exceeded maxLength. | https://docs.flutter.dev/release/breaking-changes/use-maxLengthEnforcement-instead-of-maxLengthEnforced/index.html |
d697292de87b-1 | However, to enter CJK characters, some input methods
require the user to enter a sequence of Latin characters
into the text field, then turn this sequence
into desired CJK characters (a referred to as text composition).
The Latin sequence is usually longer than the resulting CJK characters,
so setting a hard maximum character limit on a text field may mean
the user is unable to finish the text composition normally due to the
maxLength character limit.
Text composition is also used by some input methods to
indicate that the text within the highlighted composing
region is being actively edited, even when entering
Latin characters. For example, Gboard’s English keyboard on Android
(as with many other input methods on Android) puts the current word
in a composing region. | https://docs.flutter.dev/release/breaking-changes/use-maxLengthEnforcement-instead-of-maxLengthEnforced/index.html |
d697292de87b-2 | To improve the input experience in these scenarios,
a new tri-state enum, MaxLengthEnforcement, was introduced.
Its values describe supported strategies for handling
active composing regions when applying a
LengthLimitingTextInutFormatter.
A new maxLengthEnforcement parameter that uses
this enum has been added to text fields to replace
the boolean maxLengthEnforced parameter.
With the new enum parameter,
developers can choose different strategies
based on the type of the content the text field expects.
For more information, see the docs for maxLength and
MaxLengthEnforcement.
The default value of the maxLengthEnforcement
parameter is inferred from the TargetPlatform
of the application, to conform to the platform’s conventions:
Description of change | https://docs.flutter.dev/release/breaking-changes/use-maxLengthEnforcement-instead-of-maxLengthEnforced/index.html |
d697292de87b-3 | Description of change
Added a maxLengthEnforcement parameter using the
new enum type MaxLengthEnforcement,
as a replacement for the now-deprecated boolean
maxLengthEnforced parameter on
TextField, TextFormField, CupertinoTextField, and
LengthLimitingTextInputFormatter classes.
Migration guide
Using the default behavior for the current platform is recommended,
since this will be the behavior most familiar to the user.
Default values of maxLengthEnforcement
Android, Windows: MaxLengthEnforcement.enforced.
The native behavior of these platforms is enforced.
The inputting value will be truncated whether
the user is entering with composition or not. | https://docs.flutter.dev/release/breaking-changes/use-maxLengthEnforcement-instead-of-maxLengthEnforced/index.html |
d697292de87b-4 | iOS, MacOS: MaxLengthEnforcement.truncateAfterCompositionEnds.
These platforms do not have a “maximum length”
feature and therefore require that developers implement
the behavior themselves. No standard convention seems
to have evolved on these platforms. We have chosen
to allow the composition to exceed the maximum length
to avoid breaking CJK input.
Web and Linux: MaxLengthEnforcement.truncateAfterCompositionEnds.
While there is no standard on these platforms
(and many implementation exist with conflicting behavior),
the common convention seems to be to allow the composition
to exceed the maximum length by default.
Fuchsia: MaxLengthEnforcement.truncateAfterCompositionEnds.
There is no platform convention on this platform yet,
so we have chosen to default to the convention that is
least likely to result in data loss.
To enforce the limit all the time | https://docs.flutter.dev/release/breaking-changes/use-maxLengthEnforcement-instead-of-maxLengthEnforced/index.html |
d697292de87b-5 | To enforce the limit all the time
To enforce the limit that always truncate the value when
it reaches the limit (for example, when entering a
verification code), use MaxLengthEnforcement.enforced in
editable text fields.
This option may give suboptimal user experience when used
with input methods that rely on text composition.
Consider using the truncateAfterCompositionEnds
option when the text field expects arbitrary user input
which may contain CJK characters.
See the Context section for more information.
Code before migration:
TextField
maxLength:
or
TextField
maxLength:
maxLengthEnforced:
true
Code after migration:
TextField
maxLength:
maxLengthEnforcement:
MaxLengthEnforcement
enforced | https://docs.flutter.dev/release/breaking-changes/use-maxLengthEnforcement-instead-of-maxLengthEnforced/index.html |
d697292de87b-6 | MaxLengthEnforcement
enforced
To not enforce the limitation
To show a max length error in TextField,
but not truncate when the limit is exceeded,
use MaxLengthEnforcement.none instead of
maxLengthEnforced: false.
Code before migration:
TextField
maxLength:
maxLengthEnforced:
false
Code after migration:
TextField
maxLength:
maxLengthEnforcement:
MaxLengthEnforcement
none
For CupertinoTextField, which isn’t able to show an error message,
just don’t set the maxLength value.
Code before migration:
CupertinoTextField
maxLength:
maxLengthEnforced:
false
Code after migration: | https://docs.flutter.dev/release/breaking-changes/use-maxLengthEnforcement-instead-of-maxLengthEnforced/index.html |
d697292de87b-7 | false
Code after migration:
CupertinoTextField
()
To enforce the limit, but not for composing text
To avoid truncating text while the user is inputting text
by using composition, specify
MaxLengthEnforcement.truncateAfterCompositionEnds.
This behavior allows input methods that use composing
regions larger than the resulting text,
as is common for example with Chinese, Japanese,
and Korean (CJK) text, to temporarily
ignore the limit until editing is complete.
Gboard’s English keyboard on Android
(and many other Android input methods)
creates a composing region for the word being entered.
When used in a truncateAfterCompositionEnds text field,
the user won’t be stopped right away at the maxLength limit.
Consider the enforced option if you are confident that
the text field will not be used with input methods
that use temporarily long composing regions such as CJK text.
Code for the implementation: | https://docs.flutter.dev/release/breaking-changes/use-maxLengthEnforcement-instead-of-maxLengthEnforced/index.html |
d697292de87b-8 | Code for the implementation:
TextField
maxLength:
maxLengthEnforcement:
MaxLengthEnforcement
truncateAfterCompositionEnds
// Temporarily lifts the limit.
Be wary of assuming input will not use composing regions
It is tempting when targeting a particular locale to assume
that all users will be satisfied with input from that locale.
For example, forum software targeting an English-language
community might be assumed to only need to deal with English
text. However, this kind of assumption is often incorrect.
For example, maybe the English-language forum participants
will want to discuss Japanese anime or Vietnamese cooking.
Maybe one of the participants is Korean and prefers to express
their name in their native ideographs. For this reason,
freeform fields should rarely use the enforced value
and should instead prefer the
truncateAfterCompositionEnds value if at all possible.
Timeline | https://docs.flutter.dev/release/breaking-changes/use-maxLengthEnforcement-instead-of-maxLengthEnforced/index.html |
d697292de87b-9 | Timeline
Landed in version: v1.26.0-1.0.pre
In stable release: 2.0.0
References
Design doc:
MaxLengthEnforcement design doc
API documentation:
MaxLengthEnforcement
LengthLimitingTextInputFormatter
maxLength
Relevant issues:
Issue 63753
Issue 67898
Relevant PR:
PR 63754: Fix TextField crashed with composing and maxLength set
PR 68086: Introduce MaxLengthEnforcement | https://docs.flutter.dev/release/breaking-changes/use-maxLengthEnforcement-instead-of-maxLengthEnforced/index.html |
970f8af440f4-0 | Flutter architectural overview
Architectural layers
Anatomy of an app
Reactive user interfaces
Widgets
Composition
Building widgets
Widget state
State management
Rendering and layout
Flutter’s rendering model
From user input to the GPU
Build: from Widget to Element
Layout and rendering
Platform embedding
Integrating with other code
Platform channels
Foreign Function Interface
Rendering native controls in a Flutter app
Hosting Flutter content in a parent app
Flutter web support
Further information
This article is intended to provide a high-level overview of the architecture of
Flutter, including the core principles and concepts that form its design. | https://docs.flutter.dev/resources/architectural-overview/index.html |
970f8af440f4-1 | Flutter is a cross-platform UI toolkit that is designed to allow code reuse
across operating systems such as iOS and Android, while also allowing
applications to interface directly with underlying platform services. The goal
is to enable developers to deliver high-performance apps that feel natural on
different platforms, embracing differences where they exist while sharing as
much code as possible.
During development, Flutter apps run in a VM that offers stateful hot reload of
changes without needing a full recompile. For release, Flutter apps are compiled
directly to machine code, whether Intel x64 or ARM instructions, or to
JavaScript if targeting the web. The framework is open source, with a permissive
BSD license, and has a thriving ecosystem of third-party packages that
supplement the core library functionality.
This overview is divided into a number of sections:
The layer model: The pieces from which Flutter is constructed.
Reactive user interfaces: A core concept for Flutter user interface
development. | https://docs.flutter.dev/resources/architectural-overview/index.html |
970f8af440f4-2 | Reactive user interfaces: A core concept for Flutter user interface
development.
An introduction to widgets: The fundamental building blocks of Flutter user
interfaces.
The rendering process: How Flutter turns UI code into pixels.
An overview of the platform embedders: The code that lets mobile and
desktop OSes execute Flutter apps.
Integrating Flutter with other code: Information about different techniques
available to Flutter apps.
Support for the web: Concluding remarks about the characteristics of
Flutter in a browser environment.
Architectural layers
Flutter is designed as an extensible, layered system. It exists as a series of
independent libraries that each depend on the underlying layer. No layer has
privileged access to the layer below, and every part of the framework level is
designed to be optional and replaceable. | https://docs.flutter.dev/resources/architectural-overview/index.html |
970f8af440f4-3 | To the underlying operating system, Flutter applications are packaged in the
same way as any other native application. A platform-specific embedder provides
an entrypoint; coordinates with the underlying operating system for access to
services like rendering surfaces, accessibility, and input; and manages the
message event loop. The embedder is written in a language that is appropriate
for the platform: currently Java and C++ for Android, Objective-C/Objective-C++
for iOS and macOS, and C++ for Windows and Linux. Using the embedder, Flutter
code can be integrated into an existing application as a module, or the code may
be the entire content of the application. Flutter includes a number of embedders
for common target platforms, but other embedders also
exist. | https://docs.flutter.dev/resources/architectural-overview/index.html |
970f8af440f4-4 | At the core of Flutter is the Flutter engine, which is mostly written in C++
and supports the primitives necessary to support all Flutter applications. The
engine is responsible for rasterizing composited scenes whenever a new frame
needs to be painted. It provides the low-level implementation of Flutter’s core
API, including graphics (through Skia), text layout, file
and network I/O, accessibility support, plugin architecture, and a Dart runtime
and compile toolchain.
The engine is exposed to the Flutter framework through
dart:ui,
which wraps the underlying C++ code in Dart classes. This library
exposes the lowest-level primitives, such as classes for driving input,
graphics, and text rendering subsystems.
Typically, developers interact with Flutter through the Flutter framework,
which provides a modern, reactive framework written in the Dart language. It
includes a rich set of platform, layout, and foundational libraries, composed of
a series of layers. Working from the bottom to the top, we have: | https://docs.flutter.dev/resources/architectural-overview/index.html |
970f8af440f4-5 | Basic foundational
classes, and building block services such as
animation,
painting, and
gestures that offer
commonly used abstractions over the underlying foundation.
The rendering
layer provides an
abstraction for dealing with layout. With this layer, you can build a tree of
renderable objects. You can manipulate these objects dynamically, with the
tree automatically updating the layout to reflect your changes.
The widgets layer is
a composition abstraction. Each render object in the rendering layer has a
corresponding class in the widgets layer. In addition, the widgets layer
allows you to define combinations of classes that you can reuse. This is the
layer at which the reactive programming model is introduced.
The
Material
and
Cupertino
libraries offer comprehensive sets of controls that use the widget layer’s
composition primitives to implement the Material or iOS design languages.
camera and
webview, as well as platform-agnostic
features like
characters,
http, and | https://docs.flutter.dev/resources/architectural-overview/index.html |
970f8af440f4-6 | characters,
http, and
animations that build upon the core Dart and
Flutter libraries. Some of these packages come from the broader ecosystem,
covering services like
in-app
payments,
Apple
authentication, and
animations.
The rest of this overview broadly navigates down the layers, starting with the
reactive paradigm of UI development. Then, we describe how widgets are composed
together and converted into objects that can be rendered as part of an
application. We describe how Flutter interoperates with other code at a platform
level, before giving a brief summary of how Flutter’s web support differs from
other targets.
Anatomy of an app | https://docs.flutter.dev/resources/architectural-overview/index.html |
970f8af440f4-7 | Anatomy of an app
The following diagram gives an overview of the pieces
that make up a regular Flutter app generated by flutter create.
It shows where the Flutter Engine sits in this stack,
highlights API boundaries, and identifies the repositories
where the individual pieces live. The legend below clarifies
some of the terminology commonly used to describe the
pieces of a Flutter app.
Dart App
Composes widgets into the desired UI.
Implements business logic.
Owned by app developer.
Framework (source code)
Provides higher-level API to build high-quality apps
(for example, widgets, hit-testing, gesture detection,
accessibility, text input).
Composites the app’s widget tree into a scene.
Engine (source code)
Responsible for rasterizing composited scenes. | https://docs.flutter.dev/resources/architectural-overview/index.html |
970f8af440f4-8 | Responsible for rasterizing composited scenes.
Provides low-level implementation of Flutter’s core APIs
(for example, graphics, text layout, Dart runtime).
Exposes its functionality to the framework using the dart:ui API.
Integrates with a specific platform using the Engine’s Embedder API.
Embedder (source code)
Coordinates with the underlying operating system
for access to services like rendering surfaces,
accessibility, and input.
Manages the event loop.
Exposes platform-specific API to integrate the Embedder into apps.
Runner
Composes the pieces exposed by the platform-specific
API of the Embedder into an app package runnable on the target platform.
Part of app template generated by flutter create,
owned by app developer.
Reactive user interfaces | https://docs.flutter.dev/resources/architectural-overview/index.html |
970f8af440f4-9 | Reactive user interfaces
On the surface, Flutter is a reactive, pseudo-declarative UI
framework,
in which the developer provides a mapping from application state to interface
state, and the framework takes on the task of updating the interface at runtime
when the application state changes. This model is inspired by work that came
from Facebook for their own React
framework,
which includes a rethinking of many traditional design principles.
In most traditional UI frameworks, the user interface’s initial state is
described once and then separately updated by user code at runtime, in response
to events. One challenge of this approach is that, as the application grows in
complexity, the developer needs to be aware of how state changes cascade
throughout the entire UI. For example, consider the following UI: | https://docs.flutter.dev/resources/architectural-overview/index.html |
970f8af440f4-10 | There are many places where the state can be changed: the color box, the hue
slider, the radio buttons. As the user interacts with the UI, changes must be
reflected in every other place. Worse, unless care is taken, a minor change to
one part of the user interface can cause ripple effects to seemingly unrelated
pieces of code.
One solution to this is an approach like MVC, where you push data changes to the
model via the controller, and then the model pushes the new state to the view
via the controller. However, this also is problematic, since creating and
updating UI elements are two separate steps that can easily get out of sync.
Flutter, along with other reactive frameworks, takes an alternative approach to
this problem, by explicitly decoupling the user interface from its underlying
state. With React-style APIs, you only create the UI description, and the
framework takes care of using that one configuration to both create and/or
update the user interface as appropriate. | https://docs.flutter.dev/resources/architectural-overview/index.html |
970f8af440f4-11 | In Flutter, widgets (akin to components in React) are represented by immutable
classes that are used to configure a tree of objects. These widgets are used to
manage a separate tree of objects for layout, which is then used to manage a
separate tree of objects for compositing. Flutter is, at its core, a series of
mechanisms for efficiently walking the modified parts of trees, converting trees
of objects into lower-level trees of objects, and propagating changes across
these trees.
A widget declares its user interface by overriding the build() method, which
is a function that converts state to UI:
The build() method is by design fast to execute and should be free of side
effects, allowing it to be called by the framework whenever needed (potentially
as often as once per rendered frame).
This approach relies on certain characteristics of a language runtime (in
particular, fast object instantiation and deletion). Fortunately, Dart is
particularly well suited for this
task.
Widgets | https://docs.flutter.dev/resources/architectural-overview/index.html |
970f8af440f4-12 | Widgets
As mentioned, Flutter emphasizes widgets as a unit of composition. Widgets are
the building blocks of a Flutter app’s user interface, and each widget is an
immutable declaration of part of the user interface.
Widgets form a hierarchy based on composition. Each widget nests inside its
parent and can receive context from the parent. This structure carries all the
way up to the root widget (the container that hosts the Flutter app, typically
MaterialApp or CupertinoApp), as this trivial example shows:
In the preceding code, all instantiated classes are widgets.
Apps update their user interface in response to events (such as a user
interaction) by telling the framework to replace a widget in the hierarchy with
another widget. The framework then compares the new and old widgets, and
efficiently updates the user interface. | https://docs.flutter.dev/resources/architectural-overview/index.html |
970f8af440f4-13 | Flutter has its own implementations of each UI control, rather than deferring to
those provided by the system: for example, there is a pure Dart
implementation of both the
iOS Switch
control
and the one for the
Android equivalent.
This approach provides several benefits:
Provides for unlimited extensibility. A developer who wants a variant of the
Switch control can create one in any arbitrary way, and is not limited to the
extension points provided by the OS.
Avoids a significant performance bottleneck by allowing Flutter to composite
the entire scene at once, without transitioning back and forth between Flutter
code and platform code.
Decouples the application behavior from any operating system dependencies. The
application looks and feels the same on all versions of the OS, even if the OS
changed the implementations of its controls.
Composition
Widgets are typically composed of many other small, single-purpose widgets that
combine to produce powerful effects. | https://docs.flutter.dev/resources/architectural-overview/index.html |
970f8af440f4-14 | Where possible, the number of design concepts is kept to a minimum while
allowing the total vocabulary to be large. For example, in the widgets layer,
Flutter uses the same core concept (a Widget) to represent drawing to the
screen, layout (positioning and sizing), user interactivity, state management,
theming, animations, and navigation. In the animation layer, a pair of concepts,
Animations and Tweens, cover most of the design space. In the rendering
layer, RenderObjects are used to describe layout, painting, hit testing, and
accessibility. In each of these cases, the corresponding vocabulary ends up
being large: there are hundreds of widgets and render objects, and dozens of
animation and tween types. | https://docs.flutter.dev/resources/architectural-overview/index.html |
970f8af440f4-15 | The class hierarchy is deliberately shallow and broad to maximize the possible
number of combinations, focusing on small, composable widgets that each do one
thing well. Core features are abstract, with even basic features like padding
and alignment being implemented as separate components rather than being built
into the core. (This also contrasts with more traditional APIs where features
like padding are built in to the common core of every layout component.) So, for
example, to center a widget, rather than adjusting a notional Align property,
you wrap it in a Center
widget.
There are widgets for padding, alignment, rows, columns, and grids. These layout
widgets do not have a visual representation of their own. Instead, their sole
purpose is to control some aspect of another widget’s layout. Flutter also
includes utility widgets that take advantage of this compositional approach.
Container, a
commonly used widget, is made up of several widgets responsible for layout,
painting, positioning, and sizing. Specifically, Container is made up of the
LimitedBox, | https://docs.flutter.dev/resources/architectural-overview/index.html |
970f8af440f4-16 | LimitedBox,
ConstrainedBox,
Align,
Padding,
DecoratedBox, and
Transform widgets, as you
can see by reading its source code. A defining characteristic of Flutter is that
you can drill down into the source for any widget and examine it. So, rather
than subclassing
Building widgets
build() function to
return a new element tree. This tree represents the widget’s part of the user
interface in more concrete terms. For example, a toolbar widget might have a
build function that returns a
horizontal
layout of some
text and
various
buttons. As needed,
the framework recursively asks each widget to build until the tree is entirely
described by
concrete renderable
objects. The
framework then stitches together the renderable objects into a renderable object
tree. | https://docs.flutter.dev/resources/architectural-overview/index.html |
970f8af440f4-17 | A widget’s build function should be free of side effects. Whenever the function
is asked to build, the widget should return a new tree of widgets1, regardless of what the widget previously returned. The
framework does the heavy lifting work to determine which build methods need to
be called based on the render object tree (described in more detail later). More
information about this process can be found in the Inside Flutter
topic.
On each rendered frame, Flutter can recreate just the parts of the UI where the
state has changed by calling that widget’s build() method. Therefore it is
important that build methods should return quickly, and heavy computational work
should be done in some asynchronous manner and then stored as part of the state
to be used by a build method.
While relatively naïve in approach, this automated comparison is quite
effective, enabling high-performance, interactive apps. And, the design of the
build function simplifies your code by focusing on declaring what a widget is
made of, rather than the complexities of updating the user interface from one
state to another. | https://docs.flutter.dev/resources/architectural-overview/index.html |
970f8af440f4-18 | Widget state
The framework introduces two major classes of widget: stateful and stateless
widgets.
Many widgets have no mutable state: they don’t have any properties that change
over time (for example, an icon or a label). These widgets subclass
StatelessWidget.
However, if the unique characteristics of a widget need to change based on user
interaction or other factors, that widget is stateful. For example, if a
widget has a counter that increments whenever the user taps a button, then the
value of the counter is the state for that widget. When that value changes, the
widget needs to be rebuilt to update its part of the UI. These widgets subclass
StatefulWidget, and
(because the widget itself is immutable) they store mutable state in a separate
class that subclasses State.
StatefulWidgets don’t have a build method; instead, their user interface is
built through their State object. | https://docs.flutter.dev/resources/architectural-overview/index.html |
970f8af440f4-19 | Whenever you mutate a State object (for example, by incrementing the counter),
you must call setState()
to signal the framework to update the user interface by calling the State’s
build method again.
Having separate state and widget objects lets other widgets treat both stateless
and stateful widgets in exactly the same way, without being concerned about
losing state. Instead of needing to hold on to a child to preserve its state,
the parent can create a new instance of the child at any time without losing the
child’s persistent state. The framework does all the work of finding and reusing
existing state objects when appropriate.
State management
So, if many widgets can contain state, how is state managed and passed around
the system?
As with any other class, you can use a constructor in a widget to initialize its
data, so a build() method can ensure that any child widget is instantiated
with the data it needs:
@override
Widget
build
BuildContext | https://docs.flutter.dev/resources/architectural-overview/index.html |
970f8af440f4-20 | Widget
build
BuildContext
context
return
ContentWidget
importantState
);
As widget trees get deeper, however, passing state information up and down the
tree hierarchy becomes cumbersome. So, a third widget type,
InheritedWidget,
provides an easy way to grab data from a shared ancestor. You can use
InheritedWidget to create a state widget that wraps a common ancestor in the
widget tree, as shown in this example:
Whenever one of the ExamWidget or GradeWidget objects needs data from
StudentState, it can now access it with a command such as:
final
studentState
StudentState
of
context
); | https://docs.flutter.dev/resources/architectural-overview/index.html |
970f8af440f4-21 | of
context
);
The of(context) call takes the build context (a handle to the current widget
location), and returns the nearest ancestor in the
tree
that matches the StudentState type. InheritedWidgets also offer an
updateShouldNotify() method, which Flutter calls to determine whether a state
change should trigger a rebuild of child widgets that use it.
properties like color and type
styles that are
pervasive throughout an application. The
This approach is also used for
Navigator, which provides
page routing; and
MediaQuery, which provides
access to screen metrics such as orientation, dimensions, and brightness. | https://docs.flutter.dev/resources/architectural-overview/index.html |
970f8af440f4-22 | As applications grow, more advanced state management approaches that reduce the
ceremony of creating and using stateful widgets become more attractive. Many
Flutter apps use utility packages like
provider, which provides a wrapper around
InheritedWidget. Flutter’s layered architecture also enables alternative
approaches to implement the transformation of state into UI, such as the
flutter_hooks package.
Rendering and layout
This section describes the rendering pipeline, which is the series of steps that
Flutter takes to convert a hierarchy of widgets into the actual pixels painted
onto a screen.
Flutter’s rendering model
You may be wondering: if Flutter is a cross-platform framework, then how can it
offer comparable performance to single-platform frameworks? | https://docs.flutter.dev/resources/architectural-overview/index.html |
970f8af440f4-23 | It’s useful to start by thinking about how traditional Android apps work. When
drawing, you first call the Java code of the Android framework. The Android
system libraries provide the components responsible for drawing themselves to a
Canvas object, which Android can then render with Skia, a
graphics engine written in C/C++ that calls the CPU or GPU to complete the
drawing on the device.
Cross-platform frameworks typically work by creating an abstraction layer over
the underlying native Android and iOS UI libraries, attempting to smooth out the
inconsistencies of each platform representation. App code is often written in an
interpreted language like JavaScript, which must in turn interact with the
Java-based Android or Objective-C-based iOS system libraries to display UI. All
this adds overhead that can be significant, particularly where there is a lot of
interaction between the UI and the app logic. | https://docs.flutter.dev/resources/architectural-overview/index.html |
970f8af440f4-24 | By contrast, Flutter minimizes those abstractions, bypassing the system UI
widget libraries in favor of its own widget set. The Dart code that paints
Flutter’s visuals is compiled into native code, which uses Skia for rendering.
Flutter also embeds its own copy of Skia as part of the engine, allowing the
developer to upgrade their app to stay updated with the latest performance
improvements even if the phone hasn’t been updated with a new Android version.
The same is true for Flutter on other native platforms, such as iOS, Windows, or
macOS.
From user input to the GPU
The overriding principle that Flutter applies to its rendering pipeline is that
simple is fast. Flutter has a straightforward pipeline for how data flows to
the system, as shown in the following sequencing diagram:
Let’s take a look at some of these phases in greater detail.
Build: from Widget to Element
Consider this code fragment that demonstrates a widget hierarchy:
source
code
for | https://docs.flutter.dev/resources/architectural-overview/index.html |
970f8af440f4-25 | source
code
for
if
color
!=
null
current
ColoredBox
color:
color
child:
current
);
Correspondingly, the Image and Text widgets might insert child widgets such
as RawImage and RichText during the build process. The eventual widget
hierarchy may therefore be deeper than what the code represents, as in this
case2:
This explains why, when you examine the tree through a debug tool such as the
Flutter inspector, part of the
Dart DevTools, you might see a structure that is considerably deeper than what
is in your original code. | https://docs.flutter.dev/resources/architectural-overview/index.html |
970f8af440f4-26 | During the build phase, Flutter translates the widgets expressed in code into a
corresponding element tree, with one element for every widget. Each element
represents a specific instance of a widget in a given location of the tree
hierarchy. There are two basic types of elements:
ComponentElement, a host for other elements.
RenderObjectElement, an element that participates in the layout or paint
phases.
RenderObjectElements are an intermediary between their widget analog and the
underlying RenderObject, which we’ll come to later.
The element for any widget can be referenced through its BuildContext, which
is a handle to the location of a widget in the tree. This is the context in a
function call such as Theme.of(context), and is supplied to the build()
method as a parameter. | https://docs.flutter.dev/resources/architectural-overview/index.html |
970f8af440f4-27 | Because widgets are immutable, including the parent/child relationship between
nodes, any change to the widget tree (such as changing Text('A') to
Text('B') in the preceding example) causes a new set of widget objects to be
returned. But that doesn’t mean the underlying representation must be rebuilt.
The element tree is persistent from frame to frame, and therefore plays a
critical performance role, allowing Flutter to act as if the widget hierarchy is
fully disposable while caching its underlying representation. By only walking
through the widgets that changed, Flutter can rebuild just the parts of the
element tree that require reconfiguration.
Layout and rendering
It would be a rare application that drew only a single widget. An important part
of any UI framework is therefore the ability to efficiently lay out a hierarchy
of widgets, determining the size and position of each element before they are
rendered on the screen. | https://docs.flutter.dev/resources/architectural-overview/index.html |
970f8af440f4-28 | The base class for every node in the render tree is
RenderObject, which
defines an abstract model for layout and painting. This is extremely general: it
does not commit to a fixed number of dimensions or even a Cartesian coordinate
system (demonstrated by this example of a polar coordinate
system). Each
RenderObject knows its parent, but knows little about its children other than
how to visit them and their constraints. This provides RenderObject with
sufficient abstraction to be able to handle a variety of use cases.
RenderParagraph
renders text,
RenderImage renders
an image, and
RenderTransform
applies a transformation before painting its child.
Most Flutter widgets are rendered by an object that inherits from the
RenderBox subclass, which represents a RenderObject of fixed size in a 2D
Cartesian space. RenderBox provides the basis of a box constraint model,
establishing a minimum and maximum width and height for each widget to be
rendered. | https://docs.flutter.dev/resources/architectural-overview/index.html |
970f8af440f4-29 | To perform layout, Flutter walks the render tree in a depth-first traversal and
passes down size constraints from parent to child. In determining its size,
the child must respect the constraints given to it by its parent. Children
respond by passing up a size to their parent object within the constraints
the parent established.
At the end of this single walk through the tree, every object has a defined size
within its parent’s constraints and is ready to be painted by calling the
paint()
method.
The box constraint model is very powerful as a way to layout objects in O(n)
time:
Parents can dictate the size of a child object by setting maximum and minimum
constraints to the same value. For example, the topmost render object in a
phone app constrains its child to be the size of the screen. (Children can
choose how to use that space. For example, they might just center what they
want to render within the dictated constraints.) | https://docs.flutter.dev/resources/architectural-overview/index.html |
970f8af440f4-30 | A parent can dictate the child’s width but give the child flexibility over
height (or dictate height but offer flexible over width). A real-world example
is flow text, which might have to fit a horizontal constraint but vary
vertically depending on the quantity of text.
This model works even when a child object needs to know how much space it has
available to decide how it will render its content. By using a
LayoutBuilder widget,
the child object can examine the passed-down constraints and use those to
determine how it will use them, for example:
More information about the constraint and layout system, along with worked
examples, can be found in the Understanding
constraints topic.
vsync or because
a texture decompression/upload is complete), a call is made to the
Further details of the composition and rasterization stages of the pipeline are
beyond the scope of this high-level article, but more information can be found
in this talk on the Flutter rendering
pipeline.
Platform embedding | https://docs.flutter.dev/resources/architectural-overview/index.html |
970f8af440f4-31 | Platform embedding
As we’ve seen, rather than being translated into the equivalent OS widgets,
Flutter user interfaces are built, laid out, composited, and painted by Flutter
itself. The mechanism for obtaining the texture and participating in the app
lifecycle of the underlying operating system inevitably varies depending on the
unique concerns of that platform. The engine is platform-agnostic, presenting a
stable ABI (Application Binary
Interface)
that provides a platform embedder with a way to set up and use Flutter. | https://docs.flutter.dev/resources/architectural-overview/index.html |
970f8af440f4-32 | The platform embedder is the native OS application that hosts all Flutter
content, and acts as the glue between the host operating system and Flutter.
When you start a Flutter app, the embedder provides the entrypoint, initializes
the Flutter engine, obtains threads for UI and rastering, and creates a texture
that Flutter can write to. The embedder is also responsible for the app
lifecycle, including input gestures (such as mouse, keyboard, touch), window
sizing, thread management, and platform messages. Flutter includes platform
embedders for Android, iOS, Windows, macOS, and Linux; you can also create a
custom platform embedder, as in this worked
example that supports remoting
Flutter sessions through a VNC-style framebuffer or this worked example for
Raspberry Pi.
Each platform has its own set of APIs and constraints. Some brief
platform-specific notes: | https://docs.flutter.dev/resources/architectural-overview/index.html |
970f8af440f4-33 | Each platform has its own set of APIs and constraints. Some brief
platform-specific notes:
On iOS and macOS, Flutter is loaded into the embedder as a UIViewController
or NSViewController, respectively. The platform embedder creates a
FlutterEngine, which serves as a host to the Dart VM and your Flutter
runtime, and a FlutterViewController, which attaches to the FlutterEngine
to pass UIKit or Cocoa input events into Flutter and to display frames
rendered by the FlutterEngine using Metal or OpenGL.
On Android, Flutter is, by default, loaded into the embedder as an Activity.
The view is controlled by a
FlutterView,
which renders Flutter content either as a view or a texture, depending on the
composition and z-ordering requirements of the Flutter content.
On Windows, Flutter is hosted in a traditional Win32 app, and content is
rendered using
ANGLE, a
library that translates OpenGL API calls to the DirectX 11 equivalents. | https://docs.flutter.dev/resources/architectural-overview/index.html |
970f8af440f4-34 | Integrating with other code
Flutter provides a variety of interoperability mechanisms, whether you’re
accessing code or APIs written in a language like Kotlin or Swift, calling a
native C-based API, embedding native controls in a Flutter app, or embedding
Flutter in an existing application.
Platform channels
For mobile and desktop apps, Flutter allows you to call into custom code through
a platform channel, which is a mechanism for communicating between your
Dart code and the platform-specific code of your host app. By creating a common
channel (encapsulating a name and a codec), you can send and receive messages
between Dart and a platform component written in a language like Kotlin or
Swift. Data is serialized from a Dart type like Map into a standard format,
and then deserialized into an equivalent representation in Kotlin (such as
HashMap) or Swift (such as Dictionary).
The following is a short platform channel example of a Dart call to a receiving
event handler in Kotlin (Android) or Swift (iOS): | https://docs.flutter.dev/resources/architectural-overview/index.html |
970f8af440f4-35 | // Android (Kotlin)
val
channel
MethodChannel
flutterView
"foo"
channel
setMethodCallHandler
call
result
>
when
call
method
"bar"
>
result
success
"Hello, ${call.arguments}"
else
>
result
notImplemented
()
// iOS (Swift)
let
channel
FlutterMethodChannel
name
"foo"
binaryMessenger
flutterView
channel
setMethodCallHandler
call | https://docs.flutter.dev/resources/architectural-overview/index.html |
970f8af440f4-36 | channel
setMethodCallHandler
call
FlutterMethodCall
result
FlutterResult
>
Void
in
switch
call
method
case
"bar"
result
"Hello,
\(
call
arguments
as!
String
default
result
FlutterMethodNotImplemented
Further examples of using platform channels, including examples for macOS, can
be found in the flutter/plugins
repository3. There are also thousands of plugins
already available for Flutter that cover many common
scenarios, ranging from Firebase to ads to device hardware like camera and
Bluetooth.
Foreign Function Interface | https://docs.flutter.dev/resources/architectural-overview/index.html |
970f8af440f4-37 | Foreign Function Interface
For C-based APIs, including those that can be generated for code written in
modern languages like Rust or Go, Dart provides a direct mechanism for binding
to native code using the dart:ffi library. The foreign function interface
(FFI) model can be considerably faster than platform channels, because no
serialization is required to pass data. Instead, the Dart runtime provides the
ability to allocate memory on the heap that is backed by a Dart object and make
calls to statically or dynamically linked libraries. FFI is available for all
platforms other than web, where the js package
serves an equivalent purpose.
To use FFI, you create a typedef for each of the Dart and unmanaged method
signatures, and instruct the Dart VM to map between them. As an example,
here’s a fragment of code to call the traditional Win32 MessageBox() API:
Rendering native controls in a Flutter app | https://docs.flutter.dev/resources/architectural-overview/index.html |
970f8af440f4-38 | Rendering native controls in a Flutter app
Because Flutter content is drawn to a texture and its widget tree is entirely
internal, there’s no place for something like an Android view to exist within
Flutter’s internal model or render interleaved within Flutter widgets. That’s a
problem for developers that would like to include existing platform components
in their Flutter apps, such as a browser control.
Flutter solves this by introducing platform view widgets
(AndroidView
and UiKitView)
that let you embed this kind of content on each platform. Platform views can be
integrated with other Flutter content4. Each of
these widgets acts as an intermediary to the underlying operating system. For
example, on Android, AndroidView serves three primary functions:
Making a copy of the graphics texture rendered by the native view and
presenting it to Flutter for composition as part of a Flutter-rendered surface
each time the frame is painted. | https://docs.flutter.dev/resources/architectural-overview/index.html |
970f8af440f4-39 | Responding to hit testing and input gestures, and translating those into the
equivalent native input.
Creating an analog of the accessibility tree, and passing commands and
responses between the native and Flutter layers.
Inevitably, there is a certain amount of overhead associated with this
synchronization. In general, therefore, this approach is best suited for complex
controls like Google Maps where reimplementing in Flutter isn’t practical.
Typically, a Flutter app instantiates these widgets in a build() method based
on a platform test. As an example, from the
google_maps_flutter plugin:
if
defaultTargetPlatform
==
TargetPlatform
android
return
AndroidView
viewType:
'plugins.flutter.io/google_maps'
onPlatformViewCreated:
onPlatformViewCreated | https://docs.flutter.dev/resources/architectural-overview/index.html |
970f8af440f4-40 | onPlatformViewCreated:
onPlatformViewCreated
gestureRecognizers:
gestureRecognizers
creationParams:
creationParams
creationParamsCodec:
const
StandardMessageCodec
(),
);
else
if
defaultTargetPlatform
==
TargetPlatform
iOS
return
UiKitView
viewType:
'plugins.flutter.io/google_maps'
onPlatformViewCreated:
onPlatformViewCreated
gestureRecognizers:
gestureRecognizers
creationParams:
creationParams
creationParamsCodec:
const
StandardMessageCodec
(), | https://docs.flutter.dev/resources/architectural-overview/index.html |
970f8af440f4-41 | const
StandardMessageCodec
(),
);
return
Text
$defaultTargetPlatform
is not yet supported by the maps plugin'
);
Communicating with the native code underlying the AndroidView or UiKitView
typically occurs using the platform channels mechanism, as previously described.
At present, platform views aren’t available for desktop platforms, but this is
not an architectural limitation; support might be added in the future.
Hosting Flutter content in a parent app
The converse of the preceding scenario is embedding a Flutter widget in an
existing Android or iOS app. As described in an earlier section, a newly created
Flutter app running on a mobile device is hosted in an Android activity or iOS
UIViewController. Flutter content can be embedded into an existing Android or
iOS app using the same embedding API. | https://docs.flutter.dev/resources/architectural-overview/index.html |
970f8af440f4-42 | The Flutter module template is designed for easy embedding; you can either embed
it as a source dependency into an existing Gradle or Xcode build definition, or
you can compile it into an Android Archive or iOS Framework binary for use
without requiring every developer to have Flutter installed.
The Flutter engine takes a short while to initialize, because it needs to load
Flutter shared libraries, initialize the Dart runtime, create and run a Dart
isolate, and attach a rendering surface to the UI. To minimize any UI delays
when presenting Flutter content, it’s best to initialize the Flutter engine
during the overall app initialization sequence, or at least ahead of the first
Flutter screen, so that users don’t experience a sudden pause while the first
Flutter code is loaded. In addition, separating the Flutter engine allows it to
be reused across multiple Flutter screens and share the memory overhead involved
with loading the necessary libraries.
More information about how Flutter is loaded into an existing Android or iOS app
can be found at the Load sequence, performance and memory
topic. | https://docs.flutter.dev/resources/architectural-overview/index.html |
970f8af440f4-43 | Flutter web support
While the general architectural concepts apply to all platforms that Flutter
supports, there are some unique characteristics of Flutter’s web support that
are worthy of comment.
Dart has been compiling to JavaScript for as long as the language has existed,
with a toolchain optimized for both development and production purposes. Many
important apps compile from Dart to JavaScript and run in production today,
including the advertiser tooling for Google Ads.
Because the Flutter framework is written in Dart, compiling it to JavaScript was
relatively straightforward. | https://docs.flutter.dev/resources/architectural-overview/index.html |
970f8af440f4-44 | However, the Flutter engine, written in C++, is designed to interface with the
underlying operating system rather than a web browser. A different approach is
therefore required. On the web, Flutter provides a reimplementation of the
engine on top of standard browser APIs. We currently have two options for
rendering Flutter content on the web: HTML and WebGL. In HTML mode, Flutter uses
HTML, CSS, Canvas, and SVG. To render to WebGL, Flutter uses a version of Skia
compiled to WebAssembly called
CanvasKit. While HTML mode offers the
best code size characteristics, CanvasKit provides the fastest path to the
browser’s graphics stack, and offers somewhat higher graphical fidelity with the
native mobile targets5.
The web version of the architectural layer diagram is as follows: | https://docs.flutter.dev/resources/architectural-overview/index.html |
Subsets and Splits