Inyección de dependencias con Koin

La Inyección de Dependencias (DI) es un patrón de diseño en el que los objetos (clases) no crean sus propias dependencias, sino que estas se les proporcionan (inyectan) desde el exterior. Esto se hace para:

1. Reducir el acoplamiento entre clases.

2. Facilitar el cambio de implementaciones.

3. Simplificar las pruebas, ya que se pueden proporcionar dependencias simuladas (mocks).

En el contexto de Android, la DI es especialmente útil para administrar dependencias como repositorios, servicios y ViewModels.

¿Qué es Koin?

Koin es un framework ligero para la inyección de dependencias en Kotlin. Diseñado con un enfoque minimalista, Koin permite configurar y gestionar dependencias de manera declarativa y sencilla. Sus principales características son:

1. Simplicidad: No requiere generación de código ni anotaciones.

2. Modularidad: Permite dividir las dependencias en módulos reutilizables.

3. Compatibilidad: Funciona perfectamente con Jetpack Compose y Android.

Configuración de Koin en Jetpack Compose

En el archivo build.gradle del módulo, añade las dependencias necesarias:

implementation("io.insert-koin:koin-android:3.4.1")
implementation("io.insert-koin:koin-androidx-compose:3.4.1")

Implementación en el proyecto

1

Definir un módulo Koin

Crea un archivo Kotlin en el paquete di del proyecto para definir la inyección de dependencias. Por ejemplo:

AppModule.kt

val appModule = module {
    // Singleton del FirebaseFirestore
    single { FirebaseFirestore.getInstance() }
    // Singleton del respositorio de usuarios, se le inyecta el FirebaseFirestore creado en la sección anterior
    single<UserRepository> { UserFirestoreRepository(get()) }
    // Usamos factory para que proporcione una instancia del UseCase cada vez que se solicite
    factory { GetUsersUseCase(get()) }
    // Usamos factory para que proporcione una instancia del UseCase cada vez que se solicite
    factory { DeleteUserUseCase(get()) }
    // Crea el viewModel con las dependencias que tenga definidas
    viewModel { UsersScreenViewModel(get(), get()) }
}

2

Crear una clase Application para iniciar Koin

En el paquete base del proyecto, crea una clase que defina cómo se inicia la aplicación

MyUserApp.kt

class MyUserApp : Application() {
    override fun onCreate() {
        super.onCreate()
        startKoin {
            androidContext(this@MyUserApp)
            modules(appModule)
        }
    }
}

3

Actualiza el AndroidManifest.xml con la aplicación que acabamos de crear

Se debe poner el nombre de la clase que extiende Application en la propiedad android:name, precedida por un .

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    <application
        android:name=".MyUserApp"
        android:allowBackup="true"
        android:dataExtractionRules="@xml/data_extraction_rules"
        android:fullBackupContent="@xml/backup_rules"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:roundIcon="@mipmap/ic_launcher_round"
        android:supportsRtl="true"
        android:theme="@style/Theme.MyAndroidApp"
        tools:targetApi="31">

        ...
        
        </application>

</manifest>

4

Modifica la creación de los viewModel para que usen Koin

Simplementa hay que sustituir el método constructor de viewModel() a koinViewModel()

@Composable
fun UsersScreen(
    navController: NavController,
    // usersViewModel: usersViewModel = viewModel()
    usersViewModel: UsersViewModel = koinViewModel()
) {
    // Aquí iría la definición de la ventana de usuarios
}