@Component.Builder is missing setters for required modules or components [Dagger2]

Question

I'm trying to use Component.Builder to inject my module but something is wrong with RestModule -one of my modules. it returns

Error:(41, 5) error: @Component.Builder is missing setters for required modules or components: [com.injection.module.services.RestModule]

Here's the ApplicationComponent :

@Singleton
@Component(modules = {PresenterEnvironmentModule.class,
    RestModule.class})
public interface PresenterEnvironmentComponent {


@Component.Builder
interface Builder {

    @BindsInstance
    Builder sharedPreferenceService(SharedPrefService sharedPreferences);

    @BindsInstance
    Builder loggingService(LoggingService loggingService);

    @BindsInstance
    Builder applicationService(Application application);

    @BindsInstance
    Builder connectivityService(ConnectivityService connectivityService);

    @BindsInstance
    Builder schedulersService(SchedulersService schedulersService);

    @BindsInstance
    Builder sessionService(SessionService sessionService);



    PresenterEnvironmentComponent build();

}

@NonNull
PresenterEnvironment presenterEnvironment();

void inject(BaseBootstrapActivity<BaseBootstrapPresenter> baseBootstrapActivity);
}

And Here's The RestModule:

 @Module
 public class RestModule {
 private final boolean debuggable;
 private final String baseUrl;
 @NonNull
 private final TokenInterceptor tokenInterceptor;
 @NonNull
 private final BootstrapRestService bootstrapRestService;
 @Nullable
 private Interceptor[] additionalInterceptors;
 @Nullable
 private Function<OkHttpClient.Builder, OkHttpClient.Builder> onOkHttpClient;
@Nullable
private Function<OkHttpClient.Builder, OkHttpClient.Builder> onOkHttpClientForUploading;

public RestModule(@NonNull RestSettings restSettings) {
    this.debuggable = restSettings.isDebuggable();
    this.baseUrl =  restSettings.getBaseUrl();
    this.tokenInterceptor =   restSettings.getTokenInterceptor();
    this.bootstrapRestService = restSettings.getRestService();
    this.onOkHttpClient = restSettings.getOnOkHttpClient();
    this.onOkHttpClientForUploading = restSettings.getOnOkHttpClientForUploading();
    this.additionalInterceptors =     restSettings.getAdditionalInterceptors();
}

@Provides
@Singleton
@NonNull
@Type.Basic
public OkHttpClient provideOkHttpClient(@NonNull TokenInterceptor tokenInterceptor,
                                        @NonNull HttpLoggingInterceptor loggingInterceptor,
                                        @NonNull OkLogInterceptor okLogInterceptor,
                                        @NonNull CachingInterceptor cacheInterceptor) {
    OkHttpClient.Builder builder = new OkHttpClient.Builder();
    builder.addInterceptor(tokenInterceptor);
    if (additionalInterceptors != null && additionalInterceptors.length > 0) {
        for (Interceptor interceptor : additionalInterceptors) {
            builder.addInterceptor(interceptor);
        }
    }
    if (onOkHttpClient != null) {
        builder = apply(onOkHttpClient, builder);
    }
    if (debuggable) {
        // Add HttpLoggingInterceptor
        builder.addInterceptor(loggingInterceptor);
        // add cache interceptor
        builder.addNetworkInterceptor(cacheInterceptor);
        // add okLog interceptor
        builder.addInterceptor(okLogInterceptor);
    }
    return builder.build();
}

@Provides
@Singleton
@NonNull
@Type.ForUploading
public OkHttpClient provideOkHttpClientForUploading(@NonNull TokenInterceptor tokenInterceptor,
                                                    @NonNull HttpLoggingInterceptor loggingInterceptor,
                                                    @NonNull OkLogInterceptor okLogInterceptor,
                                                    @NonNull CachingInterceptor cacheInterceptor) {
    OkHttpClient.Builder builder = new OkHttpClient.Builder();
    builder.addInterceptor(tokenInterceptor);

    if (additionalInterceptors != null && additionalInterceptors.length > 0) {
        for (Interceptor interceptor : additionalInterceptors) {
            builder.addInterceptor(interceptor);
        }
    }

    if (onOkHttpClientForUploading == null) {
        builder.writeTimeout(60, TimeUnit.SECONDS);
        builder.connectTimeout(60, TimeUnit.SECONDS);
        builder.readTimeout(60, TimeUnit.SECONDS);
    } else {
        builder = apply(onOkHttpClientForUploading, builder);
    }
    if (debuggable) {
        // Add HttpLoggingInterceptor
        builder.addInterceptor(loggingInterceptor);
        // add cache interceptor
        builder.addNetworkInterceptor(cacheInterceptor);
        // add okLog interceptor
        builder.addInterceptor(okLogInterceptor);
    }
    return builder.build();
}

@Provides
@Singleton
@NonNull
public OkLogInterceptor provideOkLogInterceptor() {
    return new OkLogInterceptor.Builder().withAllLogData().build();
}

@Provides
@Singleton
@NonNull
public HttpLoggingInterceptor provideHttpLoggingInterceptor() {
    HttpLoggingInterceptor interceptor = new HttpLoggingInterceptor();
    interceptor.setLevel(HttpLoggingInterceptor.Level.BODY);
    return interceptor;
}

@Provides
@Singleton
@NonNull
@Type.Basic
public Retrofit provideRetrofit(@NonNull @Type.Basic OkHttpClient client) {
    return new Retrofit.Builder()
            .baseUrl(baseUrl)
            .client(client)
            .addConverterFactory(LoganSquareConverterFactory.create())
            .addCallAdapterFactory(RxJava2CallAdapterFactory.create())
            .build();
}

@Provides
@Singleton
@NonNull
@Type.ForUploading
public Retrofit provideRetrofitForUploading(@NonNull @Type.ForUploading OkHttpClient client) {
    return new Retrofit.Builder()
            .baseUrl(baseUrl)
            .client(client)
            .addConverterFactory(LoganSquareConverterFactory.create())
            .addCallAdapterFactory(RxJava2CallAdapterFactory.create())
            .build();
}

@Provides
@Singleton
@NonNull
public CachingInterceptor provideCachingInterceptor(LoggingService loggingService) {
    return new CachingInterceptor(loggingService);
}

@Provides
@Singleton
@NonNull
public TokenInterceptor provideTokenInterceptor() {
    return tokenInterceptor;
}

@Provides
@Singleton
@NonNull
public BootstrapRestService provideBaseRestService(@NonNull @Type.Basic Retrofit retrofit,
                                                   @NonNull @Type.ForUploading Retrofit retrofitForUploading) {
    return bootstrapRestService.setup(retrofit, retrofitForUploading);
}


@NonNull
private <T, R> R apply(@NonNull Function<T, R> f, @NonNull T t) {
    try {
        return Preconditions.checkNotNull(f.apply(t));
    } catch (Throwable ex) {
        throw new IllegalStateException("Applying function for " + t.toString() + " Threw " + ex);
    }
}



 }

