How to Use Flutter BLoC for Reactive State Management



April 11, 2023


April 11, 2023

Flutter BLoC (Business Logic Component) is a powerful state management library for Flutter that has captured the hearts of developers all over the world. The reason for its popularity lies in its ability to simplify complex state management in a clean and organized way.

Want to know how? So, here is your answer,

The key benefits of using Flutter BLoC:

1. Separates the application's business logic from the UI layer.

This separation of concerns makes it easy to understand and modify the codebase, even as the application grows in size and complexity.

2. Ideal for building apps with real-time data updates.

The BLoC pattern is based on the concept of streams and reactive programming, which makes it an ideal choice for building applications with real-time data updates. 

3. Manage states in small as well as large applications

It can be used to manage states in small or large-scale enterprise apps. With its modular architecture, developers can easily plug and play different components to fit their specific use case.

4. Strong community support

The popularity of Flutter BLoC can also be attributed to strong community support. There are numerous tutorials, blogs, and packages available that make it easy for developers to get started with BLoC. 

And that’s why the Flutter BLoC is beneficial for developers who value clean, organized code and efficient application development.

“DhiWise Flutter Builder is equipped with support for the Flutter BLoC library, adding a touch of ease and simplicity to the development process for our developers.” Give it a try!

If you're eager to learn more about the wondrous world of Flutter BLoC continue reading this article.

Getting started with the Flutter BLoC

Before diving deep into the Flutter BLoC it's essential to have a basic understanding of Flutter's widgets and how they work. The Flutter website has an extensive documentation section that covers everything you need to know.

1. Flutter BLoC Installation

Here are the steps to install the flutter_bloc library for BLoC in your Flutter project:

a. Open your Flutter project in your preferred IDE or text editor.
b. Open the pubspec.yaml file in your project.
c. Add the following line under the dependencies section:

  flutter_bloc: ^7.0.0

This line specifies the version of the flutter_bloc library you want to install. The “^” character indicates that you want to install the latest minor version of the library. 

d. Then save the changes to the pubspec.yaml file.

Run the command flutter pub get in the terminal to download and install the flutter_bloc library and any other dependencies that you added to your pubspec.yaml file.

Once the installation is complete, you can start using the flutter_bloc library in your Flutter project.

2. The basic concepts of Flutter BLoC:

To use BLoC in your Flutter project with greater ease, you should know some of its basic concepts and they are as follows:

  • Business Logic Component (BLoC): BLoC is a design pattern for managing state in Flutter apps. It separates the business logic from the presentation layer and makes it easier to maintain and test your app.
  • Stream: A stream is a sequence of asynchronous events in Dart. It allows you to receive and process data as it becomes available, instead of waiting for it to be fully available.
  • Sink: A sink is a way to add data to a stream. It allows you to push data to the stream and send it to listeners.
  • Event: An event is a simple object that represents a user action or system event that triggers a state change in the app.
  • State: State is the data that represents the current condition of the app. In BLoC, the state is separated from the UI and managed by the business logic component.
  • StreamController: A StreamController is a class that provides a way to create and manage streams. It allows you to add data to the stream and listen for incoming data.
  • BehaviorSubject: A BehaviorSubject is a special type of StreamController that always emits the last value that was added to the stream. It is commonly used in BLoC to hold the current state of the app.
  • BlocProvider: BlocProvider is a widget that provides a BLoC to its child widgets. It makes it easy to access the BLoC from anywhere in the widget tree.

Now that you know the basics of Flutter BLoC, It’s time to discuss how to create a simple Flutter app using BLoC.

How to create a simple Flutter BLoC application

The following steps will guide you through the creation of a simple Flutter BLoC application. 

So, without any delay, Let’s dive in! 

1. Create a new Flutter project using Android Studio or VS Code.

2. Add the flutter_bloc package to your pubspec.yaml file and run “flutter pub get” to download and install it.

3. Define your BLoC class by extending Bloc and defining your events and states. For example, let's create a simple counter app that increments and decrements a counter.

import 'package:flutter_bloc/flutter_bloc.dart';

// Define the events
enum CounterEvent { increment, decrement }

// Define the states
class CounterState {
  final int count;


// Define the BLoC class
class CounterBloc extends Bloc<CounterEvent, CounterState> {
  CounterBloc() : super(CounterState(0));

