匕首2-无法将成员注入原始类型

Question

I need to have three levels of inheritance and inject with dagger2

1.MainActivity

--1.1 MainSubActivity

----1.1.1 MainSubActivityOne

----1.1.2 MainSubActivityTwo (The same structure as MainSubActivityOne)

MainActivity

public abstract class MainActivity<T extends MainPresenter> extends BaseActivity implements MainView{

     @Inject
     protected T mPresenter;

}

MainPresenter

public abstract class MainPresenter<T extends MainView> extends BasePresenter<T> { ... }

MainView

public interface MainView extends BaseView{ ... }

-- MainSubActivity

public abstract class MainSubActivity extends MainActivity<MainSubPresenter> implements MainSubView { ... }

-- MainSubPresenter

public abstract class MainSubPresenter<T extends MainSubView> extends MainPresenter<T> { ... }

-- MainSubView

public interface MainSubView extends MainView { ... }

---- MainSubActivityOne (Same as MainSubActivityTwo):

public class MainSubActivityOne extends MainSubActivity implements MainSubViewOne{

    @Override
    protected void onCreatePresenter(){
        mPresenter.setView(this);
        mPresenter.onCreate();
    }

    @Override
    protected void initializeDagger() {
        getActivityComponent().inject(this);
    }

}

---- MainSubPresenterOne (Same as MainPresenterTwo):

public class MainSubPresenterOne extends MainSubPresenter<MainSubViewOne> { ... }

---- MainSubViewOne (Same as MainSubViewTwo):

public interface MainSubViewOne extends MainSubView { ... }

ActivityComponent

@PerActivity
@Component(dependencies = ApplicationComponent.class, modules = 
{ActivityModule.class})
public interface ActivityComponent { 

    void inject(MainActivity mainActivity);

}

ActivityModule

@Provides
@PerActivity
MainPresenter provideMainPresenter() {
    return new MainSubPresenterOne();
}

When I had only two levels, all is ok, but now I obtain this error:

...components/ActivityComponent.java:90: error: [Dagger/MembersInjection] Cannot inject members into raw type com.example.main.MainActivity
void inject(MainActivity mainActivity);
     ^
  com.example.main.MainActivity is injected at
      ...components.ActivityComponent.inject(com.example.main.MainActivity)

If I change the activityComponent to:

void inject(MainSubActivityOne activity);
void inject(MainSubActivityTwo activity);

I obtain the next error instead:

.../components/ActivityComponent.java:92: error: [Dagger/MissingBinding] com.example.main.MainSubPresenterOne cannot be provided without an @Provides-annotated method.
void inject(MainSubActivityOne mainActivity);
     ^
  com.example.main.MainSubPresenter is injected at
      com.example.main.MainActivity.mPresenter
  com.example.main.MainSubPresenterOne is injected at
      ...components.ActivityComponent.inject(com.example.main.MainSubActivityOne)

Answer 1

This line is your problem:

void inject(MainActivity mainActivity);

MainActivity<T> needs a generic type argument, but that's irrelevant. It's an abstract class. You're not injecting this common parent class. You're injecting the instances of its concrete children. Here's what you should do instead:

void inject(MainSubActivityOne activity);
void inject(MainSubActivityTwo activity);

[Dagger/MissingBinding] com.example.main.MainSubPresenterOne cannot be provided without an @Provides-annotated method.

This is all true. Your MainSubActivityOne expects a MainSubPresenterOne here:

 @Inject
 protected T mPresenter;

Yet you only created a binding for MainPresenter :

@Provides
@PerActivity
MainPresenter provideMainPresenter() {
    return new MainSubPresenterOne();
}

This means that Dagger knows only how to inject a MainPresenter , it doesn't care that the MainPresenter is actually a MainSubPresenterOne .

Instead, what I would do is to scope the concrete presenters and let them have an @Inject constructor:

@PerActivity
public class MainSubPresenterOne extends MainSubPresenter<MainSubViewOne> { 

    @Inject
    public MainSubPresenterOne() {
        // ...
    }

    // ...
}

Now Dagger knows how to inject MainSubPresenterOne . Remove the @Provides method.

I recommend the official documentation , which – among other things – explains that @Provides is a kind of last resort and you should prefer @Inject on the types under your control.

---

Alternatively you would

 @Inject
 protected MainPresenter mPresenter;

and create a separate subcomponent for each of your activities with a module providing the actual presenter:

@Module
abstract class MainSubActivityOneModule {

    @Binds
    abstract MainSubPresenter<MainSubViewOne> bindMainPresenter(MainSubPresenterOne impl);
}

This assumes that the activity doesn't care about the concrete implementation of its presenter, which may or may not be what you want.