Dependency Injection with Hilt: The Complete Android Guide

// build.gradle.kts (project level)
plugins {
    id("com.google.dagger.hilt.android") version "2.60.1" apply false
    id("com.google.devtools.ksp") version "2.3.12" apply false
}

// build.gradle.kts (app level)
plugins {
    id("com.google.devtools.ksp")
    id("com.google.dagger.hilt.android")
}

dependencies {
    implementation("com.google.dagger:hilt-android:2.60.1")
    ksp("com.google.dagger:hilt-android-compiler:2.60.1")

    // hiltViewModel() for Compose, without the navigation dependency
    implementation("androidx.hilt:hilt-lifecycle-viewmodel-compose:1.4.0")
}

// Application class
@HiltAndroidApp
class MyApplication : Application()

// The one entry point a Compose app needs
@AndroidEntryPoint
class MainActivity : ComponentActivity()

// Binding interfaces to implementations
@Module
@InstallIn(SingletonComponent::class)
abstract class RepositoryModule {

    @Binds
    @Singleton
    abstract fun bindUserRepository(
        impl: UserRepositoryImpl
    ): UserRepository
}

// Providing objects you cannot annotate
@Module
@InstallIn(SingletonComponent::class)
object NetworkModule {

    @Provides
    @Singleton
    fun provideOkHttpClient(): OkHttpClient =
        OkHttpClient.Builder()
            .connectTimeout(30, TimeUnit.SECONDS)
            .readTimeout(30, TimeUnit.SECONDS)
            .build()

    @Provides
    @Singleton
    fun provideRetrofit(client: OkHttpClient): Retrofit =
        Retrofit.Builder()
            .baseUrl("https://api.example.com/")
            .client(client)
            .addConverterFactory(
                Json.asConverterFactory(
                    "application/json".toMediaType()
                )
            )
            .build()

    @Provides
    @Singleton
    fun provideApiService(retrofit: Retrofit): ApiService =
        retrofit.create(ApiService::class.java)
}

// Unscoped: a new instance each time it is requested.
// It holds no state, so it needs no scope.
class GetUserProfileUseCase @Inject constructor(
    private val userRepo: UserRepository,
    private val settingsRepo: SettingsRepository
) {
    suspend operator fun invoke(userId: String): UserProfile {
        val user = userRepo.getUser(userId)
        val settings = settingsRepo.getUserSettings(userId)
        return UserProfile(user, settings)
    }
}

@HiltViewModel
class ProfileViewModel @Inject constructor(
    private val getUserProfile: GetUserProfileUseCase,
    savedStateHandle: SavedStateHandle
) : ViewModel() {

    private val userId: String = checkNotNull(savedStateHandle["userId"])

    val profile: StateFlow<UserProfile?> = flow {
        emit(getUserProfile(userId))
    }.stateIn(viewModelScope, SharingStarted.Lazily, null)
}

// Define qualifiers
@Qualifier
@Retention(AnnotationRetention.BINARY)
annotation class IoDispatcher

@Qualifier
@Retention(AnnotationRetention.BINARY)
annotation class DefaultDispatcher

// Provide qualified instances
@Module
@InstallIn(SingletonComponent::class)
object DispatcherModule {

    @IoDispatcher
    @Provides
    fun provideIoDispatcher(): CoroutineDispatcher = Dispatchers.IO

    @DefaultDispatcher
    @Provides
    fun provideDefaultDispatcher(): CoroutineDispatcher = Dispatchers.Default
}

// Ask for the one you need
class UserRepositoryImpl @Inject constructor(
    private val api: ApiService,
    private val dao: UserDao,
    @IoDispatcher private val ioDispatcher: CoroutineDispatcher
) : UserRepository {

    override suspend fun getUser(id: String): User =
        withContext(ioDispatcher) {
            dao.getUser(id) ?: api.fetchUser(id).also {
                dao.insertUser(it)
            }
        }
}

// Unit test: no Hilt, just the constructor
@OptIn(ExperimentalCoroutinesApi::class)
class ProfileViewModelTest {

    @Before
    fun setup() {
        Dispatchers.setMain(UnconfinedTestDispatcher())
    }

    @After
    fun tearDown() {
        Dispatchers.resetMain()
    }

    @Test
    fun `profile loads successfully`() = runTest {
        val userRepo = FakeUserRepository().apply {
            addUser(User("1", "Jane"))
        }
        val settingsRepo = FakeSettingsRepository().apply {
            addSettings(Settings("1", darkMode = true))
        }

        val viewModel = ProfileViewModel(
            getUserProfile = GetUserProfileUseCase(userRepo, settingsRepo),
            savedStateHandle = SavedStateHandle(mapOf("userId" to "1"))
        )

        // The first value is the initial null. Wait for the real one.
        val profile = viewModel.profile.first { it != null }
        assertEquals("Jane", profile?.user?.name)
    }
}

// Instrumented test: replace one module for this class
@UninstallModules(NetworkModule::class)
@HiltAndroidTest
class ProfileScreenTest {

    @get:Rule
    val hiltRule = HiltAndroidRule(this)

    @BindValue
    @JvmField
    val api: ApiService = FakeApiService()

    @Before
    fun setup() {
        hiltRule.inject()
    }
}