Basics

Implementing dependency injection provides you with the following advantages:

• Reusability of code

• Ease of refactoring

• Ease of testing

What is dependency injection?

Classes often require references to other classes. For example, a Car class might need a reference to an Engine class. These required classes are called dependencies, and in this example the Car class is dependent on having an instance of the Engine class to run.

There are three ways for a class to get an object it needs:

1. The class constructs the dependency it needs. In the example above, Car would create and initialize its own instance of Engine.

2. Grab it from somewhere else. Some Android APIs, such as Context getters and getSystemService(), work this way.

3. Have it supplied as a parameter. The app can provide these dependencies when the class is constructed or pass them in to the functions that need each dependency. In the example above, the Car constructor would receive Engine as a parameter.

The third option is dependency injection! With this approach you take the dependencies of a class and provide them rather than having the class instance obtain them itself.

Manual Dependency Injection

Without DI

Here's an example. Without dependency injection, representing a Car that creates its own Engine dependency in code looks like this:

This is not an example of dependency injection because the Car class is constructing its own Engine. This can be problematic because:

• Car and Engine are tightly coupled - an instance of Car uses one type of Engine. If the Car were to construct its own Engine, you would have to create two types of Car instead of just reusing the same Car for engines of type Gas and Electric.

• The hard dependency on Engine makes testing more difficult.

With DI

What does the code look like with dependency injection? Instead of each instance of Car constructing its own Engine object on initialization, it receives an Engine object as a parameter in its constructor:

The benefits of this DI-based approach are:

• Reusability of Car. You can pass in different implementations of Engine to Car. For example, you might define a new subclass of Engine called ElectricEngine that you want Car to use. If you use DI, all you need to do is pass in an instance of the updated ElectricEngine subclass, and Car still works without any further changes.

• Easy testing of Car.

How to implement?

There are two major ways to do dependency injection in Android:

• Constructor Injection. This is the way described above. You pass the dependencies of a class to its constructor.

• Field Injection (or Setter Injection). Certain Android framework classes such as activities and fragments are instantiated by the system, so constructor injection is not possible. With field injection, dependencies are instantiated after the class is created. The code would look like this:

Auto Dependency Injection

In the previous example, you created, provided, and managed the dependencies of the different classes yourself, without relying on a library. This is called dependency injection by hand, or manual dependency injection.

In the Car example, there was only one dependency, but more dependencies and classes can make manual injection of dependencies more tedious. Manual dependency injection also presents several problems:

• For big apps, taking all the dependencies and connecting them correctly can require a large amount of boilerplate code.

• When you're not able to construct dependencies before passing them in — for example when using lazy initializations or scoping objects to flows of your app — you need to write and maintain a custom container (or graph of dependencies) that manages the lifetimes of your dependencies in memory.

Libraries to perform Dependency Injection

• Dagger

Dagger is a popular dependency injection library for Java, Kotlin, and Android that is maintained by Google.

• Hilt

Hilt is Jetpack's recommended library for dependency injection in Android. Hilt defines a standard way to do DI in your application by providing containers for every Android class in your project and managing their lifecycles automatically for you.Hilt is built on top of the popular DI library Dagger to benefit from the compile time correctness, runtime performance, scalability, and Android Studio support that Dagger provides.

DI using HILT

Steps to add HILT in your app:

• First, add the hilt-android-gradle-plugin plugin to your project's root build.gradle file:

  id("com.google.dagger.hilt.android") version "2.44" apply false

• Hilt uses Java 8 features. To enable Java 8 in your project, add the following to the app/build.gradle file:

    sourceCompatibility = JavaVersion.VERSION_1_8

Note: This DI article is just a nutshell for detail information go to the official page

https://developer.android.com/training/dependency-injection

https://developer.android.com/training/dependency-injection/hilt-android