Dagger 2 Inject Context in Kotlin Object

Question

I am trying to inject Context using Dagger 2.

AppComponent.kt:

@Singleton
@Component(
    modules = [
        AppModule::class
    ]
)
interface AppComponent {
    fun context(): Context
}

AppModule.kt:

@Module
class AppModule(private val application: Application) {

    @Provides
    @Singleton
    fun providesApplicationContext(): Context = application
}

MainApp.kt:

class MainApp : Application() {
    lateinit var appComponent: AppComponent

    override fun onCreate() {
        super.onCreate()
        appComponent = initDagger()
    }

    private fun initDagger() = DaggerAppComponent.builder()
        .appModule(AppModule(this))
        .build()
}

Manager.kt: (Class where I want to inject Context)

object Manager {

    @Inject
    lateinit var context: Context
}

However, I am getting following error:

error: Dagger does not support injection into static fields
    public static android.content.Context context;
                                          ^

Is this because I am using an object (Singleton)? If you have any doubts related to question, please comment below. Thank you.

Your module seems correct. I assume you can't inject a field in an object (which will be created in compile time). — Maryam Mirzaie, Dec 28 '19 at 10:26
I used the pattern above in order to get a proof-of-concept working to inject a `FirebaseAnalytics` helper `@Singleton` class into activities/fragments requiring `Context` as a parameter/argument for the helper class. From the above code, I refactored the `object Manager` to `@Singleton class Manager @Inject constructor(val context: Context){ ... }`. A full code sample may be found in the [Coinverse open app](https://github.com/AdamSHurwitz/Coinverse). The code is on track to be merged from the Dagger branch into master within the next week. — AdamHurwitz, Feb 20 '20 at 01:55

score 2 · Accepted Answer · answered Dec 29 '19 at 00:57

Is this because I am using an object (Singleton)?

Yes, objects' properties are Java's static fields under the hood. Your Manager class would decompile to something similar to:

public final class Manager {
    @Inject
    @NotNull
    public static Context context;

    public static final Manager INSTANCE;

    static {
        INSTANCE = new Manager();
    }

    private Manager() {
    }

    @NotNull
    public final Context getContext() {
        return context;
    }

    public final setContext(Context var1) {
        context = var1;
    }
}

and Dagger 2 simply does not support injection into static fields. However, even if Dagger let you do it, the dependency wouldn't be satisfied. That's because Dagger won't be able to inject into an object unless is explicitly told to do so (like you do when injecting for example into activities) or creates the object by itself. Obviously the latter doesn't apply when it comes to Kotlin's objects. In order to ask Dagger to inject the dependency you would have to somehow provide a MainApp instance:

init {
    mainApp.appComponent.inject(this)
}

which doesn't make much sense since you'd like to inject it (as a Context) in the first place.

Therefore you have to either satisfy the dependency manually and don't bother with Dagger in this one or leave the object idea behind, use just a standard class and let Dagger handle its scope:

@Singleton
class Manager @Inject constructor(private val context: Context) {

}

The only drawback is that you would have to inject a Manager instance (created by Dagger) into every class that needs to use it instead of calling its methods statically.

score 1 · Answer 2 · answered Dec 29 '19 at 02:01

It's because you are not injecting your Manager class in your AppModule.kt and also you need to pass the context.

Just like this:

@Module
class AppModule(private val application: Application) {

    @Singleton
    @Provides
    fun providesManager(): Manager {
        return Manager(application.applicationContext)
    }
}

Obviously you need to change your Manager class to:

@Singleton
class Manager @Inject constructor(context: Context) {
    //here you can use your context
}

And it should work

Additional:

You can remove this line in your AppComponent.kt:

fun context(): Context

Because it is not necessary and unused

the only disadvantage its that you will need to inject your Manager class in every activity/fragment you want to use it

Just like @jsamol said

score 0 · Answer 3 · answered Dec 29 '19 at 02:56

https://dagger.dev/dagger-1-migration.html

Dagger 2 does not support static injection

You may try something like

object Test {
    var context: Context = MainApp.getComponent().context()
}

Do not place Android context classes in static fields as it's a memory leak.

So, You may also try creating a Wrapper around the context and provide dependencies as others suggested.

Dagger 2 Inject Context in Kotlin Object

3 Answers3

Linked