Hilt Dependency Injection

The Problem Without DI

Without DI, classes create their own dependencies inside constructors or methods. This tightly couples code — UserViewModel directly instantiates RetrofitUserRepository, which directly creates Retrofit.Builder(). Testing becomes impossible because you can't swap in a fake repository.

What DI Solves

DI inverts this: the class declares what it needs, and an external container (the DI framework) provides it. UserViewModel declares class UserViewModel(private val repository: UserRepository). At runtime, Hilt creates the real RetrofitUserRepository. In tests, you pass a fake.

Hilt vs Manual DI vs Dagger

• Manual DI: You write a ServiceLocator or pass dependencies through constructors. Works for small projects but becomes boilerplate-heavy.
• Dagger: Compile-time DI framework for Android. Powerful but verbose — requires @Component, @Module, @Subcomponent with lots of ceremony.
• Hilt: Built on top of Dagger. Reduces boilerplate with Android-specific annotations (@AndroidEntryPoint, @HiltViewModel). Google's recommended DI solution for Android.

Setup

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

dependencies {
    implementation("com.google.dagger:hilt-android:2.51")
    ksp("com.google.dagger:hilt-compiler:2.51")
    implementation("androidx.hilt:hilt-navigation-compose:1.2.0")
}

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

// Activity
@AndroidEntryPoint
class MainActivity : ComponentActivity() {
    // Hilt injects dependencies here
}

Hilt Modules

Modules tell Hilt how to create dependencies. There are two main annotations:

• @Provides: When you need to call a constructor or builder yourself (e.g., Retrofit, Room).
• @Binds: When you have an interface and a concrete implementation — Hilt figures out the rest.

@Module
@InstallIn(SingletonComponent::class)
object NetworkModule {

    @Provides
    @Singleton
    fun provideRetrofit(): Retrofit {
        return Retrofit.Builder()
            .baseUrl("https://api.example.com")
            .addConverterFactory(GsonConverterFactory.create())
            .build()
    }

    @Provides
    @Singleton
    fun provideUserApi(retrofit: Retrofit): UserApi {
        return retrofit.create(UserApi::class.java)
    }
}

@Module
@InstallIn(SingletonComponent::class)
abstract class RepositoryModule {

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

Scopes

Scopes control how long a dependency instance lives:

// Created once for the entire app lifetime
@Singleton
class SessionManager @Inject constructor(
    private val tokenStorage: TokenStorage
)

// Created once per ViewModel
@ViewModelScoped
class CartUseCase @Inject constructor(
    private val cartRepository: CartRepository
)

// Created fresh every time it's injected
class DateFormatter @Inject constructor()

@Inject Constructor

When you own the class, use @Inject constructor directly — no module needed:

@ViewModelScoped
class ProductViewModel @Inject constructor(
    private val getProductUseCase: GetProductUseCase,
    private val addToCartUseCase: AddToCartUseCase
) : ViewModel()

Hilt sees the @Inject constructor, knows how to create all parameters (because they're also provided by Hilt), and creates the ViewModel automatically.

@AndroidEntryPoint

Annotate Activities, Fragments, Services, and BroadcastReceivers with @AndroidEntryPoint to enable field injection:

@AndroidEntryPoint
class ProductFragment : Fragment() {
    // Hilt injects this before onCreate
    @Inject lateinit var analyticsTracker: AnalyticsTracker

    // ViewModel injected via hiltViewModel()
    private val viewModel: ProductViewModel by viewModels()

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)
        analyticsTracker.trackScreen("product_detail")
    }
}

ViewModel Injection

Hilt provides a dedicated annotation for ViewModels:

@HiltViewModel
class ProductViewModel @Inject constructor(
    private val getProductUseCase: GetProductUseCase
) : ViewModel() {
    private val _state = MutableStateFlow(ProductUiState())
    val state: StateFlow<ProductUiState> = _state.asStateFlow()

    fun loadProduct(id: String) {
        viewModelScope.launch {
            _state.value = ProductUiState(isLoading = true)
            val product = getProductUseCase(id)
            _state.value = ProductUiState(product = product)
        }
    }
}

In Compose:

@Composable
fun ProductScreen(viewModel: ProductViewModel = hiltViewModel()) {
    val state by viewModel.state.collectAsStateWithLifecycle()
    // render...
}

Testing with Hilt

Swap real implementations for fakes in tests:

@Module
@TestInstallIn(
    components = [SingletonComponent::class],
    replaces = [RepositoryModule::class]
)
abstract class FakeRepositoryModule {
    @Binds
    abstract fun bindUserRepository(
        fake: FakeUserRepository
    ): UserRepository
}

Hilt swaps the module automatically in test builds — no code changes needed in the ViewModel or Activity.