Dependency injection with Hilt in depth in Android Kotlin

Introduction

Dependency injection helps you manage and provide objects your app needs without creating them manually. Hilt makes this easy and organized in Android apps.

When you want to share a single instance of a class across your app.

When you want to make your code easier to test by providing mock dependencies.

When you want to reduce boilerplate code for creating and passing objects.

When you want to manage complex object graphs automatically.

When you want to improve app modularity and separation of concerns.

Syntax

Android Kotlin

1. Add Hilt dependencies in build.gradle
2. Annotate Application class with @HiltAndroidApp
3. Use @AndroidEntryPoint on Activities/Fragments
4. Create @Module classes with @Provides or @Binds
5. Inject dependencies with @Inject constructor or @Inject fields

@HiltAndroidApp triggers Hilt code generation and should be on your Application class.

@AndroidEntryPoint allows Hilt to inject dependencies into Android components.

Examples

This sets up Hilt in your app by generating necessary components.

Android Kotlin

@HiltAndroidApp
class MyApp : Application()

Hilt injects UserRepository into MainActivity automatically.

Android Kotlin

@AndroidEntryPoint
class MainActivity : AppCompatActivity() {
    @Inject lateinit var repository: UserRepository

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        // repository is ready to use here
    }
}

This module tells Hilt how to create UserRepository using ApiService.

Android Kotlin

@Module
@InstallIn(SingletonComponent::class)
object AppModule {
    @Provides
    fun provideUserRepository(api: ApiService): UserRepository {
        return UserRepositoryImpl(api)
    }
}

Constructor injection lets Hilt provide ApiService automatically.

Android Kotlin

class UserRepository @Inject constructor(private val api: ApiService) {
    // Use api to get data
}

Sample App

This example shows a full setup: Hilt initializes in Application, provides ApiService, injects UserRepository into MainActivity, and prints data.

Android Kotlin

package com.example.hiltdemo

import android.app.Application
import android.os.Bundle
import androidx.activity.ComponentActivity
import dagger.Module
import dagger.Provides
import dagger.hilt.InstallIn
import dagger.hilt.android.HiltAndroidApp
import dagger.hilt.android.AndroidEntryPoint
import dagger.hilt.components.SingletonComponent
import javax.inject.Inject
import javax.inject.Singleton

// 1. Setup Hilt in Application
@HiltAndroidApp
class MyApp : Application()

// 2. Define a simple service
class ApiService {
    fun fetchData() = "Data from ApiService"
}

// 3. Create a repository that depends on ApiService
class UserRepository @Inject constructor(private val apiService: ApiService) {
    fun getUserData() = apiService.fetchData()
}

// 4. Provide ApiService in a module
@Module
@InstallIn(SingletonComponent::class)
object AppModule {
    @Provides
    @Singleton
    fun provideApiService(): ApiService = ApiService()
}

// 5. Inject UserRepository into Activity
@AndroidEntryPoint
class MainActivity : ComponentActivity() {
    @Inject lateinit var userRepository: UserRepository

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        // Use the injected repository
        println(userRepository.getUserData())
    }
}

Important Notes

Always annotate your Application class with @HiltAndroidApp to start Hilt.

Use @Singleton scope to share one instance across the app.

Use @Inject on constructors for automatic dependency provision.

Summary

Hilt simplifies dependency injection in Android by generating code for you.

Use @Module and @Provides to tell Hilt how to create dependencies.

Inject dependencies with @Inject in constructors or fields for easy access.