了解Dagger2子组件

Question

I have the following Dagger2 Architecture in my app:

-- AppComponent (@PerApplication)
  -- UserComponent (@PerUser)
    -- ActivityComponent (@PerActivity)
      -- ChatComponent (@PerActivity) <-- 1

Where: AppComponent:

@PerApplication
@Component(modules = {ApplicationModule.class, StorageModule.class, NetworkModule.class})
public interface ApplicationComponent {
    UserComponent plus(UserModule userComponent);

    //Exposed to sub-graphs.
    Context application();
}

UserComponent:

@PerUser
@Subcomponent(modules = {UserModule.class, RosterModule.class})
public interface UserComponent {
    ActivityComponent plus(ActivityModule activityModule);

    User getMe();

    UserRepository userRepository();
}

ActivityComponent:

@PerActivity
@Subcomponent(modules = ActivityModule.class)
public interface ActivityComponent {

    ChatComponent plus(ChatModule chatComponent);

    //Exposed to sub-graphs.
    Context context();
}

ChatComponent:

@PerActivity
@Subcomponent(modules = {ChatModule.class})
public interface ChatComponent {
    void inject(ChatListFragment chatListFragment);
    void inject(ConversationFragment conversationFragment);
    void inject(NewConversationFragment newConversationFragment);
    void inject(CloudFilesFragment cloudFilesFragment);
    void inject(ChatActivity chatActivity);
    void inject(ConversationActivity conversationActivity);
    void inject(NewConversationActivity newConversationActivity);

    void inject(NewGroupActivity newGroupActivity);
    void inject(NewGroupFragment newGroupFragment);
}

I'm facing 2 problems:

First, how can I inject different Context to my classes ? Either App or Activity ??

And secondly, I'm facing a bizarre issue when trying to compile my code, the error is:

Error:(23, 10) error: br.com.animaeducacao.ulife.domain.interactor.UseCase cannot be provided without an @Provides-annotated method. br.com.animaeducacao.ulife.presentation.view.fragment.ChatListFragment.chatListPresenter [injected field of type: br.com.animaeducacao.ulife.presentation.presenter.ChatListPresenter chatListPresenter] br.com.animaeducacao.ulife.presentation.presenter.ChatListPresenter.(br.com.animaeducacao.ulife.domain.interactor.UseCase chatDialogsUseCase, br.com.animaeducacao.ulife.domain.interactor.UseCase adviceUserPresence, android.content.Context context) [parameter: @javax.inject.Named("getChatDialogs") br.com.animaeducacao.ulife.domain.interactor.UseCase chatDialogsUseCase]

My ChatListFragment is:

@PerActivity
public class ChatListFragment extends BaseFragment implements ChatListView {

    @Inject
    ChatListPresenter chatListPresenter;
  ...
//called onActivityCreated()
private void initialize() {
        this.getComponent(ChatComponent.class).inject(this);
}

BaseFragment:

protected <C> C getComponent(Class<C> componentType) {
    return componentType.cast(((HasComponent<C>)getActivity()).getComponent());
  }

ChatListPresenter:

@PerActivity
public class ChatListPresenter implements Presenter {

    private final UseCase chatDialogsUseCase;
    private final UseCase adviceUserPresence;
    private final Context context;
    private ChatListView chatListView;

    @Inject
    public ChatListPresenter(@Named("getChatDialogs") UseCase chatDialogsUseCase,
                             @Named("adviceUserPresence") UseCase adviceUserPresence,
                             Context context) {
        this.chatDialogsUseCase = chatDialogsUseCase;
        this.adviceUserPresence = adviceUserPresence;
        this.context = context;
    }

The problem is, in my ChatModule class I have implemented all the @Provides necessary:

@Provides
    @PerActivity
    @Named("getChatDialogs")
    public UseCase provideChatDialogs(@Named("transactionalChatRepository") ChatRepository chatRepository, ThreadExecutor threadExecutor, PostExecutionThread postExecutionThread) {
        return new GetUserChatDialogs(chatRepository, threadExecutor, postExecutionThread);
    }

Is this a good approach ? Why is this not compiling, what I am missing here ? Sorry for the long post and thanks !

Answer 1

Ah, you have multiple problems.

1.) While you're using the subscoping correctly to a point (you are making @Subcomponent s properly at first), the ChatComponent doesn't actually subscope its parent component - basically, ChatComponent cannot be @PerActivity , it needs to be a fourth scope.

@Subcomponent annotation is just a way to create a subscoped component without having to specify it as a component dependency. It still needs its own "more specific" scope.

2.) to make subscoping work, you need to specify provision methods in your component for every dependency that that component is meant to provide, so that the subscoped components can inherit them.

For example, your ApplicationComponent doesn't have provision methods for what is in StorageModule , and therefore the dependencies provided by StorageModule cannot be inherited to subscoped components.

I however am not sure if you can just specify the class you're providing if it is not inside a module, and instead it is annotated with @Inject constructor and the class is marked with the scope.

Also, to allow in a scope hierarchy A->B->C for C to inherit from A, then B needs to have the provision methods of A as well.

So UserComponent extends ApplicationComponent is necessary, and ActivityComponent extends UserComponent , and ChatComponent extends ActivityComponent .

3.) You should use the @Named("application") and @Named("activity") annotations to specify two different Context , or instead just refer to them as Application and Activity in your module so that they don't get mixed up.