Answer 1

@Module
public class RestModule {
  // ...
  public RestModule(@NonNull RestSettings restSettings) {

RestModule is an instantiable Module without a visible parameterless constructor. Dagger doesn't know how to create an instance of it. You'll need to supply a method like Builder restModule(RestModule restModule) on the @Component.Builder, and call it during creation like your @BindsInstance methods.

Each module dependency that Dagger can't instantiate itself (eg, the module doesn't have a visible no-args constructor) must have an abstract setter method. Other module dependencies (ones that Dagger can instantiate) are allowed, but not required. (from the @Component.Builder javadoc )

---

Not all Modules are instantiable; some are interfaces or abstract classes. Because Dagger calls static methods statically, and reflects on @Binds methods at compile time, many modules do not need to be instantiated at all. This is often more optimal, as Dagger can skip creating an instance.

For Modules that are instantiable but have visible zero-arg constructors, Dagger can automatically call new , and you may leave those Modules off the Builder. (You may choose to include them; they don't need to be called, but may be useful if you subclass modules, which the docs advise against anyway .)

For Modules that are instantiable but only have constructors with arguments, Dagger cannot create the Modules; it will not supply the constructor with arguments from the graph as it does with @Provides methods. You'll need to explicitly create a Builder method, and call it with an instance of a Module that you create yourself.