I've got a strange problem here, and I'm not quite sure why what I'm doing isn't allowed. I've got the following modules:
@Module
public final class AppModule {
private Context mContext;
@Provides
@Singleton
@AppContext
public Context provideContext() { return mContext; }
}
@Module
public final class NetModule {
@Provides
@Singleton
public OkHttpClient provideOkHttp() {
return new OkHttpClient.Builder().build();
}
}
For various reasons, I don't want to have these two modules in the same component (basically due to my project structure). So I tried to create the following components:
@Singleton
@Component(modules = AppModule.class)
public interface AppComponent {
@AppContext Context appContext();
}
@Singleton
@Component(dependencies = AppComponent.class, modules = NetModule.class)
public interface NetComponent {
Retrofit retrofit();
}
But when I try to compile this, I get the following error message:
Error:(12, 1) error: This @Singleton component cannot depend on scoped components:
@Singleton com.myapp.service.dagger.AppComponent
I understand why depending on different scopes would be bad and disallowed. But why is Singleton depends-on Singleton not allowed? This feels like it should work, since all I'm doing is declaring sibling components. What am I missing?
In order to use dependency injection with the help of dagger 2 libraries, we need to add it's dependency. Go to Gradle Scripts > build. gradle(Module: app) and add the following dependencies. After adding these dependencies you need to click on Sync Now.
The @Singleton annotation is used to declare to Dagger that the provided object is to be only initialized only once during the entire lifecycle of the Component which uses that Module.
Dagger generates code similar to what you would have written manually. Internally, Dagger creates a graph of objects that it can reference to find the way to provide an instance of a class. For every class in the graph, Dagger generates a factory-type class that it uses internally to get instances of that type.
Because your NetComponent component depends on your AppComponent component, they cannot have the same scope. Scopes are used to annotate lifecycles, and because NetComponent depends on AppComponent, they don't have the same lifecycle. AppComponent could potentially live longer than NetComponent, because it's a part of the actual build process of NetComponent. NetComponent couldn't exist without AppComponent, but not the other way around.
You could add your own custom scope and apply that to your NetComponent and NetModule, that would fix it.
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With