Animations are very important to create a great user experience. Stationary objects must overcome inertia as they start moving. Objects in motion have momentum and rarely come to a stop immediately. Animations allow you to convey physically believable motion in your interface.
Animated API is designed to concisely express a wide variety of interesting animation and interaction patterns in a very performant way.
Animated focuses on declarative relationships between inputs and outputs, with configurable transforms in between, and
stop methods to control time-based animation execution.
Animated exports six animatable component types:
SectionList, but you can also create your own using
For example, a container view that fades in when it is mounted may look like this:
Let's break down what's happening here. In the
FadeInView constructor, a new
fadeAnim is initialized as part of
state. The opacity property on the
View is mapped to this animated value. Behind the scenes, the numeric value is extracted and used to set opacity.
When the component mounts, the opacity is set to 0. Then, an easing animation is started on the
fadeAnim animated value, which will update all of its dependent mappings (in this case, only the opacity) on each frame as the value animates to the final value of 1.
This is done in an optimized way that is faster than calling
setState and re-rendering. Because the entire configuration is declarative, we will be able to implement further optimizations that serialize the configuration and runs the animation on a high-priority thread.
Animations are heavily configurable. Custom and predefined easing functions, delays, durations, decay factors, spring constants, and more can all be tweaked depending on the type of animation.
Animated provides several animation types, the most commonly used one being
Animated.timing(). It supports animating a value over time using one of various predefined easing functions, or you can use your own. Easing functions are typically used in animation to convey gradual acceleration and deceleration of objects.
timing will use an easeInOut curve that conveys gradual acceleration to full speed and concludes by gradually decelerating to a stop. You can specify a different easing function by passing an
easing parameter. Custom
duration or even a
delay before the animation starts is also supported.
For example, if we want to create a 2-second long animation of an object that slightly backs up before moving to its final position:
Take a look at the Configuring animations section of the
Animated API reference to learn more about all the config parameters supported by the built-in animations.
Animations can be combined and played in sequence or in parallel. Sequential animations can play immediately after the previous animation has finished, or they can start after a specified delay. The
Animated API provides several methods, such as
delay(), each of which take an array of animations to execute and automatically calls
stop() as needed.
For example, the following animation coasts to a stop, then it springs back while twirling in parallel:
If one animation is stopped or interrupted, then all other animations in the group are also stopped.
Animated.parallel has a
stopTogether option that can be set to
false to disable this.
You can find a full list of composition methods in the Composing animations section of the
Animated API reference.
You can combine two animated values via addition, multiplication, division, or modulo to make a new animated value.
There are some cases where an animated value needs to invert another animated value for calculation. An example is inverting a scale (2x --> 0.5x):
Each property can be run through an interpolation first. An interpolation maps input ranges to output ranges, typically using a linear interpolation but also supports easing functions. By default, it will extrapolate the curve beyond the ranges given, but you can also have it clamp the output value.
A basic mapping to convert a 0-1 range to a 0-100 range would be:
For example, you may want to think about your
Animated.Value as going from 0 to 1, but animate the position from 150px to 0px and the opacity from 0 to 1. This can be done by modifying
style from the example above like so:
interpolate() supports multiple range segments as well, which is handy for defining dead zones and other handy tricks. For example, to get a negation relationship at -300 that goes to 0 at -100, then back up to 1 at 0, and then back down to zero at 100 followed by a dead-zone that remains at 0 for everything beyond that, you could do:
Which would map like so:
interpolate() also supports mapping to strings, allowing you to animate colors as well as values with units. For example, if you wanted to animate a rotation you could do:
interpolate() also supports arbitrary easing functions, many of which are already implemented in the
interpolate() also has configurable behavior for extrapolating the
outputRange. You can set the extrapolation by setting the
extrapolateRight options. The default value is
extend but you can use
clamp to prevent the output value from exceeding
Animated values can also track other values by setting the
toValue of an animation to another animated value instead of a plain number. For example, a "Chat Heads" animation like the one used by Messenger on Android could be implemented with a
spring() pinned on another animated value, or with
timing() and a
duration of 0 for rigid tracking. They can also be composed with interpolations:
follower animated values would be implemented using
ValueXY is a handy way to deal with 2D interactions, such as panning or dragging. It is a basic wrapper that contains two
Animated.Value instances and some helper functions that call through to them, making
ValueXY a drop-in replacement for
Value in many cases. It allows us to track both x and y values in the example above.
Gestures, like panning or scrolling, and other events can map directly to animated values using
Animated.event. This is done with a structured map syntax so that values can be extracted from complex event objects. The first level is an array to allow mapping across multiple args, and that array contains nested objects.
For example, when working with horizontal scrolling gestures, you would do the following in order to map
The following example implements a horizontal scrolling carousel where the scroll position indicators are animated using the
Animated.event used in the
- Function Component
- Class Component
PanResponder, you could use the following code to extract the x and y positions from
gestureState.dy. We use a
null in the first position of the array, as we are only interested in the second argument passed to the
PanResponder handler, which is the
- Function Component
- Class Component
spring.stopAnimation(callback)will stop the animation and invoke
callbackwith the final value. This is useful when making gesture transitions.
callbackasynchronously while the animation is running, providing a recent value. This is useful for triggering state changes, for example snapping a bobble to a new option as the user drags it closer, because these larger state changes are less sensitive to a few frames of lag compared to continuous gestures like panning which need to run at 60 fps.
Animated.Value.addListener as a way to work around some of these limitations, but use it sparingly since it might have performance implications in the future.
Animated API is designed to be serializable. By using the native driver, we send everything about the animation to native before starting the animation, allowing native code to perform the animation on the UI thread without having to go through the bridge on every frame. Once the animation has started, the JS thread can be blocked without affecting the animation.
Using the native driver for normal animations is straightforward. You can add
useNativeDriver: true to the animation config when starting it.
Animated values are only compatible with one driver so if you use native driver when starting an animation on a value, make sure every animation on that value also uses the native driver.
The native driver also works with
Animated.event. This is especially useful for animations that follow the scroll position as without the native driver, the animation will always run a frame behind the gesture due to the async nature of React Native.
Not everything you can do with
Animated is currently supported by the native driver. The main limitation is that you can only animate non-layout properties: things like
opacity will work, but Flexbox and position properties will not. When using
Animated.event, it will only work with direct events and not bubbling events. This means it does not work with
PanResponder but does work with things like
When an animation is running, it can prevent
VirtualizedList components from rendering more rows. If you need to run a long or looping animation while the user is scrolling through a list, you can use
isInteraction: false in your animation's config to prevent this issue.
While using transform styles such as
rotateX, and others ensure the transform style
perspective is in place. At this time some animations may not render on Android without it. Example below.
The RNTester app has various examples of
Animated in use:
LayoutAnimation allows you to globally configure
update animations that will be used for all views in the next render/layout cycle. This is useful for doing Flexbox layout updates without bothering to measure or calculate specific properties in order to animate them directly, and is especially useful when layout changes may affect ancestors, for example a "see more" expansion that also increases the size of the parent and pushes down the row below which would otherwise require explicit coordination between the components in order to animate them all in sync.
Note that although
LayoutAnimation is very powerful and can be quite useful, it provides much less control than
Animated and other animation libraries, so you may need to use another approach if you can't get
LayoutAnimation to do what you want.
Note that in order to get this to work on Android you need to set the following flags via
This example uses a preset value, you can customize the animations as you need, see LayoutAnimation.js for more information.
As mentioned in the Direct Manipulation section,
setNativeProps allows us to modify properties of native-backed components (components that are actually backed by native views, unlike composite components) directly, without having to
setState and re-render the component hierarchy.
We could use this in the Rebound example to update the scale - this might be helpful if the component that we are updating is deeply nested and hasn't been optimized with
If you find your animations with dropping frames (performing below 60 frames per second), look into using