71

In my module, in my base Application class

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

it can not find DaggerCompClassComponent.

I have on 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'

and in Project build.gradle,

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

I have done build / rebuild / clean / restart project. I have a Component class where I inject objects and a ModuleClass where I provide objects to inject.

What can be the cause for not generating Dagger Component . class ?

EDIT:

This is my ModuleClass, adnotated with @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);
}

And this is my Component Class:

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

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

}
ghita
  • 2,746
  • 7
  • 30
  • 54

17 Answers17

139

When developing on Kotlin, you should add the following lines next to their annotationProcessor counterparts:

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

and add apply plugin: 'kotlin-kapt' at the start of the same file.

That section looks like this for me:

apply plugin: 'com.android.application'
apply plugin: 'kotlin-android'
apply plugin: 'kotlin-kapt' // <- Add this line
apply plugin: 'io.fabric'
Gonzalo
  • 3,674
  • 2
  • 26
  • 28
45

Update (March 29, 2020)

Inside your app-level build.gradle inside dependencies block, add these lines:

     //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'

Inside android block of app-level build.gradle,

kapt {
        generateStubs = true
    }

At the top of the app-level build.gradle, Do this in exactly below order.

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

Finally, You need to configure Annotation Process as provided in the screenshot below. You can do this File>Other Settings>Settings for New Projects>search"Annotation processor" enter image description here

After this, do from Menu Build > Rebuild. You are done!

Test:

@Component
public interface ApplicationComponent {

}

Now, you can use DaggerApplicationComponent that was generated at compile-time for your ApplicationComponent interface.

public class MyApplication extends Application {

    ApplicationComponent applicationComponent = DaggerApplicationComponent.create();


}
Boken
  • 4,825
  • 10
  • 32
  • 42
Uddhav P. Gautam
  • 7,362
  • 3
  • 47
  • 64
  • 6
    The correct path to allow "annotation processor" on Windows is File -> Other Settings -> Settings for new projects... – peresisUser Feb 13 '19 at 21:10
8

Maybe you forgot to annotate ModuleClass with @Module ?

Alex Shutov
  • 3,217
  • 2
  • 13
  • 11
5

If you have several modules in your AndroidStudio (modules in terms of Android Studio, not Dagger), another possible reason of fail is that you've forgot to put annotation processors into the all modules' build.gradle.

We've divided our app into several modules, updated dependencies from using implementation to using api but forgot to handle annotation processors accordingly.

So, you can have this lines only in a root module:

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

But this ones should be specified in all modules dependencies:

annotationProcessor 'com.google.dagger:dagger-compiler:2.16'
// if you use injections to Android classes
annotationProcessor 'com.google.dagger:dagger-android-processor:2.16'
Gaket
  • 6,533
  • 2
  • 37
  • 67
3

If Dagger2 can not generate its components it means that your code have some errors with Scopes/Modules. Check our your @Provides/Inject methods.

UPD:

You should inject your components into cases where you need instances of classes provided by module.

like

inject(MainActivity main);
Anton Kazakov
  • 2,740
  • 3
  • 23
  • 34
  • 1
    @hackingforgirls void inject(Interceptor o); void inject(OkHttpClient o); void inject(Retrofit o); void inject(WebServiceCall o); what the point of it? – Anton Kazakov May 03 '17 at 09:57
  • @hackingforgirls you should inject your components into classes where you want module instances injected – Anton Kazakov May 03 '17 at 09:57
  • I have injected the dependences that I need in my project. Why should I delete them? – ghita May 03 '17 at 10:54
  • @hackingforgirls as I said void inject(Interceptor o); void inject(OkHttpClient o); void inject(Retrofit o); void inject(WebServiceCall o); is totally wrong and make no sense at all. Read some tutorials how to use Dagger 2 – Anton Kazakov May 03 '17 at 11:05
  • @AntonKazakov it is used to expose those objects to those who might need them as dependencies. – Hohenheim Oct 03 '17 at 03:29
  • @Hohenhiem module class do it, but not the component – Anton Kazakov Oct 03 '17 at 05:39
  • 1
    @AntonKazakov `@Provides` are used inside the module, but if you want to expose an object to another component, that is the time you declare the interface method that expose that object. – Hohenheim Oct 03 '17 at 06:11
3

In build.gradle's app, you need to add necessary dependencies for Dagger to generate corresponding classes, as below:

  implementation 'com.google.dagger:dagger-android:2.21'
  implementation 'com.google.dagger:dagger-android-support:2.21' // if you use the support libraries
  annotationProcessor 'com.google.dagger:dagger-android-processor:2.21'
  annotationProcessor 'com.google.dagger:dagger-compiler:2.21'

you should change dagger version which you are using.

refer full dagger document in this

Mr Special
  • 1,576
  • 1
  • 20
  • 33
3

For anyone doing this in the year 2022 on Android Studio, if you want to just use some Dagger capabilities, you only need to add this in your Gradle dependencies:

implementation 'com.google.dagger:dagger:2.41'
kapt 'com.google.dagger:dagger-compiler:2.41'

then this on your plugins:

id 'kotlin-kapt'

You don't need to add anything else.

Now here's the key step: You need to do a clean (either in Gradle or just select Clean Project under Build menu) because for some reason incremental compilation is getting in the way.

Then rebuild your project.

If you created your Dagger components correctly you should see compilation errors at this point, or if you created them correctly the auto-completion with your component(s) should now work in the code editor.

Dexter Legaspi
  • 3,192
  • 1
  • 35
  • 26
2

There are some minor misconceptions/faults in your code above, here's a working implementation:

Application.java:

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

