Dagger 2 is around the corner but the available examples wouldn&#39;t even compile right off the box, and the documentation is a copy-paste-replace from Dagger 1.

Does anyone have an example of a proper application working on Google&#39;s Dagger 2?

Dagger 2 examples

I have an Android app that uses Dagger 2 for dependency injection. I am also using the latest gradle build tools that allow a build variant for unit testing and one for instrumentation tests. I am using `java.util.Random` in my app, and I want to mock this for testing. The classes I&#39;m testing don&#39;t use any Android stuff, so they&#39;re just regular java classes.

In my main code I define a `Component` in a class that extends the `Application` class, but in the unit tests I&#39;m not using an `Application`. I tried defining a test `Module` and `Component`, but Dagger won&#39;t generate the `Component`. I have also tried using the `Component` that I defined in my application and swapping the `Module` when I build it, but the application&#39;s `Component` doesn&#39;t have `inject` methods for my test classes. How can I provide a mock implementation of `Random` for testing?

Here&#39;s some sample code:

Application:

    public class PipeGameApplication extends Application {
    
        private PipeGame pipeGame;
    
        @Singleton
        @Component(modules = PipeGameModule.class)
        public interface PipeGame {
            void inject(BoardFragment boardFragment);
            void inject(ConveyorFragment conveyorFragment);
        }
    
        @Override
        public void onCreate() {
            super.onCreate();
            pipeGame = DaggerPipeGameApplication_PipeGame.create();
        }
    
        public PipeGame component() {
            return pipeGame;
        }
    }

Module:

    @Module
    public class PipeGameModule {
    
        @Provides
        @Singleton
        Random provideRandom() {
            return new Random();
        }
    }

Base class for tests:


    public class BaseModelTest {
    
        PipeGameTest pipeGameTest;
    
        @Singleton
        @Component(modules = PipeGameTestModule.class)
        public interface PipeGameTest {
            void inject(BoardModelTest boardModelTest);
            void inject(ConveyorModelTest conveyorModelTest);
        }
    
        @Before
        public void setUp() {
            pipeGameTest = DaggerBaseModelTest_PipeGameTest.create(); // Doesn&#39;t work
        }
    
        public PipeGameTest component() {
            return pipeGameTest;
        }
    }

or:

    public class BaseModelTest {
    
        PipeGameApplication.PipeGame pipeGameTest;
    
        // This works if I make the test module extend
        // the prod module, but it can&#39;t inject my test classes
        @Before
        public void setUp() {
            pipeGameTest = DaggerPipeGameApplication_PipeGame.builder().pipeGameModule(new PipeGameModuleTest()).build();
        }
    
        public PipeGameApplication.PipeGame component() {
            return pipeGameTest;
        }
    }

Test Module:

    @Module
    public class PipeGameTestModule {
    
        @Provides
        @Singleton
        Random provideRandom() {
            return mock(Random.class);
        }
    }

Android Unit Tests with Dagger 2

From the dagger 2 [Documentation][1] I noticed that you can have a `@Singleton` annotated class. What is the purpose of marking a class as `@Singleton` as I have tried to do this in my code but a singleton object is NOT produced. I&#39;m not clear on what use marking my class with this annotation serves.  

From the documentation please focus on the following statement:

&gt; The @Singleton annotation on an injectable class also serves as
&gt; documentation. It reminds potential maintainers that this class may be
&gt; shared by multiple threads.*

```java  
@Singleton
class CoffeeMaker {
    // ...
}
```

  [1]: http://google.github.io/dagger/

UPDATE: After reviewing froger_mcs answer I see that in Dagger 2 you can provide injections either by a module OR by a constructor injection. So the following class, although not in a module, can be injected:


```java
@Singleton
public class MyClass {
    @Inject
    public MyClass() {
    
    }
}
```

In this version the constructor is injected for us and in an Android activity you would just do the following and it will get provided:

```java
@Inject
MyClass myClass;
//then in onCreate actually inject(this) from your graph of course.
```


Dagger 2 - what is the purpose of a @Singleton annotation class

I am using Dagger 2 and have it working however I now need access to the **Android Application Context**. 

Its not clear to me how to inject and get access to the context. I have tried to do this as follows:
 

      
    @Module
    public class MainActivityModule {    
        private final Context context;
        
        MainActivityModule(Context context) {
            this.context = context;
        }
    
        @Provides @Singleton
        Context provideContext() {
            return context;
        }
    }
    

However this results in the following exception:

&gt; java.lang.RuntimeException: Unable to create application : java.lang.IllegalStateException: mainActivityModule must be set

If I inspect the Dagger generated code this exception is raised here: 

    public Graph build() {  
        if (mainActivityModule == null) {
            throw new IllegalStateException(&quot;mainActivityModule must be set&quot;);
        }
        return new DaggerGraph(this);
    }

I am not sure if this is the correct way to get Context injected - any help will be greatly appreciated.
 

Dagger 2 injecting Android Application Context

I&#39;m having a problem in understanding why the following code doesn&#39;t work.

I have following project structure:

    @Component(modules = CCModule.class) 
    public interface CComponent {
        XXX getXXX();
    }

where 

    @Module
    public class CCModule {

        @Provides @Singleton
        public XXX provide XXX(){
            return new XXX();
        }
    }

and 

    @Component(dependencies = CComponent.class, modules = AAModule.class) 
    public interface AComponent {
        YYY getYYY();
    }

where

    class YYY {
       @Inject
       public YYY(XXX xxx) {
           ...
       }
    }

I initialize everything as:

    CComponent c_component = Dagger_CComponent.builder().cCModule(new CCModule()).build();

    AComponent a_component = Dagger_AComponent.builder()
            .cComponent(c_component)
            .aAModule(new AAModule())
            .build();

Once compilation takes place i get the following error:

&gt; Error:(11, 1) error:
&gt; com.test.CComponent (unscoped) may not
&gt; reference scoped bindings: @Provides @Singleton
&gt; com.test.XXX
&gt; com.test.CCModule.provideXXX()

What I&#39;m aiming for is to have one component inherit bindings from other components to have the same references to an objects (singletons).

Problems with singletons when using component dependencies

I am not certain on the purpose for Dagger2&#39;s [@Bind annotation.][1]  


From what i have read online im still not clear but here is an example:

    @Module
    public abstract class HomeModule {
    
      @Binds
      public abstract HomePresenter bindHomePresenter(HomePresenterImp   
        homePresenterImp);
    }


and the class definitions look like this:

    public interface HomePresenter {
        Observable&lt;List&lt;User&gt;&gt; loadUsers();
    }

    public class HomePresenterImp implements HomePresenter {

        public HomePresenterImp(){
        }  

        @Override
        public Observable&lt;List&lt;User&gt;&gt; loadUsers(){
            //Return user list observable
        }
    }

why would i need to use @Binds if i can just use provides annotation as follows:

    @Provides
    public HomePresenter provideHomePresenter() {
        return new HomePresenterImp();
    }



what is the usecase for @Binds instead of @Provides ? if i use @Binds do i still need to declare it in my appcomponent (its an abstract class when i use @Binds)?


  [1]: https://google.github.io/dagger/api/2.13/dagger/Binds.html

