Flutter Mobile Development · Lesson

Riverpod for State

Explore Riverpod, a robust and testable state management library, and understand its advantages over other solutions for complex apps.

Riverpod for State is a free Flutter Mobile Development lesson on CoddyKit — lesson 3 of 4. You can read the complete lesson below for free — then practise it hands-on in the browser with a built-in code editor and a 24/7 AI tutor. It is part of the Flutter Mobile Development learning path, one of 4 lessons in the course, and your progress syncs across the web and the CoddyKit app.

Welcome to Riverpod!

Riverpod is a popular state management library for Flutter that aims to be simple, robust, and testable. It's a reimagined version of the Provider package, designed to address some of its limitations.

Think of Riverpod as a powerful toolkit for managing all the data in your app, from user settings to fetched data, in a safe and predictable way.

Riverpod's Core Strengths

Riverpod offers several key advantages:

Compile-time Safety: Catches errors early, before your app even runs.
Testability: Makes it easy to test your business logic in isolation.
Auto-Dispose: Providers can automatically clean up resources when no longer needed.
No Widget Tree Dependency: Providers don't rely on the widget tree, making them more flexible.

It helps you write cleaner, more maintainable code.

Setting Up Your App

To use Riverpod, first add the flutter_riverpod package to your pubspec.yaml. Then, wrap your entire application with a ProviderScope widget. This widget stores the state of all your providers.

Here's how to set it up:

import 'package:flutter/material.dart';
import 'package:flutter_riverpod/flutter_riverpod.dart';

void main() {
  runApp(
    // Wrap your app in a ProviderScope
    ProviderScope(
      child: MyApp(),
    ),
  );
}

class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      home: Text('Hello Riverpod'),
    );
  }
}

Introducing Providers

Providers are the core building blocks of Riverpod. They hold a piece of state and allow you to access it from anywhere in your app.

The simplest provider is a Provider, which holds an immutable value. You define it globally, making it accessible throughout your application.

import 'package:flutter_riverpod/flutter_riverpod.dart';

// A simple Provider that holds an immutable string.
final greetingProvider = Provider<String>((ref) {
  return 'Hello from Riverpod!';
});

// You can also provide numbers, objects, etc.
final counterProvider = Provider<int>((ref) => 0);

Consuming Providers with `ConsumerWidget`

To read a provider's value in your UI, you use a ConsumerWidget. This widget gives you access to a WidgetRef (often named ref), which lets you 'watch' or 'read' providers.

ref.watch() makes your widget rebuild when the provider's value changes.

import 'package:flutter/material.dart';
import 'package:flutter_riverpod/flutter_riverpod.dart';

final greetingProvider = Provider<String>((ref) {
  return 'Hello Riverpod User!';
});

void main() {
  runApp(ProviderScope(child: MyApp()));
}

class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      home: ConsumerWidget(
        builder: (context, ref, child) {
          final greeting = ref.watch(greetingProvider);
          return Scaffold(
            appBar: AppBar(title: Text('Riverpod App')),
            body: Center(child: Text(greeting)),
          );
        },
      ),
    );
  }
}

Mutable State with `StateProvider`

When you need to change a piece of state directly, use a StateProvider. It exposes a StateController, which has a state property you can modify.

This is perfect for simple UI states like a toggle or a counter.

import 'package:flutter/material.dart';
import 'package:flutter_riverpod/flutter_riverpod.dart';

// A StateProvider for a simple counter.
final counterProvider = StateProvider<int>((ref) => 0);

void main() {
  runApp(ProviderScope(child: MyApp()));
}

class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      home: ConsumerWidget(
        builder: (context, ref, child) {
          final count = ref.watch(counterProvider);
          return Scaffold(
            appBar: AppBar(title: Text('Counter App')),
            body: Center(
              child: Text(
                'Count: $count',
                style: TextStyle(fontSize: 24),
              ),
            ),
            floatingActionButton: FloatingActionButton(
              onPressed: () => ref.read(counterProvider.notifier).state++,
              child: Icon(Icons.add),
            ),
          );
        },
      ),
    );
  }
}

`StateNotifierProvider` for Logic

For more complex state that involves business logic (e.g., fetching data, managing lists), you'll use a StateNotifier with StateNotifierProvider.

StateNotifier is a class you extend, and it holds your state. The provider then exposes an instance of your notifier.

import 'package:flutter_riverpod/flutter_riverpod.dart';

