Composant de la dague 2 non généré

Question

Dans mon module, dans ma classe d'application de base

component = DaggerCompClassComponent.builder()
                .classModule(new ModuleClass()).build();

il ne trouve pas le composant DaggerCompClassComponent.

J'ai sur le module build.gradle

apply plugin: 'com.neenbedankt.android-apt'
.........................
apt 'com.google.dagger:dagger-compiler:2.8'
compile 'com.google.dagger:dagger:2.8'
provided 'javax.annotation:jsr250-api:1.0'

et dans le projet build.gradle,

 classpath 'com.neenbedankt.gradle.plugins:android-apt:1.8'

J'ai fait un projet de construction / reconstruction / nettoyage / redémarrage. J'ai une classe Component où j'injecte des objets et une classe ModuleClass où je fournis des objets à injecter.

Quelle peut être la cause de la non génération de la classe Dagger Component .

EDITAR:

C'est ma ModuleClass, annotée avec @Module :

@Provides
@Singleton
public Interceptor provideInterceptor() {
    return new Interceptor() {
        @Override
        public Response intercept(Chain chain) throws IOException {
            Request.Builder builder = chain.request().newBuilder();

            builder.addHeader("AppName-Android", BuildConfig.VERSION_NAME + "-" + BuildConfig.VERSION_CODE)
                    .addHeader("Content-Type", "application/json");

            return chain.proceed(builder.build());
        }
    };
}

@Provides
@Singleton
OkHttpClient provideOkHttpClient(Interceptor interceptor) {
    OkHttpClient.Builder builder = new OkHttpClient.Builder();
    builder.interceptors().add(interceptor);
    return builder.build();
}

@Provides
@Singleton
Retrofit provideRetrofit(OkHttpClient client) {
    return new Retrofit.Builder()
            .baseUrl(BaseApplication.getRes().getString(R.string.api_base_url))
            .addConverterFactory(GsonConverterFactory.create())
            .client(client)
            .build();
}

@Provides
@Singleton
WebServiceCall provideWebService(Retrofit retrofit) {
    return retrofit.create(WebServiceCall.class);
}

Et voici ma classe de composants :

@Component(modules = ModuleClass.class)
@Singleton
public interface ComponentClass {

    void inject(Interceptor o);
    void inject(OkHttpClient o);
    void inject(Retrofit o);
    void inject(WebServiceCall o);

}

Answer 1

Lorsque vous développez sur Kotlin, vous devez ajouter les lignes suivantes à côté de leur annotationProcessor contreparties :

kapt 'com.google.dagger:dagger-android-processor:2.15'
kapt 'com.google.dagger:dagger-compiler:2.15'

et ajouter apply plugin: 'kotlin-kapt' au début du même fichier.

Cette section ressemble à ceci pour moi :

apply plugin: 'com.android.application'
apply plugin: 'kotlin-android'
apply plugin: 'kotlin-kapt' // <- Add this line
apply plugin: 'io.fabric'

Answer 2

Mise à jour (29 mars 2020)

Dans votre au niveau de l'application build.gradle à l'intérieur de dependencies ajoutez ces lignes :

     //dagger2
     api 'com.google.dagger:dagger:2.24'
     api 'com.google.dagger:dagger-android:2.24'
     api 'com.google.dagger:dagger-android-support:2.24'

     annotationProcessor 'com.google.dagger:dagger-compiler:2.24'
     kapt 'com.google.dagger:dagger-compiler:2.24'

     annotationProcessor 'com.google.dagger:dagger-android-processor:2.24'
     kapt 'com.google.dagger:dagger-android-processor:2.24'

     compileOnly 'javax.annotation:jsr250-api:1.0'
     implementation 'javax.inject:javax.inject:1'

À l'intérieur de android bloc de au niveau de l'application build.gradle ,

kapt {
        generateStubs = true
    }

Au top de la au niveau de l'application build.gradle Faites-le dans exactement en dessous de la commande .

apply plugin: 'com.android.application'
apply plugin: 'kotlin-android'
apply plugin: 'kotlin-kapt'
apply plugin: 'kotlin-android-extensions'

Enfin, vous devez configurer le processus d'annotation comme indiqué dans la capture d'écran ci-dessous. Vous pouvez faire ceci File>Other Settings>Settings for New Projects> recherche "Annotation processor"

Après cela, faites à partir du Menu Build > Rebuild . Vous avez terminé !

Test :

@Component
public interface ApplicationComponent {

}

Maintenant, vous pouvez utiliser DaggerApplicationComponent qui a été généré au moment de la compilation pour votre interface ApplicationComponent.

public class MyApplication extends Application {

    ApplicationComponent applicationComponent = DaggerApplicationComponent.create();

}

Answer 3

Peut-être avez-vous oublié d'annoter ModuleClass avec @Module ?

Answer 4

Si vous avez plusieurs modules dans votre AndroidStudio (modules en termes d'Android Studio, pas de Dagger), une autre raison possible de l'échec est que vous avez oublié de mettre les processeurs d'annotation dans le tous les modules'. build.gradle .

Nous avons divisé notre application en plusieurs modules, mis à jour les dépendances de l'utilisation de implementation à l'utilisation api mais a oublié de gérer les processeurs d'annotations en conséquence.

Ainsi, vous ne pouvez avoir ces lignes que dans un module racine :

api 'com.google.dagger:dagger-android:2.16'
// if you use the support libraries
api 'com.google.dagger:dagger-android-support:2.16'

Mais ceux-ci doivent être spécifiés dans les dépendances de tous les modules :

annotationProcessor 'com.google.dagger:dagger-compiler:2.16'
// if you use injections to Android classes
annotationProcessor 'com.google.dagger:dagger-android-processor:2.16'

Answer 5

Il y a quelques erreurs/manques mineurs dans votre code ci-dessus, voici une implémentation qui fonctionne :

Application.java :

component = DaggerComponentClass.builder().classModule(new ModuleClass()).build();

La classe générée sera nommée DaggerComponentClass pas DaggerCompClassComponent . Si vous ne pouvez pas exécuter votre application dans Android Studio pour la faire construire, essayez Build->Clean project et Build->Rebuild project dans le menu. Si tout est OK, Dagger aura compilé DaggerComponentClass qui sera situé dans le même paquet que ComponentClass .

ComponentClass.java :

@Component(modules = ModuleClass.class)
public interface ComponentClass {
    void inject(AClassThatShouldGetInstancesInjected instance);
}

Un composant dans Dagger2 possède des méthodes nommées inject qui reçoivent l'instance pour y faire injecter des instances, et non l'inverse. Dans le code ci-dessus, la classe AClassThatShouldGetInstancesInjected appelle généralement componentClass.inject(this); pour se faire injecter des instances.

ModuleClass.java :

@Module
public class ModuleClass {
    @Provides
    @Singleton
    public Interceptor provideInterceptor() {/*code*/}

    //Your Providers...
}

Le module est correct dans votre code, assurez-vous qu'il est annoté.