Dependency injection is a fundamental technique in modern Android app development. In this article, we'll explore how to implement DI using Hilt, Google's official solution.
What Is Dependency Injection?
Dependency injection is a design pattern that lets you build loosely coupled components, making code easier to test and maintain. Hilt is a library that simplifies implementing DI on Android.
Basic Setup
1. Dependencies
plugins {
id 'com.android.application'
id 'kotlin-android'
id 'kotlin-kapt'
id 'dagger.hilt.android.plugin'
}
dependencies {
implementation "com.google.dagger:hilt-android:2.44"
kapt "com.google.dagger:hilt-android-compiler:2.44"
}
2. Application
@HiltAndroidApp
class MyApplication : Application()
Main Components
1. Modules
@Module
@InstallIn(SingletonComponent::class)
object AppModule {
@Provides
@Singleton
fun provideUserRepository(
api: UserApi,
db: UserDatabase
): UserRepository {
return UserRepositoryImpl(api, db)
}
@Provides
@Singleton
fun provideUserApi(): UserApi {
return Retrofit.Builder()
.baseUrl("https://api.example.com/")
.build()
.create(UserApi::class.java)
}
}
2. Injecting into Activities and Fragments
@AndroidEntryPoint
class MainActivity : AppCompatActivity() {
@Inject
lateinit var userRepository: UserRepository
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
// userRepository is already injected
}
}
Advanced Patterns
1. Injecting into ViewModels
@HiltViewModel
class UserViewModel @Inject constructor(
private val userRepository: UserRepository
) : ViewModel() {
// ...
}
2. Custom Modules
@Module
@InstallIn(ActivityComponent::class)
object UserModule {
@Provides
fun provideUserManager(
@ApplicationContext context: Context
): UserManager {
return UserManager(context)
}
}
Testing
1. Test Setup
@HiltAndroidTest
class UserRepositoryTest {
@get:Rule
val hiltRule = HiltAndroidRule(this)
@Inject
lateinit var userRepository: UserRepository
@Before
fun setup() {
hiltRule.inject()
}
}
2. Test Modules
@Module
@TestInstallIn(
components = [SingletonComponent::class],
replaces = [AppModule::class]
)
object TestAppModule {
@Provides
@Singleton
fun provideUserRepository(): UserRepository {
return FakeUserRepository()
}
}
Best Practices
Module structure
- Split modules by feature
- Use appropriate scopes
- Keep modules small and focused
Dependency injection
- Inject at the highest possible level
- Use constructor injection whenever possible
- Avoid dependency injection in UI classes
Testing
- Create dedicated test modules
- Use fakes or mocks as needed
- Keep tests independent
Usage Examples
1. Injecting into a Service
@AndroidEntryPoint
class MyService : Service() {
@Inject
lateinit var dataManager: DataManager
override fun onBind(intent: Intent?): IBinder? = null
}
2. Injecting into a WorkManager Worker
@HiltWorker
class MyWorker @AssistedInject constructor(
@Assisted context: Context,
@Assisted workerParams: WorkerParameters,
private val repository: Repository
) : CoroutineWorker(context, workerParams)
Benefits of Hilt
- Android integration
- Minimal setup
- Testing support
- ViewModel integration
- Official documentation
Conclusion
Hilt provides a robust, easy-to-use solution for dependency injection on Android. Its integration with the Android ecosystem and its testing support make it the preferred choice for modern projects.