// 1. Define your state class (immutable recommended)
class Todo { 
  final String id; 
  final String description; 
  final bool completed; 
  Todo(this.id, this.description, this.completed); 
}

// 2. Create a StateNotifier to manage the state
class TodosNotifier extends StateNotifier<List<Todo>> {
  TodosNotifier() : super([]); // Initial state is an empty list

  void addTodo(String description) {
    state = [...state, Todo(DateTime.now().toString(), description, false)];
  }

  void toggle(String id) {
    state = [ 
      for (final todo in state) 
        if (todo.id == id) 
          Todo(todo.id, todo.description, !todo.completed) 
        else 
          todo, 
    ];
  }
}

// 3. Create the StateNotifierProvider
final todosProvider = StateNotifierProvider<TodosNotifier, List<Todo>>((ref) {
  return TodosNotifier();
});

Async Data with `FutureProvider`

Riverpod makes handling asynchronous data (like network requests) a breeze with FutureProvider and StreamProvider.

A FutureProvider exposes an AsyncValue, which gracefully handles loading, error, and data states in your UI.

import 'package:flutter/material.dart';
import 'package:flutter_riverpod/flutter_riverpod.dart';

// A FutureProvider that simulates fetching data.
final userProvider = FutureProvider<String>((ref) async {
  await Future.delayed(Duration(seconds: 2)); // Simulate network delay
  return 'John Doe';
});

void main() {
  runApp(ProviderScope(child: MyApp()));
}

class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      home: ConsumerWidget(
        builder: (context, ref, child) {
          final userAsyncValue = ref.watch(userProvider);
          return Scaffold(
            appBar: AppBar(title: Text('Async Data')),
            body: Center(
              child: userAsyncValue.when(
                loading: () => CircularProgressIndicator(),
                error: (err, stack) => Text('Error: $err'),
                data: (user) => Text('User: $user', style: TextStyle(fontSize: 24)),
              ),
            ),
          );
        },
      ),
    );
  }
}

`ref.read` vs `ref.watch`

When interacting with providers, you'll primarily use two methods on the ref object:

ref.watch(provider): Listens to changes in a provider. If the provider's state changes, the widget or provider watching it will rebuild/re-execute. Use this in build methods.
ref.read(provider): Reads a provider's current value once, without listening for future changes. Ideal for one-off actions, like button presses or initial setup.

Avoid ref.read in build methods unless you specifically don't want rebuilds.

Riverpod Provider Types

Which Riverpod provider types are best suited for managing a simple counter (a single integer that can be incremented/decremented) and for handling complex business logic with multiple actions (e.g., adding/removing items from a to-do list)?

Riverpod Recap

Great job! You've explored Riverpod, a powerful and modern state management solution for Flutter.

We learned about ProviderScope for app setup.
We used Provider for immutable data and StateProvider for simple mutable state.
For complex logic, StateNotifierProvider with StateNotifier is key.
FutureProvider helps manage async data gracefully.
Remember ref.watch for listening and ref.read for one-time access.

Riverpod's compile-time safety and testability make it an excellent choice for robust Flutter applications!

Frequently asked questions

Is the “Riverpod for State” lesson free?

Yes — the full text of “Riverpod for State” is free to read here on the web, and the Flutter Mobile Development course includes 4 lessons in total. To practise it interactively (a built-in code editor and a 24/7 AI tutor) and unlock the rest of the Flutter Mobile Development course, upgrade to CoddyKit PRO.

What will I learn in “Riverpod for State”?

Explore Riverpod, a robust and testable state management library, and understand its advantages over other solutions for complex apps. You practise Flutter Mobile Development with hands-on code you run directly in the browser, and a 24/7 AI tutor answers your questions as you work through the lesson.

Do I need any experience to start Flutter Mobile Development?

No prior experience is required. Flutter Mobile Development on CoddyKit is structured for beginners through advanced learners; this is — lesson 3 of 4, so you can start here or from the beginning and move at your own pace.

How long does the “Riverpod for State” lesson take?

Most CoddyKit lessons take about 5–10 minutes. Each one is bite-sized and interactive, so you make steady progress and pick up exactly where you left off across the web and the app.

Can I write and run code in this Flutter Mobile Development lesson?

Yes. Every Flutter Mobile Development lesson includes a built-in code editor, so you write and run real code right in your browser and get instant AI feedback — no local setup required.

All lessons in this course

← Back to Flutter Mobile Development