Datasets:
Ekhlass
/
Flutter_Documentation

Dataset card Data Studio Files
xet
Community
1
text
stringlengths
1
474
Flutter’s engine triggers a “begin frame” callback that
the scheduler multiplexes to all the listeners registered using
scheduleFrameCallback(). All these callbacks are
given the official time stamp of the frame, in
the form of a Duration from some arbitrary epoch. Since all the
callbacks have the same time, any animations triggered from these
callbacks will appear to be exactly synchronised even
if they take a few milliseconds to be executed.<topic_end>
<topic_start>
Tickers
The Ticker class hooks into the scheduler’s
scheduleFrameCallback()
mechanism to invoke a callback every tick.A Ticker can be started and stopped. When started,
it returns a Future that will resolve when it is stopped.Each tick, the Ticker provides the callback with the
duration since the first tick after it was started.Because tickers always give their elapsed time relative to the first
tick after they were started; tickers are all synchronised. If you
start three tickers at different times between two ticks, they will all
nonetheless be synchronised with the same starting time, and will
subsequently tick in lockstep. Like people at a bus-stop,
all the tickers wait for a regularly occurring event
(the tick) to begin moving (counting time).<topic_end>
<topic_start>
Simulations
The Simulation abstract class maps a
relative time value (an elapsed time) to a
double value, and has a notion of completion.In principle simulations are stateless but in practice
some simulations (for example,
BouncingScrollSimulation and
ClampingScrollSimulation)
change state irreversibly when queried.There are various concrete implementations
of the Simulation class for different effects.<topic_end>
<topic_start>
Animatables
The Animatable abstract class maps a
double to a value of a particular type.Animatable classes are stateless and immutable.<topic_end>
<topic_start>Tweens
The Tween<T> abstract class maps a double
value nominally in the range 0.0-1.0 to a typed value
(for example, a Color, or another double).
It is an Animatable.It has a notion of an output type (T),
a begin value and an end value of that type,
and a way to interpolate (lerp) between the begin
and end values for a given input value (the double nominally in
the range 0.0-1.0).Tween classes are stateless and immutable.<topic_end>
<topic_start>Composing animatables
Passing an Animatable<double> (the parent) to an Animatable’s
chain() method creates a new Animatable subclass that applies the
parent’s mapping then the child’s mapping.<topic_end>
<topic_start>
Curves
The Curve abstract class maps doubles
nominally in the range 0.0-1.0 to doubles
nominally in the range 0.0-1.0.Curve classes are stateless and immutable.<topic_end>
<topic_start>
Animations
The Animation abstract class provides a
value of a given type, a concept of animation
direction and animation status, and a listener interface to
register callbacks that get invoked when the value or status change.Some subclasses of Animation have values that never change
(kAlwaysCompleteAnimation, kAlwaysDismissedAnimation,
AlwaysStoppedAnimation); registering callbacks on
these has no effect as the callbacks are never called.The Animation<double> variant is special because it can be used to
represent a double nominally in the range 0.0-1.0, which is the input
expected by Curve and Tween classes, as well as some further
subclasses of Animation.Some Animation subclasses are stateless,
merely forwarding listeners to their parents.
Some are very stateful.<topic_end>
<topic_start>Composable animations
Most Animation subclasses take an explicit “parent”
Animation<double>. They are driven by that parent.The CurvedAnimation subclass takes an Animation<double> class (the
parent) and a couple of Curve classes (the forward and reverse
curves) as input, and uses the value of the parent as input to the
curves to determine its output. CurvedAnimation is immutable and
stateless.The ReverseAnimation subclass takes an
Animation<double> class as its parent and reverses
all the values of the animation. It assumes the parent
is using a value nominally in the range 0.0-1.0 and returns
a value in the range 1.0-0.0. The status and direction of the parent
animation are also reversed. ReverseAnimation is immutable and
stateless.The ProxyAnimation subclass takes an Animation<double> class as
its parent and merely forwards the current state of that parent.
However, the parent is mutable.The TrainHoppingAnimation subclass takes two parents,
and switches between them when their values cross.<topic_end>
<topic_start>Animation controllers
The AnimationController is a stateful
Animation<double> that uses a Ticker to give itself life.
It can be started and stopped. At each tick, it takes the time
elapsed since it was started and passes it to a Simulation to obtain
a value. That is then the value it reports. If the Simulation
reports that at that time it has ended, then the controller stops
itself.The animation controller can be given a lower and upper bound to
animate between, and a duration.In the simple case (using forward() or reverse()), the animation controller simply does a linear
interpolation from the lower bound to the upper bound (or vice versa,
for the reverse direction) over the given duration.When using repeat(), the animation controller uses a linear
interpolation between the given bounds over the given duration, but
does not stop.When using animateTo(), the animation controller does a linear
interpolation over the given duration from the current value to the
given target. If no duration is given to the method, the default
duration of the controller and the range described by the controller’s
lower bound and upper bound is used to determine the velocity of the