Achieving Optimal Performance with Flutter Provider State Management

Are you familiar with Flutter state management?

Flutter state management entails various tasks, such as calling your app's network function, installing networking libraries, parsing data, and updating it on the main UI thread. Handling this can be difficult if you are new to Flutter state management concepts.

Every developer takes a different approach to the same work because there is no one "perfect solution" for all use cases. However, the developer's choice, knowledge of that approach, and level of comfort with it all influence the efficiency of the work done.

This article looks into the Flutter Provider state management and how to use Provider state manager in your Flutter application.

So, before you start, make sure you understand the state management in Flutter.

‍

What is state management in Flutter?

When developing the front-end app, it is necessary to handle the responses to each event triggered by UI activity. Technically, we must manage the state of UI components that change due to end-user interaction.

While managing the UI state, you may need to divide the massive UI into multiple smaller components while maintaining good communication.

Furthermore, all UI components should always know the application's state.

Flutter supports various state management strategies, with the default setState function being the most basic. Although it is easy to use, you can only partially rely on it.

Other variables to consider when designing a Flutter app include app complexity, scalability, and architecture. That is why you want a comprehensive and successful strategy to state management.

Provider, BLoC, and Redux are Flutter's most common state management options. 

Here let's discuss the Flutter Provider state management.

Also, know more about the popular Flutter state management packages in 2023.

‍

What is Flutter Provider state management?

The Provider is a state management solution that extends and simplifies Inherited Widgets. It is a versatile and powerful state manager that allows you to deliver data to any widget in your app. Also, it is fast and optimized to rebuild only the widgets that need to be updated.

The Provider makes data values such as state model objects accessible to child widgets. The package works like a straightforward and user-friendly wrapper for the Inherited Widgets. 

‍

But what is an Inherited Widget?

Inherited Widget is a widget that may send data down to its child widgets without having to send that data down each level of the widget tree directly. This makes it an excellent choice for handling app-wide states.

It offers a state management strategy for managing the allocation and disposal of resources.

The Flutter UI can move data down a widget tree from parent to child, where it can be used. It is effective till your app becomes more complex and massive. 

Consider passing the data above where we intend to use it elsewhere in the tree. As a result, you only need to inject the data when it is required. That is where the Flutter Provider state management comes in.

‍

Three essential components of Flutter Provider state management: 

Before using the provider state management in the Flutter app, we must first understand these basic concepts:

1. ChangeNotifier
2. ChangeNotifierProvider
3. Consumer

‍

ChangeNotifier

ChangeNotifier is a class that notifies its listeners when something changes. It is a more straightforward method for a limited number of listeners. It notifies its listeners about changes to the model using the notifyListeners() method.

‍

For example, let us create a class CounterModel that extends ChangeNotifier and has a function incrementCounter() that will increment the counter and tell its listeners about the changes using notifyListeners(), and the UI will be changed.

Copy
1
2
3
4
5
6
7
8
9
10
11
12
      import 'package:flutter/material.dart';
      class CounterModel with ChangeNotifier {
      int _counter = 0;
      CounterModel(this._counter);
      getCounter() => _counter;
      setCounter() => _counter= counter;
    	void incrementCounter() {
      	_counter++;
          notifyListeners();
      }
    }
     

‍

ChangeNotifierProvider

Simply put, ChangeNotifierProvider is a widget that delivers a ChangeNotifier instance. The code excerpt below will help you understand how it works.

Copy
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
     class MyApp extends StatelessWidget {
      @override
      Widget build(BuildContext context) {
    	return MaterialApp(
      	theme: ThemeData(
        	primarySwatch: Colors.blue,
      	),
      	home: ChangeNotifierProvider<CounterModel>(
        	builder: (_) => CounterModel(),
        	child: CounterModelView(),
      	),
    	);
      }
    }
     

‍

Consumer

It is a widget with a builder function that is used to build the UI based on model updates. The builder function will pass the context, counter, and child parameters. Context is the same as every other widget creation function. The CounterModel member that was noticed for change is the counter. For optimization, the third argument child is used.

Copy
1
2
3
4
5
6
     return Consumer<CounterModel>(
      builder: (context, counterModel, child) {
    	return Text("the value of counter is : ${counterModel.counter}");
      },
    );
     

‍

Using Provider for state management in Flutter

To use Provider in your Flutter app, create a new project first, then add the following line to your pubspec.yaml file's dependencies block:

Copy
1
2
3
      dependencies:
     provider: ^5.0.0
     

To get a local copy of the package, run the pub get command.

Copy
1
2
     flutter pub get
     

The next step is to build a new Material app in the main.dart file.

Copy
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
     import 'package:flutter/material.dart';
    
    void main() => runApp(MyApp());
    
    class MyApp extends StatelessWidget {
     @override
     Widget build(BuildContext context) {
     return MaterialApp(
      title: 'Material App',
      home: Scaffold(
      appBar: AppBar(
       title: Text('Material App Bar'),
      ),
      body: Center(
       child: Container(
       child: Text('Hello World'),
       ),
      ),
      ),
     );
     }
    }
     

‍

Managing state data

Create a new class now that includes the state data needed for the application. Here we name it as ‘UserDetailsProvider’. All the methods dealing with handling the state in this case will be declared in the UserDetailsProvider class.

This class extends the ChangeNotifier class, which offers access to the notifyListeners function, which will be used to notify listening widgets to rebuild when the state changes.

We define name and age as the two controllers for our TextFormField. This class also declares the method for updating the user's name and age based on input from the user.

This page declares everything about the app's current state:

Copy
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
      class UserDetailsProvider extends ChangeNotifier {
     TextEditingController nameController = TextEditingController();
     TextEditingController ageController = TextEditingController();
     int _age = 0;
     String _userName = '';
     int get userAge => _age;
     String get userName => _userName;
     void updateAge(int age) {
     _age = age;
     notifyListeners();
     }
     void updateName(String name) {
     _userName = name;
     notifyListeners();
     }
    }
     

‍

Updating the state

After updating the name, we call the notifyListeners function, which notifies the listening widgets of a change in the state and, as a result, causes a rebuild of all relevant widgets.

Now that we have the UserDetailsProvider class (which manages the state), we must use ChangeNotifierProvider to connect the class to the screen. Now, in the runApp method of the main block, enclose the entire program in a ChangeNotifierProvider.

Two significant attributes are exposed by the ChangeNotifierProvider: create and child. The created property accepts the class we declared, which extends ChangeNotifier, and links the class to the screen:

Copy
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
     import 'package:flutter/material.dart';
    import 'package:provider/provider.dart';
    void main() => runApp(
      ChangeNotifierProvider<UserDetailsProvider>(
      create: (_) => UserDetailsProvider(),
      child: MyApp(),
      ),
     );
    // ignore: use_key_in_widget_constructors
    class MyApp extends StatelessWidget {
     @override
     Widget build(BuildContext context) {
     return const MaterialApp(
      title: 'Material App',
      home: HomeScreen(),
     );
     }
    }
     

Now that the app is connected to the class that provides the state, any change in the state triggers a rebuild of the app's displays.

‍

Pros and Cons of Flutter Provider state management

Here are the key advantages and disadvantages of Flutter Provider state management.

‍

Advantages of using Flutter Provider state management

• In Flutter, the Provider is a lightweight and adaptable state management option.
• In comparison to other solutions, it allows for a more granular and localized approach to state management.
• Provider supports dependency injection, making sharing object instances across your project simple.
• It works well with Flutter features like streams, ChangeNotifier, and ValueNotifier.

‍

Disadvantages of using Flutter Provider state management

• For beginners, the provider can be tough to set up and understand.
• It might not be the ideal choice for managing more sophisticated and dynamic states that must be shared by multiple widgets.
• The service lacks built-in support for time-travel debugging, making debugging some bugs more difficult.

‍

Using Provider for Flutter state management

Let's see in which scenario we can use Provider state managers in your Flutter application. And also when not to use this.

‍

When to use Flutter Provider state management

• A provider is an excellent choice for small and medium-sized apps with minimal state management requirements.
• Provider is a smart choice if your program has a hierarchical structure with multiple nested widgets that need access to the same state.
• If you need to share objects across multiple portions of your app, Provider can make it easy.

‍

When not to use Flutter Provider state management

• For larger apps with sophisticated state management requirements, the Provider may not be the ideal option.
• If you need to share state across multiple portions of your app and have a lot of dependencies, you might want to explore Redux or Bloc.
• If your state management requirements are basic, you may not need to use Provider.

‍

Best practices for using Provider

Following are the best practices for using Flutter Provider state management.

• Instead of providing everything to the highest degree, provide only what is required.
• When using Provider.of() to consume data, only listen to updates if necessary; otherwise, use listen:false.
• Consume at a specific level with the Consumer widget to avoid recreating the entire tree.
• When utilizing the Consumer widget, utilize the child option to indicate which parts of the independent widget tree do not need to be rebuilt.
• When using ChangeNotifierProvider, select the appropriate choice of create or value based on whether the provider value is current or being created for the first time.

‍

Ready to manage your app state with the Provider package?

State management is an essential component of any Flutter app. It is critical to select the appropriate state management library for your project based on its complexity and your degree of experience. 

The Provider is an excellent choice for maintaining the state in your Flutter project since it is simple to use and versatile enough to manage both simple and complicated states. You may use it to ensure your app runs well and your users have a positive experience.

Are you worrying about managing your Flutter application states?

Well,  if you are using DhiWise , stop bothering about using state managers in your Flutter app. This platform provides you with inbuilt support for the Provider, GetX , BLoC, Riverpod approach as well as the Stateless approach. So, managing the state with Flutter Builder is going to be easier than ever. 

Find out more about DhiWise Flutter builder and sign up for free to start building your next app with DhiWise.