The generated class will be named DaggerComponentClass, not DaggerCompClassComponent. If you can't run your app in Android Studio to get it built, try Build->Clean project and Build->Rebuild project in the menu. If everything is OK Dagger will have compiled DaggerComponentClass which will be located in the same package as ComponentClass.

ComponentClass.java:

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

A Component in Dagger2 has methods named inject that receive the instance to get instances injected into it, not the other way around. In the code above the class AClassThatShouldGetInstancesInjected will typically call componentClass.inject(this); to get instances injected into itself.

ModuleClass.java:

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

    //Your Providers...
}

The Module is correct in your code, make sure its annotated.

Pär Nils Amsen
  • 755
  • 5
  • 16
  • `I removed @Singleton from ComponentClass since it's an annotation that is only relevant for modules.` um, no? – EpicPandaForce May 03 '17 at 10:15
  • EpicPandaForce Might be a wrong assumption, but from what I've seen in the documentation @Singleton isn't used in Components – Pär Nils Amsen May 03 '17 at 10:21
  • now you've actually made me uncertain, but i think applying scope on the component makes it a "scoped component" which will make it see all `@Singleton` annotated classes with `@Inject` constructor, and it is in a lot of examples you can find lingering around here http://stackoverflow.com/a/40751767/2413303 but maybe we were all wrong, haha – EpicPandaForce May 03 '17 at 10:28
  • 1
    I added strike-through over that part! I found a use of `@Singleton` in Components in the *new* official docs for Dagger2 https://google.github.io/dagger/subcomponents.html so guess you're right ;) – Pär Nils Amsen May 03 '17 at 10:46
  • @PärNilsAmsen I don;t get what is the change you suggest. What I have to modify? – ghita May 03 '17 at 10:48
  • @Singleton is just Dagger2 scope, but its predefined. Scopes defines lifetime of components and their modules. – Anton Kazakov May 03 '17 at 11:11
  • @hackingforgirls improved the answer somewhat to make it clearer. It's pretty much the basic implementation from the docs now, `AClassThatShouldGetInstancesInjected` is typically your Activity that wants to get injected by Dagger. – Pär Nils Amsen May 03 '17 at 13:23
  • In my case, my ComponentClass was named DaggerMainComponent. I didn't notice that I misspelled the name when building it in my Application class. –  Sep 16 '18 at 02:34
2

If you are using Kotlin, make sure to add kapt (Kotlin annotation processor) Gradle plugin to your build script and use kapt Gradle dependency type instead of annotationProcessor for Dagger Compiler.

apply plugin: 'kotlin-kapt

kapt deps.daggercompiler
implementation deps.dagger
Javad
  • 5,755
  • 4
  • 41
  • 51
2
api 'com.google.dagger:dagger-android:2.28.3'
api 'com.google.dagger:dagger-android-support:2.28.3'
annotationProcessor 'com.google.dagger:dagger-android-processor:2.28.3'

Replace above with below dependencies in app level dependencies, if you have used above

api 'com.google.dagger:dagger:2.28.3'
annotationProcessor 'com.google.dagger:dagger-compiler:2.28.3'
Manoj Behera
  • 2,736
  • 22
  • 13
1

I solved it by editing my dagger dependencies to this:

 implementation "com.google.dagger:dagger:${versions.dagger}"
 kapt "com.google.dagger:dagger-compiler:${versions.dagger}"
nima
  • 55
  • 1
  • 9
1

As Accepted Answer does NOT work for me:

This issue is related to Android Studio (V4.1.2 and up) and you can fix it by doing the below steps:

Pref -> Editor -> File Types -> Ignore Files And Folders -> Remove "Dagger*.java;" Also If you see other Dagger regexs, remove them too.

Now android studio will find generated component class.

Alireza Akbari
  • 2,153
  • 2
  • 28
  • 53
0

In my case it wasn't being created only in Instrumentation Testing, because I was missing

kaptAndroidTest "com.google.dagger:dagger-compiler:$rootProject.daggerVersion"

Of course I'm using Kotlin and $rootProject.daggerVersion is a property on my base build file. You can replace for whatever version or gradle dependency you desire and are missing.

Chisko
  • 3,092
  • 6
  • 27
  • 45
0

Try this worked for me with Kotlin. Just this much in build.gradle (Module YourProject.app)

plugins {
    id 'com.android.application'
    id 'org.jetbrains.kotlin.android'
    id 'kotlin-kapt'
}

dependencies {
    .....
    implementation 'com.google.dagger:dagger-android:2.35.1'
    kapt 'com.google.dagger:dagger-compiler:2.15'
    implementation 'javax.inject:javax.inject:1'
    .....
}
Anirudh R.Huilgol.
  • 839
  • 1
  • 15
  • 16
0

If you have many modules in one project, you can choose to generate Dagger2 classes for one module by using below command.

./gradlew <module-name>:kaptDebugKotlin

flamyoad
  • 519
  • 7
  • 15
0

If all of the aforementioned solutions doesn't work and you can't still see any generated DaggerComponent:

Sometime the issue is deceptive. It comes from Android Studio that generates the sources as expected in the build folder but doesn't refresh this folder, your sources does what has changed in the build folder.

You'll have to manually force Android Studio to reload the sources from Disk . You can achieve that by finding the appropriate action or right clicking on the incriminated module.

enter image description here

enter image description here

SebVay
  • 141
  • 1
  • 5
-2
//add all the dependencies otherwise component class will not be generated.
implementation 'com.google.dagger:dagger-android:2.21'
implementation 'com.google.dagger:dagger-android-support:2.21'
annotationProcessor 'com.google.dagger:dagger-android-processor:2.21'
implementation 'com.google.dagger:dagger:2.21'
annotationProcessor 'com.google.dagger:dagger-compiler:2.21'
sudhanshu
  • 409
  • 1
  • 5
  • 12