Understanding Dependency Injection in Flutter

What is Dependency Injection (DI)?

Dependency Injection (DI) is a design pattern that helps manage dependencies in an application. Instead of objects creating their own dependencies, DI allows them to receive dependencies from an external source. This improves code modularity, testability, and flexibility.

What is Coupling?

Coupling refers to how strongly different parts of a system depend on each other.

• Tightly Coupled Code: When one class directly creates or manages another class, making it hard to modify or replace dependencies without affecting multiple parts of the system.
• Loosely Coupled Code: When dependencies are passed externally, making components interchangeable and testable.

DI reduces coupling by allowing objects to receive dependencies rather than creating them.

Example Without Dependency Injection (Tightly Coupled Code)

Consider a Flutter Bloc that fetches data from a DatabaseService. Here’s a tightly coupled version:

class DatabaseService {
  void fetchData() {
    print("Fetching data from database...");
  }
}

class CounterBloc extends Cubit<int> {
  final DatabaseService _databaseService = DatabaseService(); // Direct dependency

  CounterBloc() : super(0);

  void increment() {
    _databaseService.fetchData();
    emit(state + 1);
  }
}

Problems with Tightly Coupled Code:

• The CounterBloc directly creates DatabaseService, making it difficult to replace or mock for testing.
• Any change to DatabaseService might require changes in CounterBloc, violating Open/Closed Principle.
• Harder to reuse CounterBloc with a different data source.

Example With Dependency Injection (Loosely Coupled Code)

We can refactor the CounterBloc to accept its dependencies via DI:

class DatabaseService {
  void fetchData() {
    print("Fetching data from database...");
  }
}

class CounterBloc extends Cubit<int> {
  final DatabaseService _databaseService;

  CounterBloc(this._databaseService) : super(0);

  void increment() {
    _databaseService.fetchData();
    emit(state + 1);
  }
}

Benefits of This Approach:

✅ CounterBloc no longer creates DatabaseService, making it loosely coupled. ✅ It can now receive any implementation of DatabaseService, allowing dependency injection. ✅ Makes unit testing easier by allowing a mock implementation of DatabaseService.

Using Dependency Injection in Flutter with Bloc and Provider

Flutter provides Provider to manage dependency injection efficiently. Here’s how you can inject dependencies in a Flutter app using Bloc and Provider together:

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

class DatabaseService {
  String fetchData() => "Data from database";
}

class CounterBloc extends Cubit<int> {
  final DatabaseService _databaseService;

  CounterBloc(this._databaseService) : super(0);

  void increment() {
    _databaseService.fetchData();
    emit(state + 1);
  }
}

void main() {
  runApp(
    MultiProvider(
      providers: [
        Provider(create: (context) => DatabaseService()),
        Provider(create: (context) => CounterBloc(context.read<DatabaseService>())),
      ],
      child: MyApp(),
    ),
  );
}

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

class HomePage extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    final counterBloc = context.read<CounterBloc>();
    return Scaffold(
      appBar: AppBar(title: Text('DI with Bloc Example')),
      body: Center(
        child: BlocBuilder<CounterBloc, int>(
          builder: (context, state) {
            return Text('Counter: $state');
          },
        ),
      ),
      floatingActionButton: FloatingActionButton(
        onPressed: () => counterBloc.increment(),
        child: Icon(Icons.add),
      ),
    );
  }
}

Key Takeaways

• Without DI: Objects create their own dependencies, leading to tight coupling.
• With DI: Dependencies are passed externally, improving flexibility and testability.
• In Flutter: Provider is a great way to manage dependency injection, especially with Bloc.

Which Approach Should You Use?

If your app is small, you may not need DI, but as it grows, using DI ensures:

• Better separation of concerns.
• Easier testing with mock dependencies.
• More maintainable and scalable code.

By implementing DI with Bloc in Flutter, you can make your app more modular, testable, and scalable.