  Stream<CounterState> mapEventToState(CounterEvent event) async* {
    switch (event) {
      case CounterEvent.increment:
        yield CounterState(state.count + 1);
      case CounterEvent.decrement:
        yield CounterState(state.count - 1);

4. Create your UI widgets and use the BlocProvider widget to provide the BLoC to the widget tree. For example, let's create a simple CounterPage that displays the counter and two buttons to increment and decrement it.

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

class CounterPage extends StatelessWidget {
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(title: Text('Counter')),
      body: BlocBuilder<CounterBloc, CounterState>(
        builder: (context, state) {
          return Center(
            child: Column(
              children: [
                Text('Count: ${state.count}'),
                SizedBox(height: 16),
                  children: [
                      onPressed: () =>
                      child: Icon(Icons.add),
                    SizedBox(width: 16),
                      onPressed: () =>
                      child: Icon(Icons.remove),

5. In the main.dart file, wrap your MaterialApp with the BlocProvider widget, and pass in the BLoC instance.

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

void main() {

class MyApp extends StatelessWidget {
  Widget build(BuildContext context) {
    return BlocProvider(
      create: (_) => CounterBloc(),
      child: MaterialApp(
        title: 'Counter App',
        home: CounterPage(),

6. Run your app and you should see a simple counter app with a counter and two buttons to increment and decrement it.

Note: This is a very basic example of using BLoC in Flutter. There are many other concepts and patterns that you can use to make your BLoC implementation more robust and maintainable.

These are the simple steps to create a Flutter BLoC application effortlessly. But there are many use cases and features out there that you will know when you become more familiar with this architecture.

Best Practices for using Flutter BLoC

Till now, you have learned about Flutter BLoC, its basic concepts, and how to create a simple Flutter app using BLoC. Now, It’s time to know the best practices for using Flutter BLoC.

Let’s dive into it!

1. Use a single BLoC for each screen:  

Keeping your code organized and clean is crucial for identifying issues and making the debugging process easier. By using a single BLoC, you can reuse the same logic across multiple screens, improving the efficiency of your app.

2. Keep your BLoC simple: 

BLoC should only be responsible for managing the state of your application. Any business logic or data manipulation should be handled in a separate layer.

3. Expose your BLoCs with the provider package:

The provider package simplifies the process of exposing your BLoC to the rest of your application, making it easily accessible from any widget. This enables you to efficiently manage and update your BLoC as needed

4. Use streams instead of UI state sets:

Using a stream separates your business logic from the UI, making it easier to test and debug your code. This enables you to utilize the BLoC pattern for state management, which simplifies maintaining and updating your app over time.

5. Use dependency injection:

 Use a dependency injection framework, like get_it, to manage your BLoC instances.

6. Use flutter_bloc package: 

The flutter_bloc package provides a lot of useful classes and methods for working with BLoC, including BlocProvider, BlocBuilder, BlocListener, and MultiBlocProvider.

7. Ensure that each BLoC has one event class:

This practice allows you to keep all your events related to a particular BLoC in one place. Also, this helps developers to find anything during the time of debugging process or make changes. It simplifies the process of adding new events without having to search through multiple classes. And you can make any changes to existing events effortlessly since all the events are in one place.

8. Use Equatable: 

Equatable is a package that helps you implement the “ ==” operator and hashCode method. It's especially useful for comparing complex objects in your BLoC.

9. Use sealed_unions: 

sealed_unions is a package that helps you create sealed unions (also known as algebraic data types) in Dart. It's useful for modeling state transitions in your BLoC.

10. Use RxDart: 

RxDart is a package that provides additional operators and extensions for working with streams. It's especially useful for complex data processing and transformation.

11. Avoid using sinks in streams:

As a general rule, sinks are used for sending data into streams, and streams are used for receiving data from sinks. And if you use sinks inside of streams it can make it difficult for you to read and maintain code. Not only this, but it also makes the debugging process harder as there is no clear source or destination for the data.

Instead, you can use multiple streams that communicate with each other via transformers. This will help you to organize your code and it simplifies the debugging process as well.

These are some best practices that you should know as a developer. By following these best practices, you can create a scalable and maintainable architecture for your Flutter app using BLoC.


The blog has taken you on a comprehensive journey through the world of Flutter BLoC, from its installation and core concepts to creating a simple application and best practices for implementation.

But the journey doesn't have to end there.

DhiWise Flutter Builder provides you with an innovative platform and offers the best assistance in Flutter app development. It is integrated with all the tools that you need to bring your ideas to life. Let us help you take your Flutter app to the next level!

Flutter Builder support for popular libraries such as GetX, Provider, Riverpod, and BLoC. Moreover, it provides a comprehensive set of features to help you create your app with ease. 

Build type

So, what are you waiting for? 

Apply your learnings, and build your next app effortlessly with DhiWise Flutter Builder, now!