Setup your android project for Dagger 2.33+

Dagger Dependency Injection

This is how to setup your project with the latest and greatest to date Dagger 2.33+ (written in April 2021)

For now, we will use a single component and module, which is the AppComponent but we shall add others in next blogs. Lets get going!

New Project

We will create a new Android Project in Android Studio.

Adding Dagger Dependency

in app/build.gradle we add this into the dependencies

def dagger_version = "2.33"

// region Dagger
implementation "com.google.dagger:dagger:$dagger_version"
implementation "com.google.dagger:dagger-android:$dagger_version"
implementation "com.google.dagger:dagger-android-support:$dagger_version"
kapt "com.google.dagger:dagger-android-processor:$dagger_version"
kapt "com.google.dagger:dagger-compiler:$dagger_version"
// endregion

And then we need to enable the kapt extenstion, using the latest gradle

Adding the app component

First we create a folder named di and inside that we create the AppComponent.kt

// Scope annotation that the AppComponent uses
// Classes annotated with @Singleton will have a unique instance in this Component
@Singleton
// Definition of a Dagger component that adds info from the different modules to the graph
@Component(
modules = [
AppModule::class
]
)
interface AppComponent : AndroidInjector<MyApplication> {

@Component.Factory
interface Factory {
// With @BindsInstance, the Context passed in will be available in the graph
fun create(@BindsInstance context: Context): AppComponent
}
}

Then we will create the missing AppModule in the same di folder like


@Module(
subcomponents = [
// We add Sub Component Here
]
)
open class AppModule

Creating the App container

This is where we start using the component. to do that we can create a new class named MyApplication like

open class MyApplication : Application() {
val appComponent: AppComponent by lazy {
initializeComponent()
}

open fun initializeComponent(): AppComponent {
return DaggerAppComponent
.factory()
.create(applicationContext)
}
}

Now, we have an unresolved reference, but that’s ok because now we are going to build the app. you can click the hammer icon at the top, I will be using the shortcut here Ctrl+F9.

After a few seconds the project is made and now you can auto-import the DaggerAppComponent inside the app component.

finally we add the application class to our manifest

<!-- Manifest -->
<application
android:name=".MyApplication"

Start Injecting Stuff

For me, I will create a new Presenter Class, nothing fancy just a basic service, and I will inject this service inside the MainActivity class

Here we have the presenter class

class MainPresenter @Inject constructor() {
fun isOdd(num: Int): Boolean {
return num % 2 == 0;
}
}

Next we modify the AppComponent to add the inject method, in which we shall inject the MainActivity.

// ... AppComponent.kt

fun inject(activity: MainActivity)

And then we can start injecting it inside the MainActivity using the following

private const val TAG = "MainActivity"

class MainActivity : AppCompatActivity() {

@Inject
lateinit var mainPresenter: MainPresenter

override fun onCreate(savedInstanceState: Bundle?) {
(application as MyApplication).appComponent.inject(this)
super.onCreate(savedInstanceState)

Log.d(TAG, "onCreate: ${mainPresenter.isOdd(2)}")

setContentView(R.layout.activity_main)
}
}

Now, to check things out, we can start the app. and everything should be working!

Next, We start adding components like AuthComponent, MainComponent, SettingsComponent. until then, have a great time!

Software Developer at Yes-Soft.de