Ceci est la 3ème partie d'un lot de 7 tutoriels.

Vous pouvez repartir de l'étape précédente ou tirer la solution contenue dans le commit 2-Timber_Stetho_StrictMode

La solution de cette partie est disponible sur le commit 3-Dagger.

Pourquoi Dagger?

Si vous venez du monde JEE, vous avez sûrement déjà entendu parler d'injection de dépendances. Le but est de découpler tout ou partie des dépendances de l'application. Cela offre plusieurs avantages :

• testabilité améliorée
• délégation de la gestion du cycle de vie de certains objets
• etc

Lorsque l'on développe sur Android, on manipule beaucoup d'objets. Nous sommes aussi amenés à gérer plusieurs types de cycles de vie : Activités, Fragments…

Dagger nous simplifie la tâche et rend le code plus lisible. Il favorise aussi un meilleur découpage des briques de notre application.

Ajout des dépendances

Dagger 2, à l'instar de Spring, utilise des annotations pour l'injection de dépendances. Kapt est le processeur d'annotations par défaut de Kotlin.

• Dans app/build.gradle, ajouter en haut du fichier la ligne suivante pour indiquer l'utilisation de kapt :

• Ajouter les dépendances relatives à Dagger :

Création du graphe de dépendances

Créer un package di dans app/src/main/java/fr/ippon/androidaacsample/coinsentinel. Dagger construit son graphe de dépendances via des Components qui contiennent des Modules.

MainActivityModule

Créer dans di une classe abstraite MainActivityModule :

Ici, on définit le module lié à notre MainActivity. L'annotation @ContributesAndroidInjector génère un AndroidInjector. Ce type d'objet sert à l'injection dans des types Android (Fragments, Activités, Services…).

AppModule

Créer dans di une classe AppModule :

Ce fichier est vide pour le moment mais sera rempli plus tard. Cette classe n'est pas abstraite puisqu'elle sera un provider de dépendances.

AppComponent

Créer dans di une interface AppComponent :

Ce composant contient 3 modules fils :

• AndroidInjectionModule (contenu dans dagger-android)
• AppModule
• MainActivityModule

Nous définissons dans l'interface Builder le binding entre AppComponent et un objet Application. Compiler l'application. La compilation générera une classe DaggerAppComponent que nous utiliserons par la suite.

Création du binding entre Dagger et notre Application

Pour injecter des dépendances dans MainActivity, notre application doit implémenter HasActivityInjector :

Cette interface contient la fonction activityInjector(). Elle retourne un objet DispatchingAndroidInjector.

Définir une variable d'instance dispatchingAndroidActivityInjector. Elle sera injectée :

Le mot clé lateinit indique au compilateur que la variable sera initialisée plus tard en dehors du constructeur. L'utilisation de l'injection de dépendances est un usecase parfait.

Redéfinir la fonction activityInjector() et retourner la variable d'instance ci-dessus :

Il ne reste plus qu'à créer le binding entre Dagger et notre application. Dans onCreate(), ajouter à la fin de la fonction :

Conclusion

Oui, nous n'avons toujours pas commencé à coder notre application. Cela montre à quel point il est important de bien réfléchir à l'outillage utilisé pour un projet. Si vous lancez l'application, vous verrez qu'elle n'affiche toujours...qu'un Hello World. En revanche, elle dispose de librairies pour faire des développements robustes et professionnels.

La prochaine étape consistera à préparer notre vue.

Sources

• Android AAC : https://developer.android.com/topic/libraries/architecture/
• Dagger : https://google.github.io/dagger/