What is the use case for @Binds vs @Provides annotation in Dagger2

From the [User&#39;s Guide][1]:

&gt; Sometimes you want to limit the number of times an @Inject-constructed
&gt; class is instantiated or a @Provides method is called, but you don’t
&gt; need to guarantee that the exact same instance is used during the
&gt; lifetime of any particular component or subcomponent.

Why would I use that instead of `@Singleton`?

  [1]: http://google.github.io/dagger/users-guide.html

Dagger @Reusable scope vs @Singleton

I have a ViewModel class just like the one defined in the **Connecting ViewModel and repository** section of [Architecture guide][1]. When I run my app I get a runtime exception. Does anyone know how to get around this? Should I not be injecting the ViewModel? Is there a way to tell the `ViewModelProvider` to use Dagger to create the model?


&lt;!-- language: lang-java --&gt;

    public class DispatchActivityModel extends ViewModel {

        private final API api;

        @Inject
        public DispatchActivityModel(API api) {
            this.api = api;
        }
    }

&gt;    Caused by: java.lang.InstantiationException: java.lang.Class&lt;com.example.dispatch.DispatchActivityModel&gt; has no zero argument constructor
        at java.lang.Class.newInstance(Native Method)
        at android.arch.lifecycle.ViewModelProvider$NewInstanceFactory.create(ViewModelProvider.java:143)
        at android.arch.lifecycle.ViewModelProviders$DefaultFactory.create(ViewModelProviders.java:143)&#160;
        at android.arch.lifecycle.ViewModelProvider.get(ViewModelProvider.java:128)&#160;
        at android.arch.lifecycle.ViewModelProvider.get(ViewModelProvider.java:96)&#160;
        at com.example.base.BaseActivity.onCreate(BaseActivity.java:65)&#160;
        at com.example.dispatch.DispatchActivity.onCreate(DispatchActivity.java:53)&#160;
        at android.app.Activity.performCreate(Activity.java:6682)&#160;
        at android.app.Instrumentation.callActivityOnCreate(Instrumentation.java:1118)&#160;
        at android.app.ActivityThread.performLaunchActivity(ActivityThread.java:2619)        at android.app.ActivityThread.handleLaunchActivity(ActivityThread.java:2727)&#160;
        at android.app.ActivityThread.-wrap12(ActivityThread.java)&#160;
        at android.app.ActivityThread$H.handleMessage(ActivityThread.java:1478)&#160;
        at android.os.Handler.dispatchMessage(Handler.java:102)&#160;
        at android.os.Looper.loop(Looper.java:154)&#160;
        at android.app.ActivityThread.main(ActivityThread.java:6121)

  [1]: https://developer.android.com/topic/libraries/architecture/guide.html

Android lifecycle library ViewModel using dagger 2

I use Dagger2 for DI in my android application. I found that I have to write inject method for every class that uses @Inject field. Is there a way that I can just inject the parent class so that I don&#39;t have to call inject on every subclass?
Take Activity for example. I have a `BaseActivity` that that every Activity extends from. Is there a way that I can just create an inject method in the component for BaseActivity and just call inject in BaseActivity&#39;s onCreate, and @inject fields in sub activities get injected automatically?


Can I just inject super class when use dagger2 for dependency injection?

I have Google this problem, but the results are not work for me.

The detail as following.
```java
    public final class App extends com.zhixin.wedeep.common.BaseApplication implements androidx.lifecycle.LifecycleOwner {
                 ^
     // Expected @HiltAndroidApp to have a value. Did you forget to apply the Gradle Plugin?

```
The App code.

```kotlin
@HiltAndroidApp
class App : BaseApplication(), LifecycleOwner {

    @Inject
    lateinit var service: EventService


    private val mLifecycleRegistry = LifecycleRegistry(this)

}


```
This module gradle file.
```
apply plugin: &#39;kotlin-kapt&#39;
apply plugin: &#39;kotlin-allopen&#39;
apply plugin: &#39;androidx.navigation.safeargs.kotlin&#39;
apply plugin: &#39;dagger.hilt.android.plugin&#39;

dependencies {
    implementation rootProject.ext.dependencies[&quot;hilt-android&quot;]
    implementation rootProject.ext.dependencies[&quot;hilt-lifecycle-viewmodel&quot;]
    kapt rootProject.ext.kapt[&quot;hilt-compiler&quot;]
    kapt rootProject.ext.kapt[&quot;hilt-android-compiler&quot;]
}
```
Who has ideas? Thanks!

Expected @HiltAndroidApp to have a value. Did you forget to apply the Gradle Plugin?

I am trying to implement MVVM pattern in my android app. I have read that ViewModels should contain no android specific code (to make testing easier), however I need to use context for various things (getting resources from xml, initializing preferences, etc). What is the best way to do this? I saw that `AndroidViewModel` has a reference to the application context, however that contains android specific code so I&#39;m not sure if that should be in the  ViewModel. Also those tie into the Activity lifecycle events, but I am using dagger to manage the scope of components so I&#39;m not sure how that would affect it. I am new to the MVVM pattern and Dagger so any help is appreciated!

How to get Context in Android MVVM ViewModel

Dagger 1&#39;s `plus()` method is something I used quite often in previous applications, so I understand situations where you might want to have a subcomponent with full access to the parent graphs bindings.

In what situation would it be beneficial to use a *component dependency* instead of a *subcomponent dependency* and why? 

Dagger 2 subcomponents vs component dependencies

I&#39;m trying to wrap my head around scopes in Dagger 2, specifically the lifecycle of scoped graphs. How do you create a component that will be cleaned up when you leave the scope.

In the case of an Android application, using Dagger 1.x you generally have a root scope at the application level which you&#39;d extend to create a child scope at the activity level.

    public class MyActivity {

        private ObjectGraph mGraph;

        public void onCreate() {
            mGraph = ((MyApp) getApplicationContext())
                .getObjectGraph()
                .plus(new ActivityModule())
                .inject(this);
        }

        public void onDestroy() {
            mGraph = null;
        }
    }

The child scope existed as long as you kept a reference to it, which in this case was the lifecycle of your Activity. Dropping the reference in onDestroy ensured the scoped graph was free to be garbage collected.

**EDIT**

Jesse Wilson recently posted a [mea culpa](https://publicobject.com/2014/11/15/dagger-2-has-components/)

&gt; Dagger 1.0 badly screwed up its scope names ... The @Singleton annotation is used for both root graphs and custom graphs, so it&#39;s tricky to figure out what the actual scope of a thing is.

and everything else I&#39;ve read/heard points towards Dagger 2 improving the way scopes work, but I&#39;m struggling to understand the difference. According to @Kirill Boyarshinov&#39;s comment below, the lifecycle of a component or dependency is still determined, as usual, by concrete references. So is the difference between Dagger 1.x and 2.0 scopes purely a matter of semantic clarity?

## My understanding

### Dagger 1.x

Dependencies were either `@Singleton` or not. This was equally true of dependencies in the root graph and subgraphs, leading to ambiguity as to which graph the dependency was bound to (see https://stackoverflow.com/questions/25953525/in-dagger-are-singletons-within-the-sub-graph-cached-or-will-they-always-be-recr)

### Dagger 2.0

Custom scopes allow you to create semantically clear scopes, but are functionally equivalent to applying `@Singleton` in Dagger 1.x.

    // Application level
    @Singleton
    @Component( modules = MyAppModule.class )
    public interface MyAppComponent {
        void inject(Application app);
    }

    @Module
    public class MyAppModule {

        @Singleton @Named(&quot;SingletonScope&quot;) @Provides
        StringBuilder provideStringBuilderSingletonScope() {
            return new StringBuilder(&quot;App&quot;);
        }
    }

---

    // Our custom scope
    @Scope public @interface PerActivity {}

---

    // Activity level
    @PerActivty
    @Component(
        dependencies = MyAppComponent.class,
        modules = MyActivityModule.class
    )
    public interface MyActivityComponent {
        void inject(Activity activity);
    }

    @Module
    public class MyActivityModule {

        @PerActivity @Named(&quot;ActivityScope&quot;) @Provides
        StringBuilder provideStringBuilderActivityScope() {
            return new StringBuilder(&quot;Activity&quot;);
        }

        @Name(&quot;Unscoped&quot;) @Provides
        StringBuilder provideStringBuilderUnscoped() {
            return new StringBuilder(&quot;Unscoped&quot;);
        }
    }

---

    // Finally, a sample Activity which gets injected
    public class MyActivity {

        private MyActivityComponent component;

        @Inject @Named(&quot;AppScope&quot;)
        StringBuilder appScope

        @Inject @Named(&quot;ActivityScope&quot;)
        StringBuilder activityScope1

        @Inject @Named(&quot;ActivityScope&quot;)
        StringBuilder activityScope2

        @Inject @Named(&quot;Unscoped&quot;)
        StringBuilder unscoped1

        @Inject @Named(&quot;Unscoped&quot;)
        StringBuilder unscoped2

        public void onCreate() {
            component = Dagger_MyActivityComponent.builder()
                .myApplicationComponent(App.getComponent())
                .build()
                .inject(this);

            appScope.append(&quot; &gt; Activity&quot;)
            appScope.build() // output matches &quot;App (&gt; Activity)+&quot; 

            activityScope1.append(&quot;123&quot;)
            activityScope1.build() // output: &quot;Activity123&quot;

            activityScope2.append(&quot;456&quot;)
            activityScope1.build() // output: &quot;Activity123456&quot;

            unscoped1.append(&quot;123&quot;)
            unscoped1.build() // output: &quot;Unscoped123&quot;

            unscoped2.append(&quot;456&quot;)
            unscoped2.build() // output: &quot;Unscoped456&quot;

        }

        public void onDestroy() {
            component = null;
        }

    }

The takeaway being that using `@PerActivity` communicates your *intention* regarding the lifecycle of this component, but ultimately you can use the component anywhere/anytime. Dagger&#39;s only promise is that, for a given component, scope annotated methods will return a single instance. I also assume Dagger 2 uses the scope annotation on the component to verify that modules only provide dependencies that are either in the same scope or non-scoped.

### In Summary

Dependencies are still either singleton or non-singleton, but `@Singleton` is now intended for application-level singleton instances and custom scopes are the preferred method for annotating singleton dependencies with a shorter lifecycle.

The developer is responsible for managing the lifecycle of components/dependencies by dropping references that are no longer needed and responsible for ensuring that components are only created once in the scope for which they are intended, but custom scope annotations make it easier to identify that scope.

## The $64k Question*

Is my understanding of Dagger 2 scopes and lifecycles correct?

*\* Not actually a $64&#39;000 question.*

What determines the lifecycle of a component (object graph) in Dagger 2?

I am getting the following error while building the project. haven&#39;t used CoordinatorLayout in this project. just added as a dependency in build.gradle : 

I am using Android Studio 3.2 Canary 4.

**LogCat**

&gt;AGPBI: {&quot;kind&quot;:&quot;error&quot;,&quot;text&quot;:&quot;Program type already present: android.support.design.widget.CoordinatorLayout$Behavior&quot;,&quot;sources&quot;:[{}],&quot;tool&quot;:&quot;D8&quot;}
:app:transformDexArchiveWithExternalLibsDexMergerForDebug FAILED
FAILURE: Build failed with an exception.
* What went wrong:
Execution failed for task &#39;:app:transformDexArchiveWithExternalLibsDexMergerForDebug&#39;.

&gt; com.android.builder.dexing.DexArchiveMergerException: Error while merging dex archives: /windows/Other/app/build/intermediates/transforms/dexBuilder/debug/0.jar, /windows/Other/app/build/intermediates/transforms/dexBuilder/debug/1.jar, /windows/Other/app/build/intermediates/transforms/dexBuilder/debug/4.jar, 
&gt;  .
.
...................

&gt;/windows/Other/app/build/intermediates/transforms/dexBuilder/debug/294.jar

 &gt; Program type already present: android.support.design.widget.CoordinatorLayout$Behavior

**build.gradle**

    apply plugin: &#39;com.android.application&#39;

    apply plugin: &#39;kotlin-android&#39;

    apply plugin: &#39;kotlin-android-extensions&#39;
    apply plugin: &#39;kotlin-kapt&#39;

    android {
        compileSdkVersion 27
        buildToolsVersion &quot;27.0.3&quot;
        defaultConfig {
            applicationId &quot;com.dagkot&quot;
            minSdkVersion 16
            targetSdkVersion 27
            versionCode 1
            versionName &quot;1.0&quot;
            testInstrumentationRunner &quot;android.support.test.runner.AndroidJUnitRunner&quot;
        }
        buildTypes {
            release {
                minifyEnabled false
                proguardFiles getDefaultProguardFile(&#39;proguard-android.txt&#39;), &#39;proguard-rules.pro&#39;
                buildConfigField &quot;String&quot;, &quot;BASE_URL&quot;, &quot;\&quot;http://api.openweathermap.org/data/2.5/\&quot;&quot;
                buildConfigField &quot;String&quot;, &quot;API_KEY&quot;, &quot;\&quot;435e9075f348868c2714fe7c6895efa5\&quot;&quot;
            }
            debug {
            minifyEnabled false
            proguardFiles getDefaultProguardFile(&#39;proguard-android.txt&#39;), &#39;proguard-rules.pro&#39;
            buildConfigField &quot;String&quot;, &quot;BASE_URL&quot;, &quot;\&quot;http://api.openweathermap.org/data/2.5/\&quot;&quot;
            buildConfigField &quot;String&quot;, &quot;API_KEY&quot;, &quot;\&quot;xxxx\&quot;&quot;
        }
    }
    }
    
    dependencies {
        implementation fileTree(dir: &#39;libs&#39;, include: [&#39;*.jar&#39;])
        implementation &#39;com.android.support:appcompat-v7:27.1.0&#39;
        implementation &#39;com.android.support.constraint:constraint-layout:1.0.2&#39;
        testImplementation &#39;junit:junit:4.12&#39;
        androidTestImplementation(&#39;com.android.support.test.espresso:espresso-core:3.0.1&#39;, {
            exclude group: &#39;com.android.support&#39;, module: &#39;support-annotations&#39;
        })
        implementation&quot;org.jetbrains.kotlin:kotlin-stdlib-jre7:$kotlin_version&quot;
    
    
        // Dagger dependencies
        compileOnly &#39;org.glassfish:javax.annotation:10.0-b28&#39;
        implementation &quot;com.google.dagger:dagger:$rootProject.daggerVersion&quot;
        implementation &quot;com.google.dagger:dagger-android:$rootProject.daggerVersion&quot;
        implementation &quot;com.google.dagger:dagger-android-support:$rootProject.daggerVersion&quot;
        kapt &quot;com.google.dagger:dagger-android-processor:$rootProject.daggerVersion&quot;
        kapt &quot;com.google.dagger:dagger-compiler:$rootProject.daggerVersion&quot;
    
        //Butterknife dependencies
        implementation &#39;com.jakewharton:butterknife:8.8.1&#39;
        kapt &#39;com.jakewharton:butterknife-compiler:8.8.1&#39;
    
        // Architecture Components Dependencies
        kapt &quot;android.arch.lifecycle:compiler:$rootProject.lifeCycle&quot;
        implementation &quot;android.arch.lifecycle:extensions:$rootProject.lifeCycle&quot;
        implementation &quot;android.arch.lifecycle:reactivestreams:$rootProject.lifeCycle&quot;
        implementation &quot;com.android.support:cardview-v7:$rootProject.supportLibraryVersion&quot;
    
        // Retrofit/RxJava Dependencies
        implementation &quot;com.squareup.retrofit2:retrofit:$rootProject.retrofitVersion&quot;
        implementation &quot;com.squareup.retrofit2:adapter-rxjava2:$rootProject.retrofitVersion&quot;
        implementation &quot;com.squareup.retrofit2:converter-gson:$rootProject.retrofitVersion&quot;
        implementation &quot;io.reactivex.rxjava2:rxandroid:$rootProject.rxAndroidVersion&quot;
        implementation &#39;com.squareup.okhttp3:logging-interceptor:3.6.0&#39;
        implementation &#39;com.jakewharton.rxbinding2:rxbinding-kotlin:2.1.1&#39;
    
        // GSON
        implementation &quot;com.google.code.gson:gson:$rootProject.gsonVersion&quot;
    
        // Rx Location Manager
        implementation &#39;io.nlopez.smartlocation:library:3.3.3&#39;
        implementation &#39;io.nlopez.smartlocation:rx:3.3.1&#39;
    
        //Anko Dependencies
        implementation &quot;org.jetbrains.anko:anko-commons:$rootProject.anko_version&quot;
        implementation &quot;org.jetbrains.anko:anko-design:$rootProject.anko_version&quot;
        implementation &#39;com.android.support:design:27.0.2&#39;
    
        implementation(&quot;com.github.hotchemi:permissionsdispatcher:3.1.0&quot;) {
            // if you don&#39;t use android.app.Fragment you can exclude support for them
            exclude module: &quot;support-v13&quot;
        }
        kapt &quot;com.github.hotchemi:permissionsdispatcher-processor:3.1.0&quot;
    }





Error : Program type already present: android.support.design.widget.CoordinatorLayout$Behavior

How to use Dagger? How to configure Dagger to work in my Android project?

I&#39;d like to use Dagger in my Android project, but I find it confusing.

EDIT: Dagger2 is also out since 2015 04 15, and it&#39;s even more confusing!


*[This question is a &quot;stub&quot; on which I am adding to my answer as I learned more about Dagger1, and learn more about Dagger2. This question is more of a **guide** rather than a &quot;question&quot;.]*

How to set up DAGGER dependency injection from scratch in Android project?

I&#39;ve been working with dagger2 for a while. And I got confused wether to create an own component/module for each Activity/ Fragment. Please help me clarify this:

For example, We have an app, and the app has about 50 screens.
We will implement the code following the MVP pattern and Dagger2 for DI. Suppose that we have 50 activities and 50 presenters. 

In my opinion, usually we should organize the code like this :

1. Create an AppComponent and AppModule which will provide all objects that will be used while the app is open.

		@Module
		public class AppModule {

		    private final MyApplicationClass application;

		    public AppModule(MyApplicationClass application) {
		        this.application = application;
		    }

		    @Provides
		    @Singleton
		    Context provideApplicationContext() {
		        return this.application;
		    }

		    //... and many other providers 

		}

		@Singleton
		@Component( modules = { AppModule.class } )
		public interface AppComponent {

		    Context getAppContext();

		    Activity1Component plus(Activity1Module module);
		    Activity2Component plus(Activity2Module module);

		    //... plus 48 methods for 48 other activities. Suppose that we don&#39;t have any other Scope (like UserScope after user login, ....)

		}

2. Create ActivityScope :

		@Scope
		@Documented
		@Retention(value=RUNTIME)
		public @interface ActivityScope {
		}

3. Create Component and Module for each Activity. Usually I will put them as static classes within the Activity class:

		@Module
		public class Activity1Module {

		    public LoginModule() {
		    }
		    @Provides
		    @ActivityScope
		    Activity1Presenter provideActivity1Presenter(Context context, /*...some other params*/){
		        return new Activity1PresenterImpl(context, /*...some other params*/);
		    }

		}

		@ActivityScope
		@Subcomponent( modules = { Activity1Module.class } )
		public interface Activity1Component {
		    void inject(Activity1 activity); // inject Presenter to the Activity
		}

		// .... Same with 49 remaining modules and components.


Those are just very simple examples to show how I would implement this.

**But a friend of mine just gave me another implementation:**

1. Create PresenterModule which will provide all presenters:

		@Module
		public class AppPresenterModule {

		    @Provides
		    Activity1Presenter provideActivity1Presentor(Context context, /*...some other params*/){
		        return new Activity1PresenterImpl(context, /*...some other params*/);
		    }

		   	@Provides
		    Activity2Presenter provideActivity2Presentor(Context context, /*...some other params*/){
		        return new Activity2PresenterImpl(context, /*...some other params*/);
		    }

		    //... same with 48 other presenters.

		}


2. Create AppModule and AppComponent:


		@Module
		public class AppModule {

		    private final MyApplicationClass application;

		    public AppModule(MyApplicationClass application) {
		        this.application = application;
		    }

		    @Provides
		    @Singleton
		    Context provideApplicationContext() {
		        return this.application;
		    }

		    //... and many other provides 

		}

		@Singleton
		@Component(
		        modules = { AppModule.class,  AppPresenterModule.class }
		)
		public interface AppComponent {

		    Context getAppContext();

		    public void inject(Activity1 activity);
		    public void inject(Activity2 activity);

		    //... and 48 other methods for 48 other activities. Suppose that we don&#39;t have any other Scope (like UserScope after user login, ....)

		}


His explaination is: **He doesn&#39;t have to create components and modules for each activity.**
I think my friends idea is absolutely not good at all, but please correct me if I am wrong. Here are the reasons:

1. **A lot of memory leaks** :
 - **The app will create 50 presenters even if the user has only 2 Activities open.** 
 - **After the user closes an Activity, its presenter will still remain**

2. What happens if I want to create two instances of one Activity ? (how can he create two presenters )

3. It will take a lot of time for the app to initialize (because it has to create many presenters, objects, ...)


**Sorry for a long post, but please help me clarify this for me and my friend, I can&#39;t convince him.**
Your comments will be very appreciated.


/*-----------------------------------------------------------------------*/

Edit after doing a demo. 

First, thanks for @pandawarrior answer.
I should have created a Demo before I asked this question. I hope my conclusion here could help someone else.

1. What my friend has done does not cause memory leaks unless he puts any Scope to the Provides-methods. (For example @Singleton, or @UserScope, ...)
2. We can create many presenters, if the Provides-method doesn&#39;t have any Scope. (So, my second point is wrong, too)
3. Dagger will create the presenters only when they are needed. (So, the app will not take a long time to initialize, I was confused by Lazy Injection)

So, all the reasons I have said above are mostly wrong. But it does not mean that we should follow my friend idea, for two reasons:

1. It&#39;s not good for the source&#39;s architecture, when he inits all presenters in  module / component. (It violates [Interface segregation principle][1], maybe [Single Responsibility][2] priciple, too).

2. When we create a Scope Component, we will know when it&#39;s created and when it&#39;s destroyed which is a huge benefit for avoiding memory leaks. So, for each Activity we should create a Component with an @ActivityScope. Let&#39;s imagine, with my friends implementation, that we forgot to put some Scope in the Provider-method =&gt; memory leaks will occur.

In my opinion, with a small app (just a few screens without many dependencies or with similar dependencies), we could apply my friends idea, but of course it&#39;s not recommended.

Prefer to read more on:
https://stackoverflow.com/questions/28411352/what-determines-the-lifecycle-of-a-component-object-graph-in-dagger-2
https://stackoverflow.com/questions/35314682/dagger2-activity-scope-how-many-modules-components-do-i-need?rq=1

And one more note: If you want to see when the object are destroyed, you can call those of method together and the GC will run immediately:

        System.runFinalization();
        System.gc();

If you use only one of these methods, GC will run later, and you may get wrong results.


  [1]: https://en.wikipedia.org/wiki/Interface_segregation_principle
  [2]: https://en.wikipedia.org/wiki/Single_responsibility_principle

Dagger- Should we create each component and module for each Activity/ Fragment

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 = &quot;dagger.internal.codegen.ComponentProcessor&quot;,
      comments = &quot;https://google.github.io/dagger&quot;
    )
    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.&lt;Application&gt;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?

Dagger 2.2 component builder module method deprecated

I&#39;m trying to perform a login action using Retrofit 2.0 using Dagger 2

Here&#39;s how I set up Retrofit dependency

    @Provides
    @Singleton
    Retrofit provideRetrofit(Gson gson, OkHttpClient client) {
        Retrofit retrofit = new Retrofit.Builder()
                                .addConverterFactory(GsonConverterFactory.create(gson)
                                .client(client)
                                .baseUrl(application.getUrl())
                                .build();
        return retrofit;     
    }

Here&#39;s the API interface.

    interface LoginAPI {
       @GET(relative_path)
       Call&lt;Boolean&gt; logMe();
    }

I have three different base urls users can log into. So I can&#39;t set a static url while setting up Retrofit dependency. I created a setUrl() and getUrl() methods on Application class. Upon user login, I set the url onto Application before invoking the API call. 

I use lazy injection for retrofit like this

    Lazy&lt;Retrofit&gt; retrofit

That way, Dagger injects dependency only when I can call

    retrofit.get()

This part works well. I got the url set to retrofit dependency. However, the problem arises when the user types in a wrong base url (say, mywifi.domain.com), understands it&#39;s the wrong one and changes it(say to mydata.domain.com). Since Dagger already created the dependency for retrofit, it won&#39;t do again.
So I have to reopen the app and type in the correct url.

I read different posts for setting up dynamic urls on Retrofit using Dagger. Nothing really worked out well in my case. Do I miss anything? 

Set dynamic base url using Retrofit 2.0 and Dagger 2

I am following the guide here: https://github.com/ecgreb/dagger-2-testing-demo

I have the following setup in my app/src/main (the injection and @Provides code omitted):

    public class FlingyApplication extends Application {
        @Singleton
        @Component(modules = { FlingyModule.class })
        public interface FlingyComponent
    }

    @Module
    public class FlingyModule

In app/src/test:

    public class TestFlingyApplication extends Application {
        @Singleton
        @Component(modules = { TestFlingyModule.class })
        public interface TestFlingyComponent extends FlingyComponent
    }

    @Module
    public class TestFlingyModule

So far, it is nearly identical to the example github. When dagger goes to generate the code for the Component builders in src/main, they generate properly. Dagger does not, however, generate code for the Component builders in src/test.

My main build.gradle:

    dependencies {
        classpath &#39;com.android.tools.build:gradle:2.1.0-alpha3&#39;

        classpath &#39;com.neenbedankt.gradle.plugins:android-apt:1.5.1&#39;
    }

My app/build.gradle

    apply plugin: &#39;com.android.application&#39;
    apply plugin: &#39;com.neenbedankt.android-apt&#39;

    
    android {
        # There is obviously more in here, but this is the custom part:
        packagingOptions {
            exclude &#39;META-INF/services/javax.annotation.processing.Processor&#39;
        }
    }

    dependencies {
        compile &#39;com.squareup:otto:1.3.8&#39;
        compile &#39;com.android.support:cardview-v7:23.1.1&#39;
        compile &#39;com.android.support:recyclerview-v7:23.1.1&#39;
        compile &#39;com.android.support:appcompat-v7:23.1.1&#39;
        compile &#39;com.android.support:design:23.1.1&#39;
        compile &#39;com.squareup.picasso:picasso:2.5.2&#39;
        compile &#39;com.jakewharton:butterknife:7.0.1&#39;

        compile &#39;com.google.dagger:dagger:2.0.1&#39;
        apt &#39;com.google.dagger:dagger-compiler:2.0.1&#39;
        compile &#39;javax.annotation:javax.annotation-api:1.2&#39;

        compile &#39;io.reactivex:rxandroid:1.1.0&#39;
        compile &#39;io.reactivex:rxjava:1.1.0&#39;

        testCompile &#39;com.neenbedankt.gradle.plugins:android-apt:1.4&#39;
        testCompile &#39;junit:junit:4.12&#39;
        testCompile &#39;org.robolectric:robolectric:3.0&#39;
        testCompile &#39;org.mockito:mockito-core:1.10.19&#39;
    }

So when I build, I get the ```DaggerFlingyApplication_FlingyComponent``` class, but not the ```DaggerTestFlingyApplication_TestFlingyComponent```

Something interesting I noticed is that if I switch the line:

    apt &#39;com.google.dagger:dagger-compiler:2.0.1&#39;
    # TO
    compile &#39;com.google.dagger:dagger-compiler:2.0.1&#39;

I see the following when I run ```./gradlew compileDebugUnitTestSources```:

    :app:compileDebugJavaWithJavac
    Note: /app/build/generated/source/apt/debug/com/jy/flingy/DaggerFlingyApplication_FlingyComponent.java uses unchecked or unsafe operations.
    Note: Recompile with -Xlint:unchecked for details.
    :app:preDebugUnitTestBuild UP-TO-DATE
    :app:prepareDebugUnitTestDependencies
    :app:compileDebugUnitTestJavaWithJavac
    Note: /app/build/intermediates/classes/test/debug/com/jy/flingy/DaggerTestFlingyApplication_TestFlingyComponent.java uses unchecked or unsafe operations.

I don&#39;t know why it builds to intermediates and I assume that I need the build.gradle file to use ```apt``` instead of ```compile```, but I can&#39;t seem to figure out how to get this to work. I know that it&#39;s absolutely possible.

Dagger not generating components for /test class

To my knowledge, Dagger does generate code, while Guice and Spring rely on runtime processing, thus Dagger works faster, but requires more work on programmer side. Because of performance edge it&#39;s good for mobile (Android) development.

However, when we are left with Guice and Spring, the latter has lots of integrations. What&#39;s the point of developing/using Guice, if we can use Spring Framework (that does basically same thing, but offers ex. easier database access)?

Isn&#39;t Google trying to reinvent wheel by creating their own DI tool, instead of using (and possibly contributing to) Spring Framework?

I am looking for decision tree, that guides through choosing DI tool.

Why use/develop Guice, when You have Spring and Dagger?

I am new to Dagger 2. I have 2 Activities, I want to use injected ViewModel for both. Here is my **ViewModuleFactory** :

    @Singleton
    public class ProductViewModelFactory implements ViewModelProvider.Factory {
    
        private final Map&lt;Class&lt;? extends ViewModel&gt;, Provider&lt;ViewModel&gt;&gt; creators;
    
        @Inject
        public ProductViewModelFactory(Map&lt;Class&lt;? extends ViewModel&gt;, Provider&lt;ViewModel&gt;&gt; creators) {
            this.creators = creators;
        }
    
    
        @SuppressWarnings(&quot;unchecked&quot;)
        @Override
        public &lt;T extends ViewModel&gt; T create(Class&lt;T&gt; modelClass) {
            Provider&lt;? extends ViewModel&gt; creator = creators.get(modelClass);
            if (creator == null) {
                for (Map.Entry&lt;Class&lt;? extends ViewModel&gt;, Provider&lt;ViewModel&gt;&gt; entry : creators.entrySet()) {
                    if (modelClass.isAssignableFrom(entry.getKey())) {
                        creator = entry.getValue();
                        break;
                    }
                }
            }
            if (creator == null) {
                throw new IllegalArgumentException(&quot;unknown viewmodel class &quot; + modelClass);
            }
            try {
                return (T) creator.get();
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        }
    }


My **ViewModelModule**:

    @Module
    abstract class ViewModelModule {
        @Binds
        @IntoMap
        @ViewModelKey(ProductListViewModel.class)
        abstract ViewModel bindProductListViewModel(ProductListViewModel listViewModel);
    
        @Binds
        @IntoMap
        @ViewModelKey(ProductDetailsViewModel.class)
        abstract ViewModel bindProductDetailsViewModel(ProductDetailsViewModel detailsViewModel);
    
        @Binds
        abstract ViewModelProvider.Factory bindViewModelFactory(ProductViewModelFactory factory);
    }

My **ViewModelKey** for mapping:

    @Documented
    @Target({ElementType.METHOD})
    @Retention(RetentionPolicy.RUNTIME)
    @MapKey
    @interface ViewModelKey {
        Class&lt;? extends ViewModel&gt; value();
    }

My **ActivityModule** :

    @Module
    public abstract class ActivityModule {
        abstract ProductListActivity contributeProductListActivity();
        abstract ProductDetailsActivity contributeProductDetailsActivity();
    }

My **AppModule**:

    @Module
    class AppModule {
    
    @Provides
        @Singleton
        RedMartProductService provideRedMartProductService() {
            ........
        }
    
        @Provides
        @Singleton
        ProductListRepository provideProductListRepository(ProductListRepository repository) {
            return repository;
        }
    
        @Provides
        @Singleton
        ProductDetailsRepository provideProductDetailsRepository(ProductDetailsRepository repository) {
            return repository;
        }
    }

My **AppComponent**:

    @Singleton
    @Component(modules = {AndroidInjectionModule.class, ActivityModule.class, AppModule.class})
    public interface AppComponent {
        @Component.Builder
        interface Builder {
            @BindsInstance
            Builder application(Application application);
    
            AppComponent build();
        }
    
        void inject(MartApplication martApp);
    }

My **Application**:

    public class MartApplication extends Application implements HasActivityInjector {
    
        @Inject
        DispatchingAndroidInjector&lt;Activity&gt; dispatchingAndroidInjector;
    
        @Override
        public void onCreate() {
            super.onCreate();
        }
    
        @Override
        public DispatchingAndroidInjector&lt;Activity&gt; activityInjector() {
            return dispatchingAndroidInjector;
        }
    }

In **Activity**: 

    @Inject
    ViewModelProvider.Factory viewModelFactory;
    .......
    AndroidInjection.inject(activity); // Throwing exception
    ListViewModel = ViewModelProviders.of(this, viewModelFactory).get(ProductListViewModel.class);


It is throwing an exception on inject: 

    java.lang.IllegalArgumentException: No injector factory bound for Class&lt;com.mymart.ui.ProductListActivity&gt;

Can anyone help me identify the problem in my code?

.......................................................................

**Edit**: I tried with `ContributesAndroidInjector` as per @azizbekian, but it resulted following error on build: 

        error: [dagger.android.AndroidInjector.inject(T)] Found a dependency cycle:
    com.mymart.repository.ProductListRepository is injected at
    com.mymart.di.AppModule.provideProductListRepository(repository)
    com.mymart.repository.ProductListRepository is injected at
    com.mymart.viewmodel.ProductListViewModel.&lt;init&gt;(productListRepository)
    com.mymart.viewmodel.ProductListViewModel is injected at
    com.mymart.di.ViewModelModule.bindProductListViewModel(listViewModel)
    java.util.Map&lt;java.lang.Class&lt;? extends android.arch.lifecycle.ViewModel&gt;,javax.inject.Provider&lt;android.arch.lifecycle.ViewModel&gt;&gt; is injected at
    com.mymart.viewmodel.ProductViewModelFactory.&lt;init&gt;(creators)
    com.mymart.viewmodel.ProductViewModelFactory is injected at
    com.mymart.di.ViewModelModule.bindViewModelFactory(factory)
    android.arch.lifecycle.ViewModelProvider.Factory is injected at
    com.mymart.ui.ProductListActivity.viewModelFactory
    com.mymart.ui.ProductListActivity is injected at
    dagger.android.AndroidInjector.inject(arg0)

**Edit 2**
After all changes, I am facing again exception:

    java.lang.RuntimeException: Unable to create application com.kaushik.myredmart.MartApplication: java.lang.IllegalStateException: com.kaushik.myredmart.di.AppModule must be set
                                                     at android.app.ActivityThread.handleBindApplication(ActivityThread.java:4710)
                                                     at android.app.ActivityThread.-wrap1(ActivityThread.java)
                                                     at android.app.ActivityThread$H.handleMessage(ActivityThread.java:1405)
                                                     at android.os.Handler.dispatchMessage(Handler.java:102)
                                                     at android.os.Looper.loop(Looper.java:148)
                                                     at android.app.ActivityThread.main(ActivityThread.java:5417)
                                                     at java.lang.reflect.Method.invoke(Native Method)
                                                     at com.android.internal.os.ZygoteInit$MethodAndArgsCaller.run(ZygoteInit.java:726)
                                                     at com.android.internal.os.ZygoteInit.main(ZygoteInit.java:616)
                                                  Caused by: java.lang.IllegalStateException: com.kaushik.myredmart.di.AppModule must be set
                                                     at com.kaushik.myredmart.di.DaggerAppComponent$Builder.build(DaggerAppComponent.java:180)
                                                     at com.kaushik.myredmart.di.AppInjector.init(AppInjector.java:30)
                                                     at com.kaushik.myredmart.MartApplication.onCreate(MartApplication.java:28)
                                                     at android.app.Instrumentation.callApplicationOnCreate(Instrumentation.java:1013)
                                                     at android.app.ActivityThread.handleBindApplication(ActivityThread.java:4707)
                                                     at android.app.ActivityThread.-wrap1(ActivityThread.java)&#160;
                                                     at android.app.ActivityThread$H.handleMessage(ActivityThread.java:1405)&#160;
                                                     at android.os.Handler.dispatchMessage(Handler.java:102)&#160;
                                                     at android.os.Looper.loop(Looper.java:148)&#160;
                                                     at android.app.ActivityThread.main(ActivityThread.java:5417)&#160;
                                                     at java.lang.reflect.Method.invoke(Native Method)

Dagger: IllegalArgumentException: No injector factory bound for Class

With the recent versions of dagger 2 one of the improvements made are the possibility of having static provide methods. Simply so:

    @Provides
    static A providesA() {
      return A();
    }

I was wondering how does one go about doing this in kotlin? I&#39;ve tried

    @Module
    class AModule {
      companion object {
        @JvmStatic
        @Provides
        fun providesA(): A = A()
      }
    }

But I get the error message:

    @Provides methods can only be present within a @Module or @ProducerModule

I&#39;m guessing there&#39;s something going on here with the companion object, however I&#39;m quite new to Kotlin and I&#39;m unsure of how one can do this. Is it even possible?

Thanks!

Dagger 2 static provider methods in kotlin

I&#39;m trying to add Dagger2 to my project in Android Studio but I can&#39;t find proper dependency to paste in build.gradle. Could you help and send me the proper line?

Dagger2 dependency - Gradle

Recent after update Android Studio (2.0.7) (maybe this is the cause) sometimes when building i get that error.

Idea is that usually compilation goes well but sometimes I get dagger error.

Is possible that is problem in Dagger configuration?

Error itself: 

&lt;code&gt;
Executing tasks: [:app:assembleDebug]

Configuration on demand is an incubating feature.
Incremental java compilation is an incubating feature.
:app:preBuild UP-TO-DATE
:app:preDebugBuild UP-TO-DATE
:app:checkDebugManifest
:app:preReleaseBuild UP-TO-DATE
:app:prepareComAndroidSupportAppcompatV72311Library UP-TO-DATE
:app:prepareComAndroidSupportDesign2311Library UP-TO-DATE
:app:prepareComAndroidSupportMultidex101Library UP-TO-DATE
:app:prepareComAndroidSupportRecyclerviewV72311Library UP-TO-DATE
:app:prepareComAndroidSupportSupportV42311Library UP-TO-DATE
:app:prepareComDaimajiaSwipelayoutLibrary120Library UP-TO-DATE
:app:prepareComF2prateekRxPreferencesRxPreferences101Library UP-TO-DATE
:app:prepareComGithubAakiraExpandableLayout141Library UP-TO-DATE
:app:prepareComGithubAfollestadMaterialDialogsCore0842Library UP-TO-DATE
:app:prepareComGithubCastorflexSmoothprogressbarLibraryCircular120Library UP-TO-DATE
:app:prepareComJakewhartonRxbindingRxbinding030Library UP-TO-DATE
:app:prepareComPnikosisMaterialishProgress17Library UP-TO-DATE
:app:prepareComTrelloRxlifecycle040Library UP-TO-DATE
:app:prepareComTrelloRxlifecycleComponents040Library UP-TO-DATE
:app:prepareComWdullaerMaterialdatetimepicker211Library UP-TO-DATE
:app:prepareIoReactivexRxandroid110Library UP-TO-DATE
:app:prepareMeRelexCircleindicator116Library UP-TO-DATE
:app:prepareMeZhanghaiAndroidMaterialprogressbarLibrary114Library UP-TO-DATE
:app:prepareDebugDependencies
:app:compileDebugAidl UP-TO-DATE
:app:compileDebugRenderscript UP-TO-DATE
:app:generateDebugBuildConfig UP-TO-DATE
:app:generateDebugAssets UP-TO-DATE
:app:mergeDebugAssets UP-TO-DATE
:app:generateDebugResValues UP-TO-DATE
:app:generateDebugResources UP-TO-DATE
:app:mergeDebugResources UP-TO-DATE
:app:processDebugManifest UP-TO-DATE
:app:processDebugResources UP-TO-DATE
:app:generateDebugSources UP-TO-DATE
:app:compileDebugJavaWithJavac
/home/ungvas/AndroidDev/Projects/FW/paynet-android/app/src/main/java/md/fusionworks/paynet/ui/activity/BaseActivity.java:23: error: cannot find symbol
import md.fusionworks.paynet.di.component.DaggerActivityComponent;
                                         ^
  symbol:   class DaggerActivityComponent
  location: package md.fusionworks.paynet.di.component
/home/ungvas/AndroidDev/Projects/FW/paynet-android/app/src/main/java/md/fusionworks/paynet/PaynetApplication.java:7: error: cannot find symbol
import md.fusionworks.paynet.di.component.DaggerApplicationComponent;
                                         ^
  symbol:   class DaggerApplicationComponent
  location: package md.fusionworks.paynet.di.component
2 errors

Incremental compilation of 66 classes completed in 3.719 secs.
:app:compileDebugJavaWithJavac FAILED
:app:compileRetrolambdaDebug

FAILURE: Build failed with an exception.

* What went wrong:
Execution failed for task &#39;:app:compileDebugJavaWithJavac&#39;.
&gt; Compilation failed; see the compiler error output for details.

* Try:
Run with --stacktrace option to get the stack trace. Run with --info or --debug option to get more log output.

BUILD FAILED

Total time: 19.556 secs
&lt;/code&gt;   
Thanks. 

Dagger 2, sometimes on compiling I get &quot;cannot find symbol class DaggerApplicationComponent&quot;

Say I have a class **Util** that takes in a object - an instance of class **Validator**. 

Since I want to avoid instantiating the Validator class within Util, I pass it in via a constructor: 

    public class Util {
       
       @Inject
       public Util(Validator validator) {

       }


    }

I have a module that provides the Validator instance:

    @Provides
    @Singleton
    Validator provideValidator() {
        return Validator.getInstance();
    }

and an instance of the Util class:

    @Provides
    Util provideUtil(Validator validator) {
        return new Util(validator);
    }

I have a component wired up that would give me an instance of Util:

    Util getUtil()

so within my activity, I could call it like: 

    Util myUtil = getComponent.getUtil();


All of that works fine - myUtil has a proper instance of Validator class when instantiated. 

Now I want to pass in a String variable named **address** (which is user input via a UI). I want to change the constructor so I pass in both an instance of Validator and the user inputted String:

    @Inject
    public Util(Validator validator, String address) {

    }

 
I just can&#39;t get my head around how to pass that 2nd parameter. Can someone tell me how? 

Ideally, I want to instantiate Util like:

    Util myUtil = getComponent.getUtil(txtAddress.getText());




Dagger 2: Injecting user inputted parameter into object

I have a [simple Android activity](https://github.com/glombard/hello-dagger2/blob/master/hello-dagger2-simple/app/src/main/java/com/codeblast/hellodagger2/HelloActivity.java) with a single dependency. I inject the dependency into the activity&#39;s `onCreate` like this:

    Dagger_HelloComponent.builder()
        .helloModule(new HelloModule(this))
        .build()
        .initialize(this);

In my `ActivityUnitTestCase` I want to override the dependency with a Mockito mock. I assume I need to use a test-specific module which provides the mock, but I can&#39;t figure out how to add this module to the object graph.

In Dagger 1.x this is apparently done with [something like this](https://stackoverflow.com/questions/25271721/overriding-debug-module-in-tests):

    @Before
    public void setUp() {
      ObjectGraph.create(new TestModule()).inject(this);
    }

What&#39;s the Dagger 2.0 equivalent of the above?

You can see my project and its unit test [here on GitHub](https://github.com/glombard/hello-dagger2/blob/master/hello-dagger2-simple/app/src/androidTest/java/com/codeblast/hellodagger2/HelloActivityTest.java).

How do you override a module/dependency in a unit test with Dagger 2.0?

I use in kotlin activity ViewPager and I want in Kotlin Fragment use the dagger injection. I have got Error: Dagger does not support injection into private fields.
In Java Fragment the dagger injection work.
Why can i not inject dagger in kotlin faragment ?

in my kotlin activity

    mPagerAdapter = object : FragmentPagerAdapter(supportFragmentManager) {

            private val mFragments = arrayOf(KotlinFragment(), JavaFragment())
            private val mFragmentNames = arrayOf(getString(R.string.cashdocuments), getString(R.string.action_absmysql))

            override fun getItem(position: Int): Fragment {
                return mFragments[position]
            }

            override fun getCount(): Int {
                return mFragments.size
            }

            override fun getPageTitle(position: Int): CharSequence {
                return mFragmentNames[position]
            }
        }

my kotlin fragment

    class KotlinFragment : Fragment()  {


    @Inject
    internal var mSharedPreferences: SharedPreferences? = null

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        (activity.application as SamfantozziApp).dgaeacomponent().inject(this)

    }

    override fun onCreateView(inflater: LayoutInflater?, container: ViewGroup?,
                              savedInstanceState: Bundle?): View? {
        super.onCreateView(inflater, container, savedInstanceState)
        val rootView = inflater!!.inflate(R.layout.activity_absserver, container, false)
        
        return rootView
    }
    
    }

messages gradle build

[![enter image description here][1]][1]


  [1]: https://i.stack.imgur.com/WDYxt.png

Kotlin Error: Dagger does not support injection into private fields

I&#39;m new to using Kotlin and trying to set it up with Dagger2, I&#39;ve seen some few examples but none of them seem to work for me.

I keep getting this 

&gt; Error:Execution failed for task &#39;:app:kaptDebugKotlin&#39;.
&gt; &gt; Internal compiler error. See log for more details

I have my build.gradle (Module: app)

    apply plugin: &#39;com.android.application&#39;
    apply plugin: &#39;kotlin-android&#39;
    apply plugin: &#39;kotlin-kapt&#39;
    apply plugin: &#39;kotlin-android-extensions&#39;
    
    android {
        compileSdkVersion 25
        buildToolsVersion &quot;25.0.0&quot;
        defaultConfig {
            applicationId &quot;com.exampleapp&quot;
            minSdkVersion 14
            targetSdkVersion 25
            versionCode 1
            versionName &quot;1.0&quot;
            testInstrumentationRunner &quot;android.support.test.runner.AndroidJUnitRunner&quot;
        }
        buildTypes {
            release {
                minifyEnabled false
                proguardFiles getDefaultProguardFile(&#39;proguard-android.txt&#39;), &#39;proguard-rules.pro&#39;
            }
        }
        kapt {
            generateStubs = true
        }
        dexOptions {
            javaMaxHeapSize &quot;2048M&quot;
        }
    }
    
    ext {
        supportLibVer = &#39;25.0.0&#39;
        daggerVer = &#39;2.8&#39;
    }
    
    dependencies {
        compile fileTree(dir: &#39;libs&#39;, include: [&#39;*.jar&#39;])
    
        // Support lib
        compile &quot;com.android.support:appcompat-v7:${supportLibVer}&quot;
    
        kapt &quot;com.google.dagger:dagger-compiler:${daggerVer}&quot;
        compile &quot;com.google.dagger:dagger:${daggerVer}&quot;
        provided &quot;javax.annotation:jsr250-api:${javaxVer}&quot;
    
        compile &quot;org.jetbrains.kotlin:kotlin-stdlib-jre7:$kotlin_version&quot;
    
    
    }
    repositories {
        mavenCentral()
    }

Error:Execution failed for task &#39;:app:kaptDebugKotlin&#39;

I&#39;m using Dagger 2 and Kotlin for Android development.
My project is also a multi-module project.
My settings.gradle file is like this:
    
    include :app
    include :lib

I&#39;m also maintaining the lib module.

In the Dagger Files (for example in the component), I try to get the item from other module. For example:

    @Component
    interface AppComponent{
        fun getPresenter() : Presenter
    }

The Presenter object is defined in lib module. I was working in linux environment and I&#39;m using Android Studio 3 preview canary 5. The code is working well and I am able to generate APK.

But my company wanted to generate the APK using stable version of Android Studio. I&#39;m using Android Studio 2.3.3.

When compiling the Android Project, I encountered this error:

    error: error.NonExistentClass

The error appears when 

    :app:kaptDebugKotlin 

is performed and caused by the dagger class cannot found, the class is defined in the other project. What can be the possible workaround for this? Sorry for my bad English.

All Dagger 2 Solutions on Gang of Coders

Total of 29 Dagger 2 Solutions