Handling Component-Specific Loading and Data State with Redux for API Calls in React Native

When building React Native applications, managing the loading state and data can become complex, especially if you want to centralize API logic in Redux but maintain component-level control over temporary states, such as loaders. Here, we’ll explore an approach that leverages Redux for API calls, while keeping the loading and data state isolated within the component, making the UI self-contained and reusable.

This approach is especially beneficial in situations where:

• The API logic should be centralized for consistency and maintainability.
• The component doesn’t need global state management for UI states like loading and fetched data display.

Let’s dive into how to set this up.

1. Setting Up the Redux Slice with createAsyncThunk

Using createAsyncThunk from Redux Toolkit, we can define a thunk for making the API call. This function returns a promise, allowing the component to know when the call is completed and handle the loader accordingly.

dataSlice.js

import { createSlice, createAsyncThunk } from '@reduxjs/toolkit';

// Define an async thunk for the API call
export const fetchData = createAsyncThunk('data/fetchData', async () => {
  const response = await fetch('https://api.example.com/data'); // Replace with your API
  const data = await response.json();
  return data; // Returns the fetched data to the action payload
});

const dataSlice = createSlice({
  name: 'data',
  initialState: {
    items: [],
  },
  reducers: {},
  extraReducers: (builder) => {
    builder
      .addCase(fetchData.fulfilled, (state, action) => {
        state.items = action.payload; // This saves the data in Redux if needed elsewhere
      });
  },
});

export default dataSlice.reducer;

Here’s what’s happening:

• fetchData is an async thunk that fetches data from an API.
• Once the API call is complete, fetchData.fulfilled is triggered, updating the items state in Redux if you want to store the data globally. However, this isn’t necessary for display purposes in the component itself.

2. Creating the Component with Local State for Loading and Data

The component can locally handle the loading and data state, providing control over the loading indicator and displaying the data only within this component.

MyComponent.js

import React, { useState } from 'react';
import { View, ActivityIndicator, Text, Button } from 'react-native';
import { useDispatch } from 'react-redux';
import { fetchData } from './dataSlice';

const MyComponent = () => {
  const [loading, setLoading] = useState(false); // Local loading state
  const [data, setData] = useState([]); // Local data state
  const dispatch = useDispatch();

  const handleFetchData = async () => {
    setLoading(true); // Start the local loader

    try {
      const resultAction = await dispatch(fetchData()); // Dispatch Redux action
      if (fetchData.fulfilled.match(resultAction)) {
        setData(resultAction.payload); // Set the data locally in the component
      }
    } catch (error) {
      console.error('Error fetching data:', error);
    } finally {
      setLoading(false); // Stop the loader after API call completes
    }
  };

  return (
    <View>
      {loading ? (
        <ActivityIndicator size="large" color="#0000ff" />
      ) : (
        data.map((item, index) => <Text key={index}>{item.name}</Text>) // Adjust based on data structure
      )}
      <Button title="Reload Data" onPress={handleFetchData} />
    </View>
  );
};

export default MyComponent;

Explanation

1. Local State for Loader and Data:

   • loading and data are managed within the component using useState, keeping them isolated from the global Redux state.
   • This enables each instance of MyComponent to manage its own loader and data without affecting other parts of the app.

2. Dispatching Redux Action:

   • The handleFetchData function dispatches fetchData using Redux. This action returns a promise, allowing us to handle asynchronous loading in a clean manner.
   • If the action is fulfilled, the fetched data (resultAction.payload) is set locally to data.

3. Displaying the Loader and Data:

   • While loading, an ActivityIndicator is shown, providing feedback to the user.
   • Once the data is fetched, it’s displayed locally in the component.

Why This Approach?

This approach balances the power of Redux with local component management, making it highly modular and flexible:

• Centralized API Management: By placing the API logic in Redux, you can reuse this action across multiple components while ensuring a single source of truth for API calls.
• Self-Contained Component Logic: Components control their loaders and data display independently. This local handling reduces the complexity of managing temporary states like loaders in Redux, which don’t need to persist globally.
• Improved Reusability: Components can independently manage API calls without needing extensive props for loading or data, making them easier to reuse in different contexts.

Conclusion

This technique provides a clean, modular way to manage API calls with Redux while keeping the UI responsive and isolated in each component. By leveraging promise-based actions and local state, you gain control over temporary UI states and still keep your API logic centralized, making your codebase more maintainable and scalable.

Try implementing this approach in your projects where you need centralized API handling and independent UI control – it’s a great way to combine the best of Redux and React’s local state management!