MVP and Dagger 2 - Esqueleto de la aplicación de Android - Parte 2

Este artículo es el resultado de una investigación, un subproducto que fue la encarnación de una idea de larga data en una aplicación de Android muy útil y que una vez desapareció: My Location Notifier , diseñada para notificar automáticamente al destinatario la llegada de un usuario (consulte la descripción detallada por referencia ).

Entonces, en la primera parte, creamos el esqueleto principal de la aplicación de Android de acuerdo con la arquitectura MVP. Ahora comencemos a atornillar Dagger 2.

2.1. Preestablecido

Para comenzar, vaya al archivo build.gradle (Proyecto: mymvcapp) y agregue la siguiente línea a la sección buildscript:

ext.dagger2_version = "2.8" 

En el momento de escribir este artículo, esta es la última versión de Dagger 2. A continuación, vaya al archivo build.gradle (Módulo: aplicación) y agregue la línea al principio:

 apply plugin: 'kotlin-kapt' 

Esto es necesario para que en Dagger 2 pueda generar su código en la compilación. Más tarde entenderás por qué.

Ahora agregue las dependencias necesarias:

 implementation "com.google.dagger:dagger:$dagger2_version" kapt "com.google.dagger:dagger-compiler:$dagger2_version" 

2.2. Preparación de la inyección

Sincronizaremos el proyecto y volveremos al componente MainScreen. Cree una clase di.MainScreenModule en el paquete de backstage y márquelo con la anotación Module . En la nueva clase, declaramos e implementamos el método providePresenter (): MainScreenPresenter = MainScreenPresenter y lo marcamos con anotaciones Provides y Singleton . Así que ahora nuestra clase se verá:

 @Module class MainScreenModule { @Provides @Singleton fun providesPresenter(): MainScreenPresenter = MainScreenPresenter() } 

Ahora iremos a la clase MainScreenCompatActivity y reemplazaremos los modificadores de la variable presentadora con lateinit var, eliminaremos la asignación de valor y la marcaremos con la anotación Inject :

 class MainScreen : BaseCompatActivity(), MainScreenContract.View { @Inject lateinit var presenter: MainScreenPresenter override fun init(savedInstanceState: Bundle?) { setContentView(R.layout.activity_main_screen) presenter.attach(this) } } 

Tenga en cuenta que ahora no necesitamos un signo de interrogación al acceder a esta variable.
Puede parecer que todo se inyecta, la tarea se completa. Pero no Ahora necesitamos que Dagger genere el código necesario para inyectar nuestra primera dependencia. Es por eso que agregamos el complemento kotlin-kapt al script de compilación anterior. En el paquete com.caesar84mx.mymvcapp, cree el paquete di.config en el que creamos la interfaz AppDiComponent.



Ahora, declaremos la interfaz un componente y un singleton y un miserable , registremos nuestro módulo en él y declaremos el método de inyección (mainScreenActivity: MainScreen) dentro de la interfaz:

 @Component( modules = [ MainScreenModule::class ] ) @Singleton interface AppDiComponent { fun inject(mainScreenActivity: MainScreen) } 

Y ahora, finalmente debes hacer que Dagger genere todo el código necesario. Para hacer esto, crearemos la clase MyMvpApp en el paquete config.di, la heredaremos de la clase Application, registraremos la clase en AndroidManifest.xml escribiendo la línea android: name = ". Config.di.MyMvpApp" en la etiqueta de la aplicación. A continuación, declare el inyector variable lateinit var: AppDiComponent, configúrelo en un setter privado y redefina el método onCreate (). Y comienza la magia:

 class MyMvpApp: Application() { lateinit var injector: AppDiComponent private set override fun onCreate() { super.onCreate() injector = DaggerAppDiComponent.builder() .mainScreenModule(MainScreenModule()) .build() } } 

Como puede ver, la clase DaggerAppDiComponent aún no existe, se generará durante la compilación de la aplicación. Así como la implementación de nuestro componente. El nombre de la clase se compone de la palabra "Daga" + el nombre de la interfaz marcada como un componente. El método mainScreenModule () también se generará durante la compilación del proyecto, el nombre debe compilarse a partir del nombre de la clase del módulo inyectado en lowerCamelCase.

Ensamblamos el proyecto (Build → Make Project). Disfruta de la generación automática de código y continúa.

2.3. Inyección

Atención: además, se presentarán algunos bailes con pandereta con elementos del porno. La solicitud para eliminar niños y personas nerviosas de la pantalla.

Para inyecciones exitosas, necesitaremos una referencia a la variable del inyector. De acuerdo, crear una instancia de MyMvpApp en cada clase donde inyectamos no es la mejor solución. Por lo tanto, haremos lo siguiente:

 class MyMvpApp: Application() { lateinit var injector: AppDiComponent private set override fun onCreate() { super.onCreate() INSTANCE = this injector = DaggerAppDiComponent.builder() .mainScreenModule(MainScreenModule()) .build() } companion object { private var INSTANCE: MyMvpApp? = null @JvmStatic fun get(): MyMvpApp = INSTANCE!! } } 

Exhalado, regresó a la clase MainScreen. Ahora, inyecte nuestro presentador en el método init (). No olvide que esta acción debe realizarse antes del primer acceso a la variable inyectada. Entonces ahora nuestra clase se ve así:

 class MainScreen : BaseCompatActivity(), MainScreenContract.View { @Inject lateinit var presenter: MainScreenPresenter override fun init(savedInstanceState: Bundle?) { setContentView(R.layout.activity_main_screen) MyMvpApp.get().injector.inject(this) presenter.attach(this) } } 

Y aquí está toda la estructura básica de nuestra aplicación:



2.4. Conclusión

Entonces, estamos listos para la estructura mínima de la aplicación, en la que solo queda colgar los elementos. ¿Necesitas una nueva actividad? Lo representamos como un componente, separado de la interfaz de usuario del backstage, para cada componente determinamos qué dependencias necesitamos (mínimo, presentador en actividad o tal vez en la API del presentador para interactuar con un servicio remoto o, por ejemplo, API de repositorio para trabajar con una base de datos), registre el módulo con dependencias, registre el módulo en el componente, regístrese en el generador, reconstruya el proyecto, inyecte dependencias cuando sea necesario, repita la iteración para cada nuevo componente.

Por supuesto, puede surgir la pregunta: ¿por qué necesitamos Dagger? Después de todo, ¿hicieron un excelente trabajo? Genial, mientras que la aplicación es pequeña. Cuando crezca por completo, con docenas de actividades, fragmentos, adaptadores, solicitudes de servidor, almacenamiento en caché de datos y otras maravillas, habrá muchas dependencias que son difíciles de rastrear en una aplicación grande si no usa la Inyección de dependencias. El marco Dagger DI ayuda a simplificar la tarea de implementarlos y rastrearlos.