Kotlin Dependency Injection Like a Pro: Mastering Hilt in Android

You’ve built Android apps without dependency injection (DI), but now you’re ready to level up. Code that’s tightly coupled? No thanks. Manual instance management? Too messy. Let’s dive into Kotlin-powered DI with Hilt—the clean, scalable way to inject dependencies like a pro.

Why DI? (Spoiler: It’s Not Just Hype)

Imagine building a car by hand-wiring every part. That’s coding without DI. With DI:

• Testability: Swap real databases for mocks in seconds.
• Maintainability: Change one component without breaking ten others.
• Readability: No more “Where did this object come from?!”

Step 1: Setup Hilt (Google’s Official DI Tool)

Add Hilt to your build.gradle:

// Project-level build.gradle  
dependencies {  
    classpath "com.google.dagger:hilt-android-gradle-plugin:2.48"  
}  

// App-level build.gradle  
plugins {  
    id("kotlin-kapt")  
    id("com.google.dagger.hilt.android")  
}  

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

Step 2: Define Modules (Your Dependency “Factories”)

Create a module to tell Hilt how to provide objects:

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

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

    // Provide a Repository (depends on Retrofit)  
    @Provides  
    fun provideRepo(retrofit: Retrofit): Repository {  
        return RepositoryImpl(retrofit)  
    }  
}  

Step 3: Inject Dependencies into Classes

Use @Inject to request dependencies in your Activities, Fragments, or ViewModels:

@AndroidEntryPoint  
class MainActivity : AppCompatActivity() {  

    @Inject lateinit var repo: Repository  // Injected by Hilt!  

    override fun onCreate(savedInstanceState: Bundle?) {  
        super.onCreate(savedInstanceState)  
        repo.fetchData() // No manual setup!  
    }  
}  

Pro Tips for Hilt Ninjas

1. Scoped Instances:
   Use @ActivityScoped or @ViewModelScoped to control object lifetimes.
2. Binds vs. Provides:
   • @Provides: For objects you don’t own (e.g., Retrofit).
   • @Binds: For interfaces (e.g., RepositoryImpl → Repository).
3. Testing Made Easy:
   Override modules in tests:

@Module  
@TestInstallIn(components = [SingletonComponent::class], replaces = [AppModule::class])  
object FakeRepoModule {  
    @Provides  
    fun provideFakeRepo(): Repository = FakeRepository()  
}  

Common Pitfalls (And How to Dodge Them)

• Circular Dependencies: Hilt will yell at you. Simplify your object graph.
• Missing @AndroidEntryPoint: Forgot to annotate your Activity/Fragment? Injection fails.
• Over-Scoping: Don’t make everything a singleton—leak risk!

Why Not Koin?

Koin is great for small projects, but Hilt:

• Generates code at compile time (catches errors early).
• Integrates seamlessly with Jetpack (ViewModel, WorkManager).
• Backed by Google’s long-term support.

Your Turn:
Try refactoring a tight-coupled class with Hilt this week.
Stuck? Comment below—let’s debug together!

#AndroidDev #Kotlin #Hilt #DI #CleanCode