Mastering Dependency Injection

In this post, we’ll explore design patterns, demystify Dependency Injection, and set the stage for learning about Koin—a popular DI library in Android.

What Are Design Patterns?

Design patterns are tried-and-tested solutions to common problems. They are not specific implementations but rather templates that guide developers in designing flexible, reusable, and maintainable software.

Common Design Patterns

Here are a few examples of widely used design patterns:

Singleton Pattern: Ensures that a class has only one instance and provides a global point of access to it. Example: Managing a shared database connection.
Factory Pattern: Provides a method to create objects without specifying their exact class.
Observer Pattern: Enables one-to-many dependencies, where changes in one object notify others. Example: LiveData in Android.
Dependency Injection Pattern: Decouples object creation from its usage by injecting dependencies from an external source. This is the focus of today’s discussion.

Dependency Injection: A Game-Changer for Modern Apps

What Is Dependency Injection?

Dependency Injection is a design pattern used to manage dependencies within an application. Instead of having a class create its dependencies, an external source provides (or "injects") them. This approach decouples components and makes them easier to test and maintain.

Understanding Dependencies

A dependency is any object that a class requires to function. For example:

class UserRepository(private val apiService: ApiService) {
    fun getUserData() = apiService.fetchUser()
}

Here, ApiService is a dependency of UserRepository.

Without DI, you might instantiate ApiService directly inside UserRepository. However, this tightly couples the two classes and makes it harder to test or switch out implementations.

Benefits of Dependency Injection

Loose Coupling: Classes depend on abstractions rather than concrete implementations.
Improved Testability: Easily inject mock dependencies during testing.
Scalability: Simplifies managing dependencies in large applications.
Flexibility: Swap out implementations with minimal code changes.

Types of Dependency Injection

There are three primary ways to inject dependencies:

Constructor Injection: Dependencies are provided via the class constructor.

class UserRepository(private val apiService: ApiService)

Setter Injection: Dependencies are provided via public setters.

class UserRepository {
    lateinit var apiService: ApiService
}

Why Dependency Injection Matters in Android?

In Android development, applications grow quickly and involve multiple layers like data repositories, view models, and UI components. Without a DI framework, managing these dependencies can become cumbersome and error-prone.

For example, consider this tightly coupled code:

class LoginViewModel {
    private val userRepository = UserRepository(ApiService())
}

Here, LoginViewModel directly creates its dependencies, making it difficult to test or replace UserRepository or ApiService.

Using DI, this can be rewritten as:

class LoginViewModel(private val userRepository: UserRepository)

Now, LoginViewModel relies on an external provider to inject UserRepository, which can easily be mocked during testing.

Transition to Koin: Simplifying Dependency Injection

While DI can be implemented manually, frameworks like Koin make it effortless by providing:

A lightweight and developer-friendly API.
Simplified setup for Android projects.
Seamless integration with Jetpack libraries like ViewModel and Compose.

In the next post, we’ll dive deeper into how to set up and use Koin in your Android projects, starting with its core concepts and a simple “Hello Koin” example. From there, we’ll explore advanced topics like using Koin in Jetpack Compose and testing with Koin.

Akshay Nandwana
Founder AndroidEngineers

You can connect with me on:

Book 1:1 Session here Click Here

Join our upcoming classes
https://www.androidengineers.in/courses