How to provide the Application / Application Context to Singleton dependencies in Dagger 2.11?

This is a question I have in my project: https://github.com/vestrel00/android-dagger-butterknife-mvp/issues/42. I currently have a working solution: https://github.com/vestrel00/android-dagger-butterknife-mvp/pull/43. However, I’m hoping that future versions of Dagger may make it simpler (not that it isn’t simple already).

Currently, Dagger 2.11 does not allow the Application instance to be implicitly provided using the same method used to provide Activity and Fragment instances;

abstract class AppModule {
    @Binds
    @Singleton
    abstract Application application(App app);
}

The above gives the following compile-time error:

error: [dagger.android.AndroidInjector.inject(T)] com.vestrel00.daggerbutterknifemvp.App cannot be provided without an @Inject constructor or from an @Provides-annotated method. This type supports members injection but cannot be implicitly provided.

The current solution (and what I consider a workaround) is to store the Application instance in a module so that it may be provided;

@Module
class ApplicationProviderModule {

    private final Application application;

    ApplicationProviderModule(Application application) {
        this.application = application;
    }

    @Provides
    @Singleton
    Application application() {
        return application;
    }
}


@Module(includes = {
        AndroidInjectionModule.class,
        ApplicationProviderModule.class
})
abstract class AppModule {
    ...
}

public class App extends Application implements HasActivityInjector {
    ...
    @Override
    public void onCreate() {
        super.onCreate();
        DaggerAppComponent.builder()
                .applicationProviderModule(new ApplicationProviderModule(this))
                .build()
                .inject(this);
    }
    ...
}

[vestrel00]

Thanks for that info! I sometimes choose readability over performance (of auto-generated code) given its pros and cons. I’ll play the devils advocate here and just update the comment to:

    @Binds
    @Singleton
    /*
     * Singleton annotation isn't necessary since Application instance is unique but is here for
     * convention. In general, providing Activity, Fragment, BroadcastReceiver, etc does not require
     * them to be scoped since they are the components being injected and their instance is unique.
     *
     * However, having a scope annotation makes the module easier to read. We wouldn't have to look
     * at what is being provided in order to see understand scope.
     */
    abstract Application application(App app);

Just my preference. Other people could totally disagree =)

[LeoDroidCoder]

For me, this representation looks better:

App : DaggerApplication() {

    override fun applicationInjector(): AndroidInjector<out DaggerApplication> {
        return DaggerAppComponent.builder()
            .create(this)
    }
}

@Singleton
@Component(
    modules = arrayOf(
        AppModule::class,
        //...
    )
)

interface AppComponent : AndroidInjector<App> {

    @Component.Builder
    abstract class Builder : AndroidInjector.Builder<App>() {
    }
}

@Module(includes = arrayOf(AndroidSupportInjectionModule::class, ...))
abstract class AppModule {

    @Singleton
    @Binds
    @AppContext
    abstract fun provideContext(app: App): Context
}

@Qualifier
@kotlin.annotation.Retention(AnnotationRetention.RUNTIME)
annotation class AppContext

and finally you can use it in a way: @AppContext context : Context