Hilt: A Simple Guide to Dependency Injection

In Android development, managing dependencies efficiently and seamlessly is essential. However, using dependency injection helps organize the codebase and create a separation of concerns, and that’s where Hilt comes into play. Hilt is a robust dependency injection library built on Dagger’s framework. It simplifies the process and enhances code readability while reducing boilerplate.

Dependency Injection

To understand why this library is so useful, it’s important to understand the Dependency Injection (DI) concept. Essentially, DI is a design pattern that helps reduce dependency between different software modules. Instead of objects creating the dependencies they need to function, these dependent objects are “injected” into them.

Hilt is Google’s solution to handle DI in Android more efficiently. It uses Dagger for providing dependencies but simplifies its usage by being opinionated in its approach and automatically managing component lifecycles.

Getting Started

Before starting, ensure you have added the necessary Hilt dependencies to your Gradle. To start integrating Hilt into your project, first, annotate your Application class with @HiltAndroidApp.

@HiltAndroidApp
class MyApplication : Application() {}

This enables Hilt to generate the necessary components for DI. Next, you’ll want to set up the dependencies to inject. You do this by creating a Module. A Module is a class annotated with @Module that tells Hilt how to provide instances of certain types.

@Module
@InstallIn(ApplicationComponent::class)
object AppModule {
    @Singleton 
    @Provides
    fun provideDatabase(application: Application): AppDatabase = 
        Room.databaseBuilder(application, AppDatabase::class.java, "app_db").build()
}

This code makes a Room Database instance available to the whole application.

Injecting Dependencies

Once the dependencies are set up, we can now have them injected. To do this, annotate the constructor with @Inject.

class ExampleActivity : AppCompatActivity() {
    @Inject lateinit var exampleRepository: ExampleRepository

    // Rest of the code
}

Hilt handles the lifecycle and creates the necessary dependencies when the activity is created.

Remember to use the Hilt-defined classes (e.g., HiltActivity, HiltFragment) in place of the usual AppCompat classes or annotate your classes with the corresponding @AndroidEntryPoint annotations to allow Hilt to perform injection.

Hilt, thereby, enables smoother DI with a lowered learning curve. By taking care of the DI boilerplate under the hood and automatically managing components’ lifecycles, Hilt makes dependency management less of a hassle. In turn, that leaves you free to focus on core app development.