Dagger 2 injecting Android Application Context

Question

I am using Dagger 2 and have it working however I now need access to the Android Application Context.

Its not clear to me how to inject and get access to the context. I have tried to do this as follows:

@Module
public class MainActivityModule {    
    private final Context context;
    
    MainActivityModule(Context context) {
        this.context = context;
    }

    @Provides @Singleton
    Context provideContext() {
        return context;
    }
}

However this results in the following exception:

java.lang.RuntimeException: Unable to create application : java.lang.IllegalStateException: mainActivityModule must be set

If I inspect the Dagger generated code this exception is raised here:

public Graph build() {  
    if (mainActivityModule == null) {
        throw new IllegalStateException("mainActivityModule must be set");
    }
    return new DaggerGraph(this);
}

I am not sure if this is the correct way to get Context injected - any help will be greatly appreciated.

I am not sure if injecting Context of Application makes sense. You can extend Application class and create static instance of the Application. You can name it e.g. `BaseApplication`. After that, you can create `get()` method inside your extended Application class, which will return that instance and will be Application Context at the same time. Then, you can use the following construction to reach Application Context from any place in your project: `BaseApplication.get()`. You should use it carefully and only when it's necessary. — Piotr Wittchen, Jun 07 '15 at 13:05

EpicPandaForce · Answer 1 · 2016-02-19T15:37:57.920

34

@Module
public class MainActivityModule {    
    private final Context context;

    public MainActivityModule (Context context) {
        this.context = context;
    }

    @Provides //scope is not necessary for parameters stored within the module
    public Context context() {
        return context;
    }
}

@Component(modules={MainActivityModule.class})
@Singleton
public interface MainActivityComponent {
    Context context();

    void inject(MainActivity mainActivity);
}

And then

MainActivityComponent mainActivityComponent = DaggerMainActivityComponent.builder()
    .mainActivityModule(new MainActivityModule(MainActivity.this))
    .build();

edited Feb 19 '16 at 15:37

answered Nov 16 '15 at 12:07

EpicPandaForce

79,669
27
256
428

Can you explain where you are replacing MainActivityModule here? – IgorGanapolsky Feb 19 '16 at 15:29
1

@IgorGanapolsky I'm not sure why I had it with AppContext. It works essentially the same way, though. – EpicPandaForce Feb 19 '16 at 15:38
@EpicPandaForce In an Activity, should I use DI or just 'this'? For example to show a Dialog in an Activity – Dr.jacky Jul 22 '17 at 16:42
For dialog I'd just go with `this` – EpicPandaForce Jul 22 '17 at 22:44
@EpicPandaForce can you please have a look at this question https://stackoverflow.com/q/45192878/5214893 – eC Droid Jul 25 '17 at 07:12
@EpicPandaForce Why is scope not necessary for parameters stored within the module? – b4da Sep 08 '18 at 10:36
2

Because the scoped provider isn't needed for it to provide the same instance . It will only exist once as it is always provided from the field in the module – EpicPandaForce Sep 08 '18 at 12:51
void inject(MainActivity mainActivity); what is the use of this line??? – Johan Lund Oct 03 '20 at 20:02
1

The ability to field-inject `MainActivity` @JohanLund – EpicPandaForce Oct 03 '20 at 21:51

score 16 · Answer 2 · answered May 09 '19 at 22:01

It took me a while to find a proper solution, so thought it might save some time for others, as far as I could gather this is the preferred solution with the current Dagger version (2.22.1).

In the following example I need the Application's Context to create a RoomDatabase (happens in StoreModule).

Please if you see any errors or mistakes let me know so I'll learn as well :)

Component:

// We only need to scope with @Singleton because in StoreModule we use @Singleton
// you should use the scope you actually need
// read more here https://google.github.io/dagger/api/latest/dagger/Component.html
@Singleton
@Component(modules = { AndroidInjectionModule.class, AppModule.class, StoreModule.class })
public interface AwareAppComponent extends AndroidInjector<App> {

    // This tells Dagger to create a factory which allows passing 
    // in the App (see usage in App implementation below)
    @Component.Factory
    interface Factory extends AndroidInjector.Factory<App> {
    }
}

AppModule:

@Module
public abstract class AppModule {
    // This tell Dagger to use App instance when required to inject Application
    // see more details here: https://google.github.io/dagger/api/2.22.1/dagger/Binds.html
    @Binds
    abstract Application application(App app);
}

StoreModule:

@Module
public class StoreModule {
    private static final String DB_NAME = "aware_db";

    // App will be injected here by Dagger
    // Dagger knows that App instance will fit here based on the @Binds in the AppModule    
    @Singleton
    @Provides
    public AppDatabase provideAppDatabase(Application awareApp) {
        return Room
                .databaseBuilder(awareApp.getApplicationContext(), AppDatabase.class, DB_NAME)
                .build();
    }
}

App:

public class App extends Application implements HasActivityInjector {

    @Inject
    DispatchingAndroidInjector<Activity> dispatchingAndroidInjector;

    @Override
    public void onCreate() {
        super.onCreate();

        // Using the generated factory we can pass the App to the create(...) method
        DaggerAwareAppComponent.factory().create(this).inject(this);
    }

