What made me do this article?
I started programming Android applications few months ago. I went through fundamental and more advanced guides. None of them mentioned dependency injection. Without it I struggled to make proper unit tests. I decided that I have to make it work.
I looked around and found Dagger 2. The project developed by Google that provides dependency injection for Android applications. Sadly, I had a hard time making it work with Kotlin.
I have read many articles, but they had only scraps of necessary information. Combining them together I made it work. This post is a summary of my small research. It won’t be about Dagger 2 basics. If you want to know more, read official user’s guide. Those are articles that inspired me:
- Setup Dagger 2.11 on Kotlin Project
- How to use Android Injector for Activity and Fragment objects through New Dagger 2 (with Kotlin)
- New Android Injector with Dagger 2 — part 3
- Dependency Injection on Android with Dagger 2 (and Kotlin) — Part 1
How to setup Dagger 2 with Kotlin?
First of all, add dependencies to app/build.gradle
and enable kapt
.
...
apply plugin: 'kotlin-kapt'
android {
...
}
dependencies {
...
implementation 'com.google.dagger:dagger-android:2.x'
implementation 'com.google.dagger:dagger-android-support:2.x'
kapt 'com.google.dagger:dagger-android-processor:2.x'
kapt 'com.google.dagger:dagger-compiler:2.x'
}
Provide modules to inject
Organize your code in modules that provide dependencies. Activities and fragments are dependencies too. They need to be in special abstract modules that use @ContributesAndroidInjector
annotation on methods.
@Module
abstract class ActivityProvider {
@ContributesAndroidInjector
abstract fun mainActivity(): MainActivity
}
For other objects write modules with methods annotated with @Provides
.
@Module
class CoffeeModule {
@Provides
@Singleton
fun coffeeService() = CoffeeService()
}
class CoffeeService {
fun prepareCoffee() = "Here! Espresso for you"
fun fetchCoffee() = "espresso"
}
OrderService
depends on CoffeeService
. You don’t need to use @Inject
annotation to do this with Dagger.
@Module
class OrderModule {
@Provides
@Singleton
fun orderService(coffeeService: CoffeeService)
= OrderService(coffeeService)
}
class OrderService(private val coffeeService: CoffeeService) {
fun askForOrder() = "Would you like some ${coffeeService.fetchCoffee()}?"
}
Prepare your Application
Next add AppComponent
that extends AndroidInjector<DaggerApplication>
. It is vital that one of the included modules is AndroidSupportInjectionModule
.
@Singleton
@Component(modules = [AndroidSupportInjectionModule::class, ActivityProvider::class, CoffeeModule::class, OrderModule::class])
interface AppComponent : AndroidInjector<DaggerApplication>
Add your own DaggerApplication
implementation. This will be the starting point of your Android application.
class InjectionExampleApplication : DaggerApplication() {
override fun applicationInjector(): AndroidInjector<out DaggerApplication> {
val appComponent = DaggerAppComponent.builder()
.build()
appComponent.inject(this)
return appComponent
}
}
Don’t forget to add attribute android:name
in AndroidManifest.xml
.
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="com.github.wpanas.injectionexample">
<application
android:name=".InjectionExampleApplication"
...
>
...
</application>
</manifest>
From now on, dependencies registered by modules in AppComponent
will be available for injection.
Inject dependencies
The last step is injecting those dependencies into your activities. Change parent class of your MainActivity
from AppCompatActivity
to DaggerAppCompatActivity
. Then add your dependencies as lateinit var
properties with @Inject
annotation.
class MainActivity : DaggerAppCompatActivity() {
@Inject
lateinit var coffeeService: CoffeeService
@Inject
lateinit var orderService: OrderService
...
}
The same you can do with all activities and fragments. Add prefix Dagger-
to theirs parents class names. This will ensure that dependencies are injected. Don’t forget to add those activities and fragments to module like in ActivityProvider
.
Summary
Those simple steps enables you to make Dagger 2 work with Kotlin. All this code is captured in this repository. For more complex example you can also check out this project of mine.
Top comments (0)