Dagger 2: Unable to inject singleton in other scope

Question

I have Singleton scoped module that provides some standard singletons: Application, DB services, etc. But for Activity I have separate module that should create Presenter for he Activity and I need to pass Application context to it. However I get following error when trying to compile the project:

Error:(13, 1) error: xxx.SplashComponent scoped with @xxx.ViewScope may not reference bindings with different scopes:
@Provides @Singleton xxx.ApplicationModule.provideAppContext()

Here is snippet of my Application module:

@Singleton
@Module
public class ApplicationModule {

    private Application app;

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

    @Provides
    @Singleton
    @Named("ui")
    Scheduler provideUIScheduler() {
        return AndroidSchedulers.mainThread();
    }

    @Provides
    @Singleton
    @Named("io")
    Scheduler provideIOScheduler() {
        return Schedulers.io();
    }

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

    @Provides
    @Singleton
    Context provideAppContext() {
        return app;
    }
}

And here is Activity module and Component:

@Module
public class SplashModule {
    private final FragmentManager fragmentManager;

    public SplashModule(FragmentManager fragmentManager) {

        this.fragmentManager = fragmentManager;
    }

    @Provides
    @ViewScope
    Presenter getPresenter(Context context) {
        return new SplashPresenter(context, fragmentManager);
    }
}

Component:

@ViewScope
@Component(modules = {SplashModule.class, ApplicationModule.class})
public interface SplashComponent {
    void inject(SplashActivity activity);
}

What am I doing wrong?

Thanks. After I looked at your error message, I understood that my Module file contained methods with different scopes. For instance, "@ FirstScope @ Binds Class1 method1()" and "@ SecondScope @ Binds Class2 method2()". — CoolMind, Jan 17 '18 at 18:25

score 17 · Answer 1 · answered Mar 13 '16 at 18:08

What am I doing wrong?

This:

@ViewScope
@Component(modules = {SplashModule.class /*View scoped*/,
    ApplicationModule.class/*Singleton scoped*/})

You can only include unscoped or modules scoped with the same scope in your components. You will need to use more than one component.

To include the dependencies from your application, you need to have them in a different component, e.g. ApplicationComponent. If yo do this, you have 2 options: either declare SplashComponent as a SubComponent of ApplicationComponent or add ApplicationComponent as a dependency to your component. If you add it as a dependency, be sure to also provide methods in your ApplicationComponent, so that it can access the dependencies.

e.g. if you were to use component dependencies:

@Component(modules = {ApplicationModule.class})
public interface ApplicationComponent {

    void inject(MyApplication app);

    // todo: also add getters for your other dependencies you need further down the graph
    Application getApplication();

}

@Component(modules = {SplashModule.class}, dependencies={ApplicationComponent.class})
public interface SplashComponent {
    // as before
}

38

Still can`t understand – bowman han Dec 08 '16 at 18:36

score 12 · Answer 2 · edited Apr 09 '18 at 09:41

12

I want to explain some key points of Dagger 2 from my understanding.

Main actors:

"Component" is the bridge between modules and places where injection happens.
"Module" is the place where we declare our objects which will be injected.
"Scope" is like the life-time of related injection story.

How does it work?

Declare component with a scope ("Singleton").
Define modules that can inject the required objects in the component's modules list.

void inject(BaseFragment baseFragment);

*******Expose the provided objects in the component's module to sub components****
DbHelper dbHelper();

Declare module and provides objects to be injected via component.

Ex:

@Singleton 
@Component(modules = { ApplicationModule.class, NetworkModule.class })
public interface ApplicationComponent {

  void inject(BaseActivity baseActivity);
  DbHelper dbHelper();
}




@PerService @Component(dependencies = ApplicationComponent.class, modules = ServiceModule.class)
public interface ServiceComponent {

  void inject(SyncService service);

}

// SyncService.java

  @Inject DbHelper dbHelper;  (even Singleton scoped)

  private void setupInjector() {
    ServiceComponent mServiceComponent = DaggerServiceComponent.builder()
        .applicationComponent(getApplicationComponent())
        .serviceModule(new ServiceModule(this))
        .build();
    mServiceComponent.inject(this);
  }

ok then...

You can inject both unscoped and (Singleton and PerService) scoped objects to your SyncService.class

edited Apr 09 '18 at 09:41

chriscz

169
2
9

answered Mar 14 '17 at 10:09

huseyin

1,367
16
19

2

Exposing stuff like `DbHelper dbHelper()` was what I was missing all the time. Thanks so much for this answer. – Yaroslav Mytkalyk Jun 14 '17 at 15:54
1

I have to correct you a bit about "Singleton is the default". No-scope is the default not Singleton. Without @Singleton you'll have a new instance on every injection. – WindRider Jul 24 '17 at 09:17
@WindRider you're right. Thats why we marked some components as Singleton for avoiding to create expensive objects each time. – huseyin Jul 25 '17 at 11:57
Actually, it's created every time it's injected so its effective scope is actually the consumer's scope. – WindRider Jul 25 '17 at 12:47
what do you mean by consumer's scope? – huseyin Jul 25 '17 at 20:33
WindRider means if your object is allowed to have multiple instances throughout your application lifecycle, then you'll get a new object every time you inject. For instance, even if you don't annotate the Application instance with `@Singleton` every time you inject `Application`, it will return the same instance. Now, let's say you have `GrumpyFragment`, you'll get a new instance every time you inject a `GrumpyFragment`. Because the Android system restricts the `Application` object to have only one instance but for `Fragment` there is no such restriction. – Farid Nov 10 '19 at 12:37
Here, `Application` and `Fragment` are consumers and their scope, by default, are `@Singleton` and `No Scope` respectively. – Farid Nov 10 '19 at 12:43

score 0 · Answer 3 · answered Mar 02 '20 at 06:42

Scoping rules:

When a type is marked with a scope annotation, it can only be used by Components that are annotated with the same scope.

When a Component is marked with a scope annotation, it can only provide types with that annotation or types that have no annotation.

A subcomponent cannot use a scope annotation used by one of its parent Components.

Components also involve subcomponents in this context.

Caution:- Modules that use a scope annotation can only be used in components that are annotated with the same scope. Check Here.

For more information on Dagger in Android go through this training and practise it here.

Dagger 2: Unable to inject singleton in other scope

3 Answers3