Bird
Raised Fist0
React Nativemobile~20 mins

Spring and decay animations in React Native - Mini App: Build & Ship

Choose your learning style10 modes available
Build: SpringDecayAnimationScreen
This screen demonstrates how to use spring and decay animations in React Native. It shows a circle that can be dragged horizontally. When released, it either springs back to center or decays with momentum.
Target UI
┌───────────────────────────────┐
│ Spring and Decay Animations    │
├───────────────────────────────┤
│                               │
│           ○                   │
│                               │
│ Drag the circle left or right │
│ Release to see spring or decay│
└───────────────────────────────┘
Display a circle in the center horizontally.
Allow user to drag the circle horizontally with touch.
When user releases drag, if velocity is small, animate circle back to center with spring animation.
If velocity is large, animate circle with decay animation simulating momentum.
Use React Native Animated API with useNativeDriver set to false.
Show instructions text below the circle.
Starter Code
React Native
import React, { useRef } from 'react';
import { View, Text, Animated, PanResponder, StyleSheet } from 'react-native';

export default function SpringDecayAnimationScreen() {
  const translateX = useRef(new Animated.Value(0)).current;

  const panResponder = useRef(
    PanResponder.create({
      onStartShouldSetPanResponder: () => true,
      onPanResponderMove: (e, gestureState) => {
        // TODO: Update translateX with gestureState.dx
      },
      onPanResponderRelease: (e, gestureState) => {
        // TODO: Animate translateX with spring or decay based on velocity
      },
    })
  ).current;

  return (
    <View style={styles.container}>
      <Animated.View
        style={[styles.circle, { transform: [{ translateX }] }]}
        {...panResponder.panHandlers}
      />
      <Text style={styles.instructions}>
        Drag the circle left or right{'
'}Release to see spring or decay
      </Text>
    </View>
  );
}

const styles = StyleSheet.create({
  container: {
    flex: 1,
    justifyContent: 'center',
    alignItems: 'center',
    backgroundColor: '#fff',
  },
  circle: {
    width: 80,
    height: 80,
    borderRadius: 40,
    backgroundColor: '#4a90e2',
  },
  instructions: {
    marginTop: 20,
    fontSize: 16,
    color: '#333',
    textAlign: 'center',
  },
});
Task 1
Task 2
Task 3
Task 4
Task 5
Solution
React Native
import React, { useRef } from 'react';
import { View, Text, Animated, PanResponder, StyleSheet } from 'react-native';

export default function SpringDecayAnimationScreen() {
  const translateX = useRef(new Animated.Value(0)).current;

  const panResponder = useRef(
    PanResponder.create({
      onStartShouldSetPanResponder: () => true,
      onPanResponderMove: (e, gestureState) => {
        translateX.setValue(gestureState.dx);
      },
      onPanResponderRelease: (e, gestureState) => {
        const velocity = gestureState.vx;
        if (Math.abs(velocity) < 0.5) {
          Animated.spring(translateX, {
            toValue: 0,
            useNativeDriver: false,
            bounciness: 10,
          }).start();
        } else {
          Animated.decay(translateX, {
            velocity: velocity,
            deceleration: 0.997,
            useNativeDriver: false,
          }).start();
        }
      },
    })
  ).current;

  return (
    <View style={styles.container}>
      <Animated.View
        style={[styles.circle, { transform: [{ translateX }] }]}
        {...panResponder.panHandlers}
        accessibilityLabel="Draggable circle"
        accessible={true}
      />
      <Text style={styles.instructions} accessibilityRole="text">
        Drag the circle left or right{'
'}Release to see spring or decay
      </Text>
    </View>
  );
}

const styles = StyleSheet.create({
  container: {
    flex: 1,
    justifyContent: 'center',
    alignItems: 'center',
    backgroundColor: '#fff',
  },
  circle: {
    width: 80,
    height: 80,
    borderRadius: 40,
    backgroundColor: '#4a90e2',
  },
  instructions: {
    marginTop: 20,
    fontSize: 16,
    color: '#333',
    textAlign: 'center',
  },
});

This solution uses React Native's Animated API to create a draggable circle that responds to user gestures.

We use PanResponder to track the horizontal drag movement and update the translateX animated value accordingly.

When the user releases the drag, we check the horizontal velocity (gestureState.vx). If the velocity is small (less than 0.5), we animate the circle back to the center using a spring animation, which gives a natural bounce effect.

If the velocity is larger, we use a decay animation that simulates momentum, letting the circle continue moving and gradually slow down.

We set useNativeDriver: false because the translation affects layout and gesture handling.

Accessibility labels are added for screen readers, and the UI is simple and clear for easy interaction.

Final Result
Completed Screen
┌───────────────────────────────┐
│ Spring and Decay Animations    │
├───────────────────────────────┤
│                               │
│           ○                   │
│                               │
│ Drag the circle left or right │
│ Release to see spring or decay│
└───────────────────────────────┘
User touches and drags the blue circle horizontally.
Circle moves following the finger horizontally.
When user releases the circle with slow movement, it springs back to center with bounce.
When user releases the circle with fast movement, it continues moving with decay animation and slows down gradually.
Stretch Goal
Add a toggle button to switch between light and dark mode for the screen.
💡 Hint
Use React state to track mode and change background and text colors accordingly.

Practice

(1/5)
1. What is the main purpose of a spring animation in React Native?
easy
A. To create a bouncy and natural movement effect
B. To instantly change a value without animation
C. To simulate a slow fade out effect
D. To repeat an animation infinitely

Solution

  1. Step 1: Understand spring animation behavior

    Spring animations mimic real-world springs, causing bouncy, natural movements.
  2. Step 2: Compare with other animation types

    Unlike decay or timing animations, spring animations create a bounce effect.
  3. Final Answer:

    To create a bouncy and natural movement effect -> Option A
  4. Quick Check:

    Spring animation = bouncy movement [OK]
Hint: Spring = bounce and natural movement [OK]
Common Mistakes:
  • Confusing spring with decay animation
  • Thinking spring is for instant changes
  • Assuming spring repeats infinitely
2. Which of the following is the correct way to start a spring animation using React Native's Animated API?
easy
A. Animated.decay(value, {toValue: 1}).start()
B. Animated.spring(value, {duration: 1000}).run()
C. Animated.timing(value, {toValue: 1}).run()
D. Animated.spring(value, {toValue: 1}).start()

Solution

  1. Step 1: Identify correct method for spring animation

    The method is Animated.spring with parameters including toValue and then .start() to begin.
  2. Step 2: Check method usage and syntax

    Animated.decay is for decay animations, .run() is not a valid method, and duration is not used in spring.
  3. Final Answer:

    Animated.spring(value, {toValue: 1}).start() -> Option D
  4. Quick Check:

    Use Animated.spring(...).start() for spring animation [OK]
Hint: Use .start() to begin spring animation [OK]
Common Mistakes:
  • Using .run() instead of .start()
  • Confusing decay with spring method
  • Adding duration to spring config
3. What will happen when this code runs?
const anim = new Animated.Value(0);
Animated.decay(anim, {velocity: 3, deceleration: 0.997}).start();
anim.addListener(({value}) => console.log(value));
medium
A. The value will increase quickly then slow down gradually
B. The value will jump instantly to 3 and stop
C. The value will decrease to zero immediately
D. The animation will loop forever without stopping

Solution

  1. Step 1: Understand decay animation behavior

    Decay animation starts with a velocity and slows down gradually due to deceleration.
  2. Step 2: Analyze given parameters

    Velocity 3 means value increases fast initially, deceleration 0.997 slows it down over time.
  3. Final Answer:

    The value will increase quickly then slow down gradually -> Option A
  4. Quick Check:

    Decay animation = fast start + slow stop [OK]
Hint: Decay = fast start, then slow down [OK]
Common Mistakes:
  • Thinking decay jumps instantly to velocity
  • Assuming decay decreases value immediately
  • Believing decay loops infinitely
4. Identify the error in this spring animation code:
const anim = new Animated.Value(0);
Animated.spring(anim, {toValue: 1, velocity: 5}).run();
medium
A. Missing toValue property in spring config
B. Using .run() instead of .start() to begin animation
C. Velocity is not a valid spring config property
D. Animated.Value should be initialized with 1

Solution

  1. Step 1: Check method to start animation

    Animated animations use .start() to begin, not .run().
  2. Step 2: Verify spring config properties

    toValue and velocity are valid properties; initial value 0 is fine.
  3. Final Answer:

    Using .run() instead of .start() to begin animation -> Option B
  4. Quick Check:

    Use .start() to run animations [OK]
Hint: Animations start with .start(), not .run() [OK]
Common Mistakes:
  • Using .run() instead of .start()
  • Removing toValue from config
  • Initializing Animated.Value incorrectly
5. You want to create a button that moves right with a spring animation and then slows to stop with a decay animation when released. Which sequence of code correctly achieves this behavior?
hard
A. Animated.spring(anim, {toValue: 100, velocity: 2}).start()
B. Animated.decay(anim, {velocity: 2}).start(() => Animated.spring(anim, {toValue: 100}).start())
C. Animated.spring(anim, {toValue: 100}).start(() => Animated.decay(anim, {velocity: 2}).start())
D. Animated.timing(anim, {toValue: 100, duration: 500}).start(() => Animated.decay(anim, {velocity: 2}).start())

Solution

  1. Step 1: Understand desired animation sequence

    First move right with spring (bouncy), then slow down with decay on release.
  2. Step 2: Analyze options for correct order and methods

    Animated.spring(anim, {toValue: 100}).start(() => Animated.decay(anim, {velocity: 2}).start()) runs spring first, then decay in callback, matching desired sequence.
  3. Step 3: Check other options

    Animated.spring(anim, {toValue: 100, velocity: 2}).start() performs only spring without decay. Animated.decay(anim, {velocity: 2}).start(() => Animated.spring(anim, {toValue: 100}).start()) (Animated.decay(anim, {velocity: 2}).start(() => Animated.spring(anim, {toValue: 100}).start())) reverses order. Animated.timing(anim, {toValue: 100, duration: 500}).start(() => Animated.decay(anim, {velocity: 2}).start()) uses timing instead of spring.
  4. Final Answer:

    Animated.spring(anim, {toValue: 100}).start(() => Animated.decay(anim, {velocity: 2}).start()) -> Option C
  5. Quick Check:

    Spring then decay = move then slow [OK]
Hint: Run spring first, then decay in callback [OK]
Common Mistakes:
  • Running decay before spring
  • Performing only spring without decay
  • Using timing instead of spring for bounce
Recommended

Ready to prove it?

Pass the test and this pattern moves unknown strong while earning +1 Grip toward your certificate.

10 questions~5 mineasy hard