Dagger 2.2 component builder module method deprecated

I started using dagger 2.2 and the module methods in the Component builder are deprecated.

This is my Application component :

@Component(modules = ApplicationModule.class)
public interface ApplicationComponent {
    void inject(Application application);
}

And the Application module:

@Module
public class ApplicationModule {
    Application application;

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

    @Provides
    @Singleton
    Application providesApplication() {
        return application;
    }
}

Here is the generated class:

@Generated(
  value = "dagger.internal.codegen.ComponentProcessor",
  comments = "https://google.github.io/dagger"
)
public final class DaggerApplicationComponent implements ApplicationComponent {
  private DaggerApplicationComponent(Builder builder) {
    assert builder != null;
  }

  public static Builder builder() {
    return new Builder();
  }

  public static ApplicationComponent create() {
    return builder().build();
  }

  @Override
  public void inject(Application application) {
    MembersInjectors.<Application>noOp().injectMembers(application);
  }

  public static final class Builder {
    private Builder() {}

    public ApplicationComponent build() {
      return new DaggerApplicationComponent(this);
    }

    /**
     * @deprecated This module is declared, but an instance is not used in the component. This method is a no-op. For more, see https://google.github.io/dagger/unused-modules.
     */
    @Deprecated
    public Builder applicationModule(ApplicationModule applicationModule) {
      Preconditions.checkNotNull(applicationModule);
      return this;
    }
  }
}

How do I initialize the component if not with the ComponentBuilder?

You should read the description of why it is deprecated. If you are using an IDE like IntelliJ or Android Studio you can just select the method and hit Control + Q on Windows to read the Javadoc including the deprecation notice.

The Javadoc reads:

@deprecated This module is declared, but an instance is not used in the component. This method is a no-op. For more, see https://google.github.io/dagger/unused-modules.

And from this link you can see:

When the Dagger processor generates components, it only requires instances of modules and component dependencies that are explicitly needed to supply requests for a binding.

• If all of a module’s methods that are used in the component are static, Dagger does not need an instance of that module at all. Dagger can invoke the static methods directly without a module.
• If a module provides no bindings for a Component, no instance of that module is necessary to construct the graph.

It is safe to say that you can just ignore the deprecation. It is intended to notify you of unused methods and modules. As soon as you actually require / use Application somewhere in your subgraph the module is going to be needed, and the deprecation warning will go away.

It show deprecated because you are not using Component and module in your application by

@Inject
SomeObjectFromModule mSomeObject

if you are not injecting dependencies in your applications there is no use of initialising your component so dagger look for at least one usage

once you add these lines in any classes you want to inject views and then clean build and rebuild the project and your deprecation will be solved

It showing error when my Module have no @Provides method or the object that provide by Dagger is not used in app.
Example to remove deprecated module

Module

@Module
public class SecondActivityModule {
    @Provides
    Book provideBookTest() {
        return new Book();
    }
}

Activity

public class SecondActivity extends AppCompatActivity {
    @Inject
    Book test;
    ...
}

OR in Component

@Component(modules = SecondModule.class)
public interface SecondComponent {

    void inject(SecondActivity activity);

    Book getBookTest();
}

I have the same problem with host and I just want everyone has deprecated issue on Generated component builder class should check two things to save time:

1/ Correct dagger syntax for module, component also check carefully where you inject.

2/ Must have injection object (inject annotation and its object) in place you want to inject or else the dagger compiler cannot see where to use your module so some method will be deprecated.Just inject at least one module's provides to your injection place and re-compile the code, you won't have that issue anymore :)

you will get module method deprecated if you declare void inject(AppCompactActivity activity); in component class. instead of you have to use tight coupling like following void inject(MainActivity activity);and rebuild your project you will see, there is no deprecate method in module class