Prácticamente todo el mundo que quiere crear código en Android de forma desacoplada y fácil de testear, recurre tarde o temprano a Dagger para ello.

Aunque hay alguna cosa que funciona un poco diferente a la hora de configurar Dagger en Kotlin, la mayor parte es bastante sencilla, y en pocos pasos te la voy a mostrar hoy aquí.

También decirte que, gracias a la potencia de Kotlin, hay otras maneras de solventar la inyección, e incluso algunas librerías hechas exclusivamente en Kotlin para ello.

Pero Dagger sigue siendo una opción perfectamente válida, y una de las más versátiles (si no la que más).

Este artículo forma parte de una serie de 30 con motivo del lanzamiento del curso presencial de Kotlin para Desarrolladores Android que impartiré en breve.

kotlin-desarrolladores-android

Disclaimer: En este artículo no voy a explicar cómo se usa Dagger 2, esto ya se da por sabido. Si tienes alguna duda, busca alguno de los muchos artículos que puedes encontrar por Internet.

Configurando el proyecto para que utilice Dagger 2

Si ya tienes configurado el plugin de Kotlin en tu proyecto, lo único que necesitas es configurar kapt.

Si ya utilizabas Dagger, seguramente conoces apt. kapt no es más que la versión para Kotlin, que crea las clases autogeneradas necesarias para Dagger.

Para configurarlo, necesitas añadir lo siguiente al build.gradle:

Puedes añadirlo justo antes de la sección de dependencies. En algún sitio leí (no recuerdo dónde), que en un tiempo esta parte tampoco será necesaria.

Ahora ya solo necesitas añadir las dependencias del compilador de Dagger (usando kapt para que no se incluya en el apk) y de la librería propiamente dicha:

Ya está todo listo para empezar a utilizar Dagger.

Implementación del módulo principal

Como bien sabes, para el grafo principal vas a necesitar un Module y un Component.

El módulo de aplicación, en este caso sencillo, sólo devolverá la instancia de la aplicación propiamente dicha.

Para ello crearemos un clase anotada con @Module, que recibirá por constructor la instancia de aplicación, la almacenará en una property, y la devolvería mediante un método anotado con @Provides @Singleton:

Ya ves que, incluso para esta clase tan sencilla, el código es bastante más simple que en Java.

Ahora nos queda implementar el Component, que necesita un array de módulos a cargar, y especificar quién lo va a poder inyectar manualmente:

Ahora ya solo queda crear la clase App, que se encargará de generar el grafo:

Lo interesante a ver aquí es que, gracias a la declaración lazy, podemos especificar el valor del grafo en la definición de la propiedad, y además conseguir así un acceso de solo lectura a dicha propiedad.

el código definido por la propiedad no se ejecutará hasta que no se haga component.inject(this), de tal forma que para ese momento this ya existe y se puede crear el grafo de forma segura.

Implementación de un módulo por ámbito

Los módulos por ámbito permiten que esa parte del grafo solo viva durante el tiempo de vida del objeto que lo crea.

De esta forma, podemos crear subgrafos que vivan y mueran con una Activity, por ejemplo.

Nos crearíamos nuestro módulo con lo que necesitemos:

Un Subcomponent de forma muy parecida al anterior, indicando que se va a inyectar en la HomeActivity:

Y un método plus en AppComponent, para indicar que a ese componente se le pueden añadir subcomponentes de ese tipo:

Ahora, en la HomeActivity ya solo necesitas declarar el subcomponente:

Y ya lo puedes inyectar tras el setContentView:

Conclusión

Así de sencillo es utilizar Dagger 2 en Kotlin. Ya no tienes excusa para no hacer tu código más desacoplado también en Kotlin.

Si quieres aprender mucho más sobre todo esto y coger la soltura suficiente para crear tus propias Apps Android, échale un vistazo al curso presencial que estoy preparando, y del que ya puedes reservar tu plaza. ¡La fecha se aproxima, no lo dejes escapar!