Hussain Arif Hussain is a CS student in Pakistan whose biggest interest is learning and teaching programming to make the world a better place.

Building an animated loader in React Native

3 min read 1017

Building an Animated Loader in React Native

React Native is an amazing library for developers looking to build mobile apps with speed. It provides an efficient way of displaying information to the frontend. But before displaying API data, the application has to first inform the user that the data is on its way.

One way to do so is to leverage the power of animations. Thus, it can also give your UI a more vibrant feel.

For example, what do you think gives a better impression? Rendering a piece of text:

RN Animated Text Loader

Or using a vivid animation:

Vivid RN Loader

In the React Native world, a multitude of libraries exists to help you get up and running. In this guide, we will use lottie-react-native and react-native-animatable. This is because they are an absolute breeze to use and well maintained.

Using Lottie

Let’s say that you built a breathtaking graphic using Adobe After Effects and want to render it in your app. But, this is one major flaw: Adobe does not allow you to do that.

This is where lottie-react-native comes in. It allows developers to render their animations without recreating them via code. It only requires a few lines of code to work, thus letting you focus on more important parts of the project.

Installing modules

To install it in your app, run the following terminal commands:

We made a custom demo for .
No really. Click here to check it out.

npm i lottie-react-native
npm i [email protected]

Acquiring assets

You can use your own animations by exporting them with the Bodymovin plugin. But for this guide, we will use the LottieFiles directory. It includes a ton of free animations that you can import in your project.

In this article, I will use the Sleeping Cat animation.

To use your desired animation in your application, first download it in JSON format like so:

Download Lottie in JSON

Next, move this into the assets folder.

Simple usage

To use Lottie, write the following code:

import React from "react";
import { StyleSheet, View, Text } from "react-native";
import LottieView from "lottie-react-native";
import { useState } from "react";
export default function SimpleLottie() {
  return (
    <View>
      <LottieView
        source={require("./assets/67834-ssssttt-shut-up-the-cat-is-sleeping.json")}
        style={styles.animation}
        autoPlay
      />
    </View>
  );
}
const styles = StyleSheet.create({
  animation: {
    width: 100,
    height: 100,
  },
});

The LottieView component holds our animation config. Here, the source prop tells the location of our asset. Moreover, the autoPlay prop tells Lottie to run the animation on startup.

To render SimpleLottie, write the following code in App.js:

//further code removed..
import SimpleLottie from "./SimpleLottie";
export default function App() {
  return (
    <View style={styles.container}>
      <SimpleLottie />
      <StatusBar style="auto" />
    </View>
  );
}
//...

Sleeping Cat Lottie

Conditional rendering in Lottie

We can even perform conditional rendering on our SimpleLottie component. This will simulate loading functionality:

const [show, setShow] = useState(false);

useEffect(() => {
  setTimeout(() => setShow(true), 3000);
}, []);

return (
  <View style={styles.container}>
    {show ?<Text>Finished loading!</Text> : <SimpleLottie /> }
    <StatusBar style="auto" />
  </View>
);

In this block of code, we told React to reverse the value of the show Hook after 3 seconds. This will render the Text on the screen.

Sleeping Cat Lottie Loader

Creating a loader component with Lottie

Here, the plan is to show data from Coffee API. While the data is loading, React will display the loading graphic.
Create a file called DataDisplay.js. This component will be useful in displaying list items. Here, write the following code:

import React from "react";
import { StyleSheet, SafeAreaView, FlatList, Text, View } from "react-native";
export default function DataDisplay({ data }) {
  const Item = ({ title }) => (
    <View style={styles.item}>
      <Text>{title}</Text>
    </View>
  );
  const renderItem = ({ item }) => <Item title={item.title} />;
  return (
    <SafeAreaView>
      <FlatList
        data={data}
        renderItem={renderItem}
        keyExtractor={(item) => item.id.toString()}
      />
    </SafeAreaView>
  );
}
const styles = StyleSheet.create({
  item: {
    backgroundColor: "yellow",
    padding: 20,
    marginVertical: 8,
  },
});

A few inferences from this code:

  • We created the Item component and renderItem function. They will work together to render each individual element in the array
  • Later on, we used the FlatList component to render the list

Next, alter your App.js file like so:

export default function App() {
  const [data, setData] = useState(null);
  const fetchData = async () => {
    const resp = await fetch("https://api.sampleapis.com/coffee/hot");
    const data = await resp.json();
    setData(data);
  };
  useEffect(() => {
    fetchData();
  }, []);
  return (
    <View style={styles.container}>
      {data ? <DataDisplay data={data} /> : <SimpleLottie />}
      <StatusBar style="auto" />
    </View>
  );
}

In the above block of code, we told React to fetch data from the API and store the response into the data Hook. After that, React checks whether the response has loaded (data has a value).

If true, the API data is shown. Otherwise, React Native renders the SimpleLottie animation.

This will be the output:

RN Loader if API Data is True

Using react-native-animatable

The react-native-animatable library allows the developer to create their own transitions and animations through the declarative API. This is suitable for loaders and splash screens.

Installation

Run the following terminal command to get the package:

npm install react-native-animatable 

Simple usage

Create a file called SimpleAnimatable.js. Here, write the following block of code:

import * as Animatable from "react-native-animatable";
import React from "react";

export default function SimpleAnimatable() {
  return (
    <Animatable.View>
      <Animatable.Text
        animation="bounce"
        iterationCount={"infinite"}
        direction="normal"
      >
        Loading..
      </Animatable.Text>
    </Animatable.View>
  );
}

Let’s dissect this code piece by piece.

  • The Animatable.View component allows our custom component to have animation functionality
  • Our Text element will have bounce-like behavior. Moreover, we’ve also set the iterationCount property to infinite . This makes the animation loop forever

This will be the output:

Animated Loader Bounce RN

You can even get a “flash-like” animation like so:

<Animatable.Text
   animation="flash"
//....

Flashing Loader in RN

Creating a loader component with react-native-animatable

This step should be straightforward. You can simply use conditional rendering:

{data ? <DataDisplay data={data} /> : <SimpleAnimatable />}

RN Loader Component

Conclusion

In this article, we covered two common strategies for building animations in React Native. In my own projects, I use Lottie because it is rock solid and extremely easy to use.

Furthermore, Lottie includes an imperative API which allows for more granular control over the chosen animation.

Thank you so much for reading!

: Full visibility into your web apps

LogRocket is a frontend application monitoring solution that lets you replay problems as if they happened in your own browser. Instead of guessing why errors happen, or asking users for screenshots and log dumps, LogRocket lets you replay the session to quickly understand what went wrong. It works perfectly with any app, regardless of framework, and has plugins to log additional context from Redux, Vuex, and @ngrx/store.

In addition to logging Redux actions and state, LogRocket records console logs, JavaScript errors, stacktraces, network requests/responses with headers + bodies, browser metadata, and custom logs. It also instruments the DOM to record the HTML and CSS on the page, recreating pixel-perfect videos of even the most complex single-page apps.

.
Hussain Arif Hussain is a CS student in Pakistan whose biggest interest is learning and teaching programming to make the world a better place.

Leave a Reply