0

I am trying to figure out how to use Dagger components/subcomponents. I know it is the older style of things but I have a legacy app that is using this Dagger structure and I'm using this sample project to better understand it.

This sample app has just a AppComponent, AppModule, ActivityComponent and ActivityModule. I'm trying to inject MainActivityDependency into my MainActivity but the compiler says it can provide it without an explicit @Provides. But I am already explicitly providing it. I know I can just annotate the class with @Inject but for the sake of exercise I need to use the @Provides method.

It seems like I have the dependency structure correct but can't figure it out. I've pasted sample code below but here is the github link as well:

https://github.com/fkruege/daggerSubComponentPractice/tree/master/app/src/main/java/com/franctan/daggerpractice

Thank you

AppComponent.java
@Singleton
@Component(modules = AppModule.class)
public interface AppComponent {
    ActivityComponent.Builder activityComponentBuilder();
    Application application();
    void inject(MyApp myApp);
}

AppModule

@Module(subcomponents = {ActivityComponent.class})
public class AppModule {

    private Application app;

    public AppModule(Application app) {
        this.app = app;
    }

    @Provides
    @Singleton
    public Application provideApplication() {
        return app;
    }

    @Provides
    @Singleton
    public AppDependency provideAppDependency() {
        return new AppDependency();
    }

}

ActivityComponent

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

    @Subcomponent.Builder
    interface Builder {
        Builder activityModule(ActivityModule module);
        ActivityComponent build();
    }

    void inject(MainActivity mainActivity);
}

ActivityModule

@Module

public class ActivityModule {

    private Activity activity;

    public ActivityModule(Activity activity) {
        this.activity = activity;
    }

    @ActivityScope
    @Provides
    public Activity provideActivity() {
        return activity;
    }

    @ActivityScope
    @Provides
    public MainActivityDependency provideMainActivityDependency() {
        return new MainActivityDependency();
    }


}

MyApp

public class MyApp extends Application {

    public AppComponent appComponent;

    @Inject
    AppDependency appDependency;

    @Override
    public void onCreate() {
        super.onCreate();
        appComponent = DaggerAppComponent
                .builder()
                .appModule(new AppModule(this))
                .build();

        appComponent.inject(this);
    }
}

MainActivity

 @Inject
    MainActivityDependency mainActivityDependency;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        MyApp myApp = (MyApp) getApplication();

        myApp.appComponent
                .activityComponentBuilder()
                .activityModule(new ActivityModule(this))
                .build()
                .inject(this);
Franc
  • 41
  • 1
  • 2

1 Answers1

0

So figured it out. It turns out the ActivityScope interface was defined incorrectly:

@Qualifier
@Retention(RetentionPolicy.RUNTIME)
@Scope
public @interface ActivityScope {
}

The @Qualifier annotation was messing things up. Dumb mistake.

Franc
  • 41
  • 1
  • 2