Inyección de dependencias con Dagger Hilt: Guía completa

Si realmente quieres estructurar proyectos Android de una forma modular y escalable, no puedes pasar por alto Dagger Hilt. Esta es una de las soluciones de inyección de dependencias que todos los desarrolladores Android deberían conocer y manejar. Por eso, en esta guía te daremos los primeros pasos para que aprendas a configurarlo.

¿Por qué usar Dagger Hilt en proyectos Android?

Dagger Hilt te configurará automáticamente las dependencias en componentes típicos de Android. Por eso es tan importante usarlo, porque aparte de mejorar la escalabilidad y el mantenimiento de tus proyectos, sin la necesidad de que realices configuraciones complejas, se adapta muy bien al desarrollo Android ya que te brinda integraciones específicas.

Primeros pasos para configurar Dagger Hilt en Kotlin

Añade dependencias en Gradle

Para comenzar, es necesario que agregues las dependencias de Dagger Hilt en los archivos build.gradle.

Primero, vas a agregar el classpath de Dagger Hilt en el archivo build.gradle del proyecto:

buildscript {
    ext.kotlin_version = "1.3.72"
    ext.hilt_version = '2.35'
    repositories {
        google()
        jcenter()
    }
    dependencies {
        classpath "com.android.tools.build:gradle:4.1.3"
        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
        classpath "com.google.dagger:hilt-android-gradle-plugin:$hilt_version"
    }
}

Luego, en el build.gradle del módulo app, agregas los plugins y dependencias necesarios para habilitar Hilt en el proyecto:

plugins {
    id 'kotlin-kapt'
    id 'dagger.hilt.android.plugin'
}

dependencies {
    implementation "com.google.dagger:hilt-android:$hilt_version"
    kapt "com.google.dagger:hilt-android-compiler:$hilt_version"
}

Recuerda definir hilt_version como variable en el archivo de build.gradle general para evitar discrepancias de versión en las dependencias. Además, asegúrate de que tu proyecto está configurado para Java 8.

Configura la clase de aplicación con Dagger Hilt

Para que Dagger Hilt funcione correctamente, necesitas una clase de aplicación anotada con @HiltAndroidApp, lo que permite que Hilt se inicialice al inicio de la aplicación.

Esta clase debe heredar de Application y estar registrada en el AndroidManifest.xml.

@HiltAndroidApp
class MyApplication : Application()

Y en el AndroidManifest.xml, indicas que esta será la clase de aplicación principal:

<application
    android:name=".MyApplication"
    ... >
</application>

Inyectar dependencias en componentes de Android

Con Dagger Hilt puedes inyectar dependencias en varios componentes de Android como Activity, Fragment o Service.

Así puedes inyectar una dependencia en una Activity y en un ViewModel.

Inyectar en una Activity

Para inyectar una dependencia en una Activity, primero debes anotarla con @AndroidEntryPoint. Por ejemplo, en MainActivity:

@AndroidEntryPoint
class MainActivity : AppCompatActivity() {
    @Inject lateinit var myDependency: ExampleClass
}

Aquí estas utilizando @Inject para decirle a Hilt que inyecte la dependencia ExampleClass en MainActivity. Esta anotación permite que Hilt cree automáticamente las instancias necesarias para las dependencias definidas.

Inyectar en ViewModel

Cuando se utiliza MVVM en una aplicación Android, los ViewModel suelen gestionar la lógica de la aplicación. Entonces, Hilt facilita la inyección en estos componentes para desacoplar el código.

Para inyectar dependencias en un ViewModel, este debe estar anotado con @HiltViewModel.

@HiltViewModel
class MainViewModel @Inject constructor(
    private val repository: MyRepository
) : ViewModel() {
    // Lógica del ViewModel
}

En este caso, el constructor del ViewModel recibe el repository como dependencia, que Hilt inyectará automáticamente.

Crear módulos para inyectar dependencias externas con @Provides

Dagger Hilt te permite crear módulos que proveen dependencias más complejas. Te servirá mucho cuando necesites inyectar dependencias de librerías externas como Retrofit o Room, ya que no puedes anotarlas directamente con @Inject.

Ejemplo: Proveer Retrofit en un módulo

1. Crea un directorio di en el módulo de tu proyecto y dentro, un archivo NetworkModule.kt con el siguiente contenido:

@Module
@InstallIn(SingletonComponent::class)
object NetworkModule {

    @Singleton
    @Provides
    fun provideRetrofit(): Retrofit {
        return Retrofit.Builder()
            .baseUrl("https://example.com/api/")
            .addConverterFactory(GsonConverterFactory.create())
            .build()
    }

    @Singleton
    @Provides
    fun provideApiClient(retrofit: Retrofit): ApiClient {
        return retrofit.create(ApiClient::class.java)
    }
}

La anotación @Module define esta clase como un módulo de Dagger Hilt, mientras que @InstallIn(SingletonComponent::class) asegura que estas dependencias estarán disponibles en toda la aplicación (singleton).

Además, la anotación @Provides es necesaria para indicar qué métodos suministrarán instancias de las dependencias.

Alcances en Dagger Hilt

Ten en cuenta que, Dagger Hilt usa @InstallIn para definir el alcance de una dependencia. Estos son los más comunes:

• SingletonComponent: La instancia vive durante el ciclo de vida de la aplicación.
• ActivityComponent: La instancia se destruye cuando la Activity se destruye.
• FragmentComponent: La instancia solo vive durante el ciclo de vida del Fragment.

Ejemplo completo de inyección de dependencias en un proyecto MVVM con Dagger Hilt en Kotlin

Imagina que tienes una clase QuoteService que realiza llamadas a una API y un repositorio que necesita esta clase para manejar datos.

Con Dagger Hilt, puedes inyectar estas dependencias de la siguiente manera:

1. Define el módulo NetworkModule para Retrofit (como te expliqué anteriormente).
2. Luego, configura QuoteService para inyección:

class QuoteService @Inject constructor(private val api: ApiClient) {
    suspend fun getQuotes(): List<Quote> {
        return withContext(Dispatchers.IO) {
            api.getAllQuotes()
        }
    }
}

3. Ahora, ya puedes inyectar QuoteService en un ViewModel que gestione la lógica de las citas:

@HiltViewModel
class QuoteViewModel @Inject constructor(
    private val quoteService: QuoteService
) : ViewModel() {
    // Lógica de ViewModel
}

Este tipo de configuración asegura que cada clase reciba solo las dependencias que necesita y facilita la escalabilidad del proyecto.

¿Quieres desarrollar aplicaciones Android con inyección de dependencias y otras habilidades avanzadas? En el Bootcamp de Desarrollo de Aplicaciones Móviles iOS & Android de KeepCoding, aprenderás a dominar desde frameworks como Hilt hasta la creación de aplicaciones completas.

Con nuestra metodología intensiva, te convertirás en un profesional del sector IT, accediendo a un mercado laboral con alta demanda, estabilidad y oportunidades de crecimiento económico. ¡Únete a KeepCoding y transforma tu futuro!