Dagger 2 @Inject y @Component Anotaciones en Android

Android es un sistema operativo de código abierto, basado en el kernel de Linux y utilizado en dispositivos móviles como teléfonos inteligentes, tabletas, etc. Además, fue desarrollado para relojes inteligentes y Android TV. Cada uno de ellos tiene una interfaz especializada. Android ha sido uno de los sistemas operativos más vendidos para teléfonos inteligentes. El sistema operativo Android fue desarrollado por Android Inc., que Google compró en 2005. Entonces, en este artículo, aprenderemos cómo usar @Inject y @Component en nuestra aplicación de Android usando Kotlin. ¿Aprenderemos cómo Dagger crea el objeto requerido? ¿Cómo automatiza el proceso de inyección manual?

Requisitos previos:

• inyección de construcción
• inyección manual
• Conceptos básicos de la inyección de dependencia
• Sintaxis de Kotlin

En el artículo anterior vimos cómo funciona la inyección manual , así que aquí tomaremos ese mismo proyecto para entender este concepto. La implementación de Android Dagger 2 es más sencilla y se basa en la arquitectura de inyección de dependencia. Dagger crea objetos para la clase dependiente. Dagger necesita saber cómo crear instancias para las clases. Aquí usamos la anotación @Inject para el constructor , que le indicará a Dagger cómo crear una instancia con el constructor anotado @Inject. Dado que en nuestra aplicación, la clase UserRegistrationService depende de la clase EmailService y la clase UserRepo. Necesitamos agregar la anotación @Inject a su constructor también.

Clase de servicio de correo electrónico:

class EmailService @Inject constructor() {
    fun send(to: String,from: String,body:String){
       Log.d("result","Email sent")
    }
}

Clase UserRepo:

class UserRepo @Inject constructor() {
    fun saveUser(email:String,pass:String){
        Log.d("result","user data saved")
    }
}

Clase UserRegistrationService:

class UserRegistrationService @Inject constructor(
    private val userRepo: UserRepo,
    private val emailService: EmailService
) {
    fun userRegistration(email:String,pass:String){
        userRepo.saveUser(email,pass)
        emailService.send(email,"abc@gmail.com","")
    }
}

Luego, debemos crear una interfaz para el componente Dagger , un componente es solo una colección de dependencias en nuestro proyecto que puede usar para averiguar dónde debe obtener esas dependencias cuando se necesitan. Entonces necesitamos anotar esta interfaz con @Component. Dentro de la interfaz @Component, necesitamos definir funciones que devuelvan instancias de las clases que necesitamos.

Interfaz de UserRegistrationComponent:

@Component
interface UserRegistrationComponent {
    // as we need the object of 
    // UserRegistrationService class
    // in mainActivity
    fun getUserRegistrationService(): UserRegistrationService 
}

El método getUserRegistrationService() devuelve un objeto de UserRegistrationService, Dagger crea su objeto (que se devolverá). Entonces, en el archivo mainActivity, llamaremos a este método. Cuando construimos este proyecto, Dagger creará un campo como Dagger que agregará el nombre de la interfaz del componente. Como en nuestro caso, será DaggerUserRegistrationComponent ( Dagger + UserRegistrationComponent) necesitamos construirlo, luego podemos acceder a su método.

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
  
        val userRegistrationService = DaggerUserRegistrationComponent.builder().build().getUserRegistrationService()
        userRegistrationService.userRegistration("xyz@gmail.com","11111")
    }
}

No hay cambios en el archivo de diseño XML.

<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout 
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity">
  
    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Hello World!"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintLeft_toLeftOf="parent"
        app:layout_constraintRight_toRightOf="parent"
        app:layout_constraintTop_toTopOf="parent" />
  
</androidx.constraintlayout.widget.ConstraintLayout>

Entonces, de esta manera, podemos implementar Dagger en nuestro proyecto.