    @Override
    public AndroidInjector<Activity> activityInjector() {
        return dispatchingAndroidInjector;
    }
}

Adolfo Chavez · Answer 3 · 2019-12-29T02:11:45.970

I have read this article and it was very helpful.

https://medium.com/tompee/android-dependency-injection-using-dagger-2-530aa21961b4

Sample code.

Update: I removed from AppComponent.kt these lines because are not necessaries

fun context(): Context
fun applicationContext(): Application

AppComponent.kt

   @Singleton
    @Component(
        modules = [
            NetworkModule::class,
            AppModule::class
        ]
    )
    interface AppComponent {
        fun inject(viewModel: LoginUserViewModel)
    }

AppModule.kt

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

    @Provides
    @Singleton
    fun providesApplication(): Application = application

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

    @Singleton
    @Provides
    fun providesNetworkConnectivityHelper(): NetworkConnectivityHelper{
        return NetworkConnectivityHelper(application.applicationContext)
    }
}

NetworkConnectivityHelper.kt

And only added @Inject constructor to pass the Context

class NetworkConnectivityHelper @Inject constructor(context: Context) {

    private val connectivityManager =
        context.getSystemService(CONNECTIVITY_SERVICE) as ConnectivityManager

    @Suppress("DEPRECATION")
    fun isNetworkAvailable(): Boolean {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
            val nc = connectivityManager.getNetworkCapabilities(connectivityManager.activeNetwork)

            nc != null
                    && nc.hasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)
                    && nc.hasCapability(NetworkCapabilities.NET_CAPABILITY_VALIDATED)
        }

        val networkInfo = connectivityManager.activeNetworkInfo
        return networkInfo != null && networkInfo.isConnected
    }
}

App class.kt

class App : Application() {

    lateinit var appComponent: AppComponent

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

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

Finally in my Activity I injected my helper

 @Inject lateinit var networkConnectivity: NetworkConnectivityHelper

And YEI! it works for me.

Please see this question: https://stackoverflow.com/questions/59509103/dagger-does-not-support-injection-into-static-fields-context — Malwinder Singh, Dec 28 '19 at 07:58

score 2 · Accepted Answer · edited Oct 06 '17 at 13:46

2

Was not correctly building the Application component, needed to pass in the Application. This Dagger 2 example perfectly shows how to do this: https://github.com/google/dagger/tree/master/examples/android-simple/src/main/java/com/example/dagger/simple

Update:
Working link: https://github.com/yongjhih/dagger2-sample/tree/master/examples/android-simple/src/main/java/com/example/dagger/simple

edited Oct 06 '17 at 13:46

Dr.jacky

3,341
6
53
91

answered Jun 07 '15 at 14:28

user3521637

1,622
2
18
25

score 2 · Answer 5 · answered Mar 14 '22 at 19:45

@Singleton
@Component(modules = [YourModule::class, ThatOtherModule::class])
interface ApplicationComponent {

    @Component.Builder
    interface Builder {
        @BindsInstance fun applicationContext(applicationContext: Context): Builder
        fun build(): ApplicationComponent
    }
}

class YourApplication : Application() {

    val component: ApplicationComponent by lazy {
        DaggerApplicationComponent.builder()
            .applicationContext(applicationContext)
            .build()
    }
}

Use the @BindInstance to declare a abstract function that provides the context dependency. i.e @BindsInstance fun applicationContext(applicationContext: Context): Builder
set the context using .applicationContext(applicationContext)

score 1 · Answer 6 · answered Jun 18 '20 at 00:32

probably we could inject the context as shown below:

the application component

@Component(
    modules = [
        (ApplicationModule::class),
        (AndroidSupportInjectionModule::class),
        (UiBindingModule::class)
    ]
)
interface ApplicationComponent : AndroidInjector<AndroidApplication> {

    override fun inject(application: AndroidApplication)

    @Component.Builder
    interface Builder {

        @BindsInstance
        fun application(application: AndroidApplication): Builder

        @BindsInstance
        fun context(context: Context): Builder

        fun build(): ApplicationComponent
    }
}

the custom application extending dagger application

class AndroidApplication : DaggerApplication() {

    override fun applicationInjector(): AndroidInjector<out DaggerApplication> {
        return DaggerApplicationComponent.builder().application(this).context(this).build()
    }
}

Example ApplicationModule

@Module
abstract class ApplicationModule {

    /**
     * Binds a background thread executor, which executes threads from a thread pool
     * @param jobExecutor
     * @return
     */
    @Binds
    internal abstract fun provideThreadExecutor(jobExecutor: JobExecutor): ThreadExecutor

    /**
     * Binds main ui looper thread
     * @param uiThread
     * @return
     */
    @Binds
    internal abstract fun providePostExecutionThread(uiThread: UIThread): PostExecutionThread

}

Example UI BindingModule

@Module
abstract class UiBindingModule {

    @ContributesAndroidInjector(modules = [(MainActivityModule::class)])
    internal abstract fun mainActivity(): MainActivity

    @ContributesAndroidInjector(modules = [(MapFragmentModule::class)])
    internal abstract fun mapFragment(): MapFragment

}

This is actually the best solution if Android injection is used — Nicolás Arias, Jul 08 '20 at 03:21

Dagger 2 injecting Android Application Context

6 Answers6

Linked