Método del módulo de creación de componentes Dagger 2.2 obsoleto

Comencé a usar dagger 2.2 y los métodos del módulo en el generador de componentes están en desuso.

Este es mi componente de aplicación:

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

Y el módulo de aplicación:

@Module
public class ApplicationModule {
    Application application;

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

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

Aquí está la clase generada:

@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;
    }
  }
}

¿Cómo inicializo el componente si no es con ComponentBuilder?

Debería leer la descripción de por qué está obsoleto. Si está utilizando un IDE como IntelliJ o Android Studio, puede seleccionar el método y presionar Control+ Qen Windows para leer el Javadoc, incluido el aviso de obsolescencia.

El Javadoc dice:

@deprecated Este módulo está declarado, pero no se utiliza una instancia en el componente. Este método no es operativo. Para obtener más información, consulte https://google.github.io/dagger/unused-modules .

Y desde este enlace puedes ver:

Cuando el procesador Dagger genera componentes, solo requiere instancias de módulos y dependencias de componentes que se necesitan explícitamente para suministrar solicitudes para un enlace.

• Si todos los métodos de un módulo que se utilizan en el componente son estáticos, Dagger no necesita una instancia de ese módulo en absoluto. Dagger puede invocar los métodos estáticos directamente sin un módulo.
• Si un módulo no proporciona enlaces para un componente, no se necesita ninguna instancia de ese módulo para construir el gráfico.

Es seguro decir que puede ignorar la desaprobación. Tiene la intención de notificarle sobre métodos y módulos no utilizados. Tan pronto como realmente requiera / use Applicationen algún lugar de su subgráfico, el módulo será necesario y la advertencia de obsolescencia desaparecerá.

Se muestra en desuso porque no está utilizando Componente y módulo en su aplicación por

@Inject
SomeObjectFromModule mSomeObject

Si no está inyectando dependencias en sus aplicaciones, no tiene sentido inicializar su componente, así que busque al menos un uso.

una vez que agregue estas líneas en cualquier clase que desee inyectar vistas y luego limpiar, construir y reconstruir el proyecto y su desaprobación se resolverá

Muestra un error cuando Moduleno tengo ningún @Providesmétodo o el objeto proporcionado por Daggerno se usa en la aplicación.
Ejemplo para eliminar un módulo obsoleto

Módulo

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

Actividad

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

O en componente

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

    void inject(SecondActivity activity);

    Book getBookTest();
}

Tengo el mismo problema con el host y solo quiero que todos los que tienen un problema obsoleto en la clase Generador de componentes deben verificar dos cosas para ahorrar tiempo:

1 / Corrija la sintaxis de dagger para el módulo, el componente también verifique cuidadosamente dónde inyecta.

2 / Debe tener el objeto de inyección (anotación de inyección y su objeto) en el lugar que desea inyectar o, de lo contrario, el compilador de dagger no puede ver dónde usar su módulo, por lo que algún método quedará obsoleto. vuelva a compilar el código, ya no tendrá ese problema :)

Obtendrá el método del módulo obsoleto si declara void inject(AppCompactActivity activity);en la clase de componente. en lugar de tener que usar un acoplamiento estrecho como seguir void inject(MainActivity activity);y reconstruir su proyecto, verá, no hay un método obsoleto en la clase de módulo