Dagger 2 Constructor Injection and more

Question

I have some questions regarding dagger2 which i find hard to understand. This code:

@Module
public class AppModule {

    private MainApplication applicationContext;

    @Inject
    public AppModule(MainApplication context){
        this.applicationContext = context;
    }

    @Provides
    @Singleton
    StuffA provideStuffA(){
        return new StuffA();
    }

    @Provides
    @Singleton
    StuffB provideStuffB(StuffA){
         return new StuffB(stuffA);
    }
}

And in the application class:

appComponent = DaggerAppComponent.builder()
                .appModule(new AppModule(this))
                .build();

My first question is:

• If i want to split the Module into 2, provideStuffA in ModuleA and provideStuffB in ModuleB, how could i accomplish that, considering B depends on A.

Second question:

• I have an object that i am using in the Application class, and it is from the application class i call the injections from the activities. So how do i access that object in the application class=? Should i call inject on my applicationClass just after the Dagger build stuff above?

Final question

• Imagining i have two Modules with different dependencies that i need to use in the same activity. What is the proper way of having one component and different modules that will inject in the same activity.

PS. I'm sorry if this is really basic stuff, but i find the documentation very poor and lack of examples as well. Thanks in advanced

Answer 1

Answer 1

You just split them in two separate modules. Dagger will build the graph and when at some point provideStuffB() is called it will inject it with StuffA. Btw I think there is small syntax error in the provide method and it should be (stuffA parameter was missing):

@Provides
@Singleton
StuffB provideStuffB(StuffA stuffA){
     return new StuffB(stuffA);
}

Answer 2

Yes, that is the usual way. Just after you create the graph (in onCreate()) you inject this (the application). Please note there is a subtle caveat when in comes to unit tests with this approach - Application object will be created even before setUp() method is called so you will be unable to set/swap your test Component (and you will end up always with your default Component). The solution is to use lazy initialization of the graph, i.e. when first activity (or service, or BroadcastReceiver, etc.) calls getApplication().getInjector(this) you will have to create the graph at that point.

Answer 3

You usually have one top Component that contains all the modules and subcomponents. It is (have to be) able to inject all activities. De facto the top component is used to generate the graph. Here is an example from real app:

@Component(modules = {IzgubenoDaggerModule.class,
                        AcraDaggerModule.class,
                        AppInfoDaggerModule.class,
                        SessionDaggerModule.class,
                        ComponentManagerDaggerModule.class,
                        NetworkInfoProviderDaggerModule.class,
                        DeviceInfoProviderDaggerModule.class,
                        KhRestExchangeManagerDaggerModule.class
                     })
@Singleton
public interface IzgubenoDaggerComponent extends GgLibDaggerComponent {
    void inject(IzgubenoApplication app);
    void inject(Act_Main act);
    void inject(Act_ContactDetails act);
    void inject(Act_MyPets act);
    void inject(Act_PetEdit act);
    void inject(Act_PetManage act);
    void inject(Act_PetPics act);
    //...
    GgLibDaggerComponent newGgLibDaggerComponent(HttpsDaggerModule httpsMod,
                                             KhRestDaggerModule khrestMod,
                                             AppInfoDaggerModule appInfoMod,
                                             GgServerDaggerModule ggServMod,
                                             GgClientDaggerModule ggClientMod);
    //...
}