Building an Android application without a dependency injection framework can make the application more difficult to maintain and test. The main reasons to use a dependency injection framework is to allow for reusable modules and invert dependency of modules within the application.

While busy working on an Android application side project, I discovered a light-weight dependency injection framework called Dagger.

In this article I'll demonstrate how to setup dependency injection in an Android application using Dagger 1.

@Module(
        injects = MainActivity.class
)
public class CommunicationModule {

    @Provides
    public CommunicationRepository provideCommunicationRepository() {
        return new CommunicationRepositoryImpl();
    }

    @Provides
    public CommunicationApi provideCommunicationApi(CommunicationRepository	communicationRepository) {
        return new CommunicationApiImpl(communicationRepository);
    }
}

The code above specifies a communication module that provides two dependencies; `CommunicationRepository` and `CommunicationApi` (both of which are interfaces). Notice that the `CommunicationModule` class has a `@Module` annotation which allows Dagger to know where to find dependencies that are provided by the class. The `@Module` also accepts properties, in this case we want the module's dependencies to be injected in the `MainActivity` class. The `@Provides` annotation tells Dagger how we want to construct and provide dependencies. We can also see that `CommunicationApiImpl` requires the `CommunicationRepository`, in this case the `CommunicationRepository` can be passed as a parameter and Dagger will provide an instance of it using the `provideCommunicationRepository()` method.

public class AndroidApplication extends android.app.Application {

    private ObjectGraph objectGraph;

    @Override
    public void onCreate() {
        super.onCreate();

        objectGraph = ObjectGraph.create(new CommunicationModule());
    }

    public ObjectGraph getObjectGraph() {
        return objectGraph;
    }
}

The next step shown above allows you to give Dagger global application state in your Android application by extending the `android.app.Application` class and the `CommunicationModule` then define the dependency object graph. This graph can provide the dependencies to be injected.

```HTML

```

Please note when extending the `android.app.Application` class the `` tag's name has to be changed to `AndroidApplication`, this is shown above (located in the AndroidManifest.xml file).

public abstract class BaseActivity extends Activity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        ((AndroidApplication) getApplication()).getObjectGraph().inject(this);
    }
}

So we do not want to get the object graph for every Activity we create and inject the dependencies, so the best way to do it, is to create a `BaseActivity` class that extends Activity. Then you call the `getApplication()` and cast it to your implementation of `AndroidApplication` and get the graph then you finally inject your dependencies.

That's it! The setup is complete, now all we have to do is inject the dependencies into the `MainActivity` class.

public class MainActivity extends BaseActivity {

    @Inject
    CommunicationApi communicationApi;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        
        this.communicationApi.sendSomething();
    }
}

The `BaseActivity` defined before is extended by `MainActivity` and the `CommunicationApi` member variable declared with a `@Inject` annotation which will tell Dagger to construct an instance of `CommunicationApiImpl`. This is property dependency injection being used here because the Android application requires that an Activity should have a default constructor. Constructor injection is a bit more difficult, but with a bit more research it can be done.

References

http://square.github.io/dagger/

http://blog.andresteingress.com/2014/08/31/android-dependency-injection/

http://developer.android.com/reference/android/app/Application.html

http://stackoverflow.com/questions/2046761/what-is-object-graph-in-java

http://fernandocejas.com/2015/04/11/tasting-dagger-2-on-android/