Dependency Injection (Hilt/Dagger)

# CHAPTER 28

Dependency Injection (Hilt/Dagger) #

1. Introduction #

2. Learning Objectives #

• Understand the core philosophy of "Inversion of Control" and Dependency Injection.

• Configure Hilt Gradle dependencies and plugins.

• Initialize Hilt at the Application level via @HiltAndroidApp.

• Annotate UI controllers (Activities/Fragments) with @AndroidEntryPoint.

• Construct Hilt Modules and leverage @Provides to instruct Hilt on object creation.

• Seamlessly inject dependencies into ViewModels utilizing @HiltViewModel.

3. What is Dependency Injection? #

*Analogy:* You are a Chef. You shouldn't have to build your own oven before cooking. The restaurant (Hilt) should "inject" an oven into your kitchen.

4. Step 1: Hilt Gradle Setup #

plugins {
    id("com.google.dagger.hilt.android") version "2.50" apply false
}

App-level build.gradle.kts (Module :app):

plugins {
    id("kotlin-kapt") // Required for Hilt code generation!
    id("com.google.dagger.hilt.android")
}

dependencies {
    implementation("com.google.dagger:hilt-android:2.50")
    kapt("com.google.dagger:hilt-android-compiler:2.50")
}

5. Step 2: The Application Class #

1. 1. Create a new Kotlin class named MyApplication extending Application.

1. 2. Annotate it with @HiltAndroidApp.

1. 3. CRITICAL: Register this class in the AndroidManifest.xml inside the <application> tag using android:name=".MyApplication".

import android.app.Application
import dagger.hilt.android.HiltAndroidApp

@HiltAndroidApp // Triggers Hilt's code generation, including a base class for your app
class MyApplication : Application() {
    override fun onCreate() {
        super.onCreate()
        // App initialization code
    }
}

6. Step 3: Hilt Modules (@Provides) #

import android.content.Context
import androidx.room.Room
import dagger.Module
import dagger.Provides
import dagger.hilt.InstallIn
import dagger.hilt.android.qualifiers.ApplicationContext
import dagger.hilt.components.SingletonComponent
import javax.inject.Singleton

@Module
// InstallIn(SingletonComponent) tells Hilt: "These objects should live forever as Singletons"
@InstallIn(SingletonComponent::class) 
object AppModule {

    // Teach Hilt how to build the Room Database
    @Provides
    @Singleton // Ensure only ONE instance is ever created
    fun provideUserDatabase(@ApplicationContext context: Context): UserDatabase {
        return Room.databaseBuilder(
            context,
            UserDatabase::class.java,
            "user_database"
        ).build()
    }

    // Teach Hilt how to pull the DAO out of the Database
    @Provides
    @Singleton
    fun provideUserDao(database: UserDatabase): UserDao {
        return database.userDao()
    }
    
    // (You would add another @Provides function here to build Retrofit!)
}

7. Step 4: Injecting the Repository #

import javax.inject.Inject

// Hilt looks at the constructor, sees it needs a UserDao, finds the @Provides function we just wrote,
// builds the Dao, and automatically injects it right here! Magic!
class UserRepository @Inject constructor(
    private val userDao: UserDao
) {
    fun getAllUsers() = userDao.getAllUsers()
}

8. Step 5: Injecting the ViewModel #

import androidx.lifecycle.ViewModel
import dagger.hilt.android.lifecycle.HiltViewModel
import javax.inject.Inject

@HiltViewModel
// Hilt automatically injects the UserRepository into the ViewModel!
class UserViewModel @Inject constructor(
    private val repository: UserRepository
) : ViewModel() {

    val users = repository.getAllUsers()
}

9. Step 6: Injecting the Activity (@AndroidEntryPoint) #

import android.os.Bundle
import androidx.activity.viewModels
import androidx.appcompat.app.AppCompatActivity
import dagger.hilt.android.AndroidEntryPoint

@AndroidEntryPoint // Tells Hilt to inject dependencies into this Activity
class MainActivity : AppCompatActivity() {

    // Hilt handles the entire instantiation process! No ViewModelProvider factories needed!
    private val viewModel: UserViewModel by viewModels()

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        // The ViewModel is fully wired with the Repository, Dao, and Database automatically!
        viewModel.users.observe(this) { userList ->
            println("We have ${userList.size} users!")
        }
    }
}

10. Common Mistakes #

• Forgetting the Manifest: You can write perfect Hilt code, but if you forget to add android:name=".MyApplication" to the AndroidManifest.xml, Hilt will simply never start, and your app will crash instantly with injection errors.

• Missing @AndroidEntryPoint on Fragments: If an Activity uses Hilt, but a Fragment inside it requests a ViewModel without having @AndroidEntryPoint above its class declaration, the app will crash.

11. Best Practices #

• Scoping Constraints: Do not arbitrarily add @Singleton to every @Provides function. A Database should be a Singleton. But a simple temporary helper class should not be a Singleton, as it will persist in RAM forever and cause memory bloat. Let Hilt create new instances of lightweight objects.

12. Exercises #

1. 1. Setup Hilt dependencies in Gradle and create the MyApplication class. Don't forget the Manifest.

1. 2. Create an AppModule and write a @Provides function that returns a String representing a base API URL. Inject that string into a dummy Repository.

13. Coding Challenges #

14. MCQ Quiz with Answers #

15. Interview Questions #

• Q: Explain the mechanics of "Inversion of Control". How does passing an Interface into a constructor via DI, rather than instantiating a concrete class directly, radically improve the testability of a system?

• Q: Detail the lifecycle hierarchies utilized by Hilt Components. Why must a Room Database be installed within the SingletonComponent rather than the ActivityComponent?

• Q: Contrast traditional Dagger 2 with modern Dagger Hilt. What specific Android-centric boilerplate configuration steps did Hilt eliminate to become the Jetpack standard?

16. Summary #

17. Next Chapter Recommendation #