DEV Community: Bernardo Iribarne

Dependency Injection in Flutter: implementing the Dependency Inversion principle

Bernardo Iribarne — Fri, 15 Sep 2023 14:30:40 +0000

If you are looking to get your code to the next level, you have to know about dependency injection.

Introduction

When we write code we follow the SOLID guidelines. One of those principles (“D”) take care of Dependency Inversion. Let's see what it means.

Suppose you have a service class called “UserService” that uses a datasource called UserSqlite to get users from a SQLite database:

So Package 1 depends on Package 2. If you have this relation on your code, Mr. SOLID will go to your desktop and say: “Ey, do NOT couple your code with other libraries, what are you thinking about?”.

What about this:

What we have already done was change the dependency direction. Now, Package 2 depends on Package 1. The right direction of dependency makes our code reusable, and eliminates cyclic dependencies.

Dependency Injection

The dependency injection concept will help us to drive the right implementation of the interface IUserDataSource to our UserService.

UserService wouldn’t be concerned about the IUserDataSource implementation, it just uses it.

How can you implement Dependency Injection in Flutter?

I use a package called get_it, you can find it here:

GetIt

I like to wrap the third party packages, because maybe tomorrow I want to change it to another that I like more than this. It is a premise that I have, you can skip that step, but it is one more thing that helps me to have my code the most descouple than I can.

So, I created a class called DependencyManager which wraps the get_it library:

Inject dependencies

In your app config class or your app initializer you have to inject the dependencies you want to have. In the example of the second picture, we have to inject the implementation of IUserDataSource:

 void injectDependencies() {
    try {

      /// Get dependency manager
      DependencyManager manager = DependencyManager();

      /// Register UserSQLite as IUserDataSource
      manager.registerFactory<IUserDataSource>(() => UserSQLite());


    } catch (e2) {
      debugPrint("Manage depency injections error");
    }
  }

And then we must use this manager everywhere we need to use the user data source implementation. Let’s see:

class UserService {

  /// User datasource.
  final IUserDataSource datasource= DependencyManager().get<IUserDataSource>();

  ....
}

DependencyManager manages the implementations of our interface. It registers and returns concrete classes.

DependencyManager

To have the example simple I just showed you how to register a factory for our user datasource, but the dependency manager also could call constructors that requires some parameters, could be a little more complex.

My DependencyManager looks like this:

import 'package:get_it/get_it.dart';

class DependencyManager {

  /// GetIt instance.  
  final getIt = GetIt.instance;

  /// I use singleton to create this manager.
  DependencyManager._internal();

  static final DependencyManager _singleton = DependencyManager._internal();

  factory DependencyManager() {
    return _singleton;
  }

  T get<T extends Object>(){
     return getIt.get<T>();
  }

  T getWithParam<T extends Object, P1>(dynamic p){
    return getIt.get<T>(param1: p);
  }

  T getWith2Param<T extends Object, P1, P2>(dynamic p1, dynamic p2){
    return getIt.get<T>(param1: p1, param2: p2);
  }

  bool isRegistered<T extends Object>(){
    return getIt.isRegistered<T>();
  }

  void registerLazySingleton<T extends Object>(FactoryFunc<T> factoryFunc){
    getIt.registerLazySingleton<T>(factoryFunc );
  }

  void registerFactory<T extends Object>(FactoryFunc<T> factoryFunc){
    getIt.registerFactory<T>(factoryFunc );

  }

  void registerFactoryParam<T extends Object, P1, P2>(
      FactoryFuncParam<T, P1, P2> factoryFunc, {
        String? instanceName,
      }){
    getIt.registerFactoryParam<T,P1,P2>(factoryFunc);
  }

}

Conclusion

We talked about a SOLID principle, the dependency inversion, we introduced to dependency injection and saw how to get implemented it in Flutter.

Now you have the concept, and you know how to apply it. You will drive your code to the next level:

Descoupled
Testeable
Easy to mantain

Thanks for reading, Clap if you like it!

Let me know your comments below.

How to set environment variables in Flutter: a cleaned way

Bernardo Iribarne — Thu, 14 Sep 2023 22:18:10 +0000

Photo by Rima Kruciene on Unsplash

Since Flutter doesn’t have a standard way to use environment settings I will share a cleaned way to do it.

I don’t like using plain text files so I design a few classes to manage the environment.

Let’s see how this look like in our code.

I created a simple AppConfig to show you how it works where I’ve just added a simple variable called appVersion:

abstract class AppConfig {

  /// App name
  String appName => "My App";

  /// App version
  String appVersion => "1.0.0";
}

Then I have a concrete AppConfig for each environment where I’ve rewrited the app version:

class AppConfigDev extends AppConfig{

  /// App version
  String appVersion => "1.0.0-dev";
}

class AppConfigStaging extends AppConfig{

  /// App version
  String appVersion => "1.0.0-staging";
}

class AppConfigProd extends AppConfig{

  /// App version
  String appVersion => "1.0.0-release";
}

Environment class

The magic happens in Environment class. When you run your app in Flutter, you can send some parameters to your app, so I will show you how to send the environment you want to execute. Let’s see the Environment class and then I will talk about that parameter.

import '/src/config/app_config_prod.dart';
import '/src/config/app_config.dart';
import '/src/config/app_config_dev.dart';
import '/src/config/app_config_staging.dart';

/// Enumeration type for each environment
enum EnvironmentType {
  dev("DEV"), staging("STAGING"), prod("PROD");

  final String name;
  const EnvironmentType(this.name);
}

class Environment {

  /// Implements singleton
  Environment._internal();
  static final Environment _singleton = Environment._internal();

  factory Environment() {
    return _singleton;
  }

  late AppConfig config;

  Future<void> initConfig(String environment) async{

    config = _getConfig(environment);
  }

  AppConfig _getConfig(String environment) {
    Map<String, AppConfig> factories = <String, AppConfig>{};
    factories.putIfAbsent( EnvironmentType.dev.name, () => AppConfigDev() );
    factories.putIfAbsent( EnvironmentType.staging.name, () => AppConfigStaging() );
    factories.putIfAbsent( EnvironmentType.prod.name, () => AppConfigProd() );

    AppConfig? config ;
    if( factories.containsKey(environment) ){
      config = factories[environment];
    }

    return config??AppConfigDev();
  }

}

This class has a method to initialize the configuration where it receives a string called environment. We are going to send that string to our App from the Run/Debug Configuration or from the command line. So, when we initialize our App, we have to include this code:

await Environment().initConfig(
       String.fromEnvironment('ENVIRONMENT')
);

Run your App with the desired environment

Now when you run your app you have to send a parameter called ENVIRONMENT. You can do it from the command line or from your IDE.

From the command line:

flutter run --dart-define=ENVIRONMENT=DEV

flutter run --dart-define=ENVIRONMENT=STAGING

flutter run --dart-define=ENVIRONMENT=PROD

From Android Studio:

You have to go to “Edit Configurations” and create one entry for each environment. Below you can see some screenshots

]

Conclusion

We have configured our Flutter environment in a cleaned way. We saw a very simple case but you can improve AppConfig to have anything you want to manage as configuration. For example, I use to have the dependency injections in the AppConfig, so I can change the dependencies regarding to the environment, it is very useful to me.

Thanks for reading, Clap if you like it!

Let me know your comments below.