Tareas con Hilt: no construyas lo que necesitas, pídelo

git clone https://github.com/rpversontec/practica-9-tareas-hilt.git
cd practica-9-tareas-hilt

package mx.tec.tareas.ui.state

import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.setValue
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import kotlinx.coroutines.launch
import mx.tec.tareas.data.TareasRepository
import mx.tec.tareas.domain.Tarea

class TareasViewModel : ViewModel() {

    // El ViewModel construye todo lo que necesita
    private val repo = TareasRepository()

    var tareas by mutableStateOf<List<Tarea>>(emptyList())
        private set

    var cargando by mutableStateOf(false)
        private set

    init { cargar() }

    fun cargar() = viewModelScope.launch {
        cargando = true
        tareas = repo.obtenerTareas()
        cargando = false
    }
}

package mx.tec.tareas.data

import mx.tec.tareas.domain.Tarea

class TareasRepository {

    // El repositorio construye su propia API
    private val api = ApiRemota()

    suspend fun obtenerTareas(): List<Tarea> = api.descargarTareas()
}

package mx.tec.tareas.data

import mx.tec.tareas.domain.Tarea

/** El enchufe: quien lo usa no sabe de dónde vienen las tareas. */
interface TareasRepository {
    suspend fun obtenerTareas(): List<Tarea>
}

/** CFE: la fuente de verdad, que le pregunta a la API. */
class TareasRepositoryReal(
    private val api: ApiRemota
) : TareasRepository {
    override suspend fun obtenerTareas() = api.descargarTareas()
}

/** La planta de emergencia: una tarea fija, al instante y sin red. */
class TareasRepositoryFalso : TareasRepository {
    override suspend fun obtenerTareas() = listOf(Tarea("Tarea de prueba", "Pruebas", "Nunca"))
}

package mx.tec.tareas.ui.state

import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.setValue
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import kotlinx.coroutines.launch
import mx.tec.tareas.data.TareasRepository
import mx.tec.tareas.domain.Tarea

class TareasViewModel(
    private val repo: TareasRepository
) : ViewModel() {

    var tareas by mutableStateOf<List<Tarea>>(emptyList())
        private set

    var cargando by mutableStateOf(false)
        private set

    init { cargar() }

    fun cargar() = viewModelScope.launch {
        cargando = true
        tareas = repo.obtenerTareas()
        cargando = false
    }
}

package mx.tec.tareas

import android.app.Application
import mx.tec.tareas.data.ApiRemota
import mx.tec.tareas.data.TareasRepository
import mx.tec.tareas.data.TareasRepositoryReal

/** Quién construye a quién, en un solo lugar. Como el de las prácticas 5 a 8. */
class AppContainer {
    private val api = ApiRemota()
    val tareasRepository: TareasRepository = TareasRepositoryReal(api)
}

/** Vive tanto como el proceso. Declarada en el manifiesto con `android:name`. */
class MiApp : Application() {
    val container = AppContainer()
}

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android">

    <!-- android:name conecta MiApp. Sin esta línea, el contenedor de la app nunca se crea. -->
    <application
        android:name=".MiApp"
        android:label="Tareas"
        android:supportsRtl="true"
        android:theme="@style/Theme.Tareas">
        <activity
            android:name=".MainActivity"
            android:exported="true">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>
</manifest>

package mx.tec.tareas.ui.state

import androidx.lifecycle.ViewModelProvider
import androidx.lifecycle.viewmodel.CreationExtras
import androidx.lifecycle.viewmodel.initializer
import androidx.lifecycle.viewmodel.viewModelFactory
import mx.tec.tareas.MiApp

/** Cómo se construye cada ViewModel: con las piezas que le da el contenedor. */
object AppViewModelProvider {

    val Factory = viewModelFactory {
        initializer { TareasViewModel(miApp().container.tareasRepository) }
    }
}

/** El atajo para llegar al contenedor desde dentro de un initializer. */
private fun CreationExtras.miApp(): MiApp =
    this[ViewModelProvider.AndroidViewModelFactory.APPLICATION_KEY] as MiApp

/** Con estado: el ViewModel lo arma la fábrica, con las piezas del contenedor. */
@Composable
fun PantallaTareas(vm: TareasViewModel = viewModel(factory = AppViewModelProvider.Factory)) {

val tareasRepository: TareasRepository = TareasRepositoryReal(api)

[versions]
agp = "9.3.1"
kotlin = "2.4.10"
ksp = "2.3.12"
hilt = "2.60.1"
hiltViewModelCompose = "1.4.0"
coreKtx = "1.19.0"
lifecycle = "2.11.0"
activityCompose = "1.13.0"
composeBom = "2026.08.00"

[libraries]
androidx-core-ktx = { group = "androidx.core", name = "core-ktx", version.ref = "coreKtx" }
androidx-lifecycle-runtime-ktx = { group = "androidx.lifecycle", name = "lifecycle-runtime-ktx", version.ref = "lifecycle" }
androidx-lifecycle-viewmodel-compose = { group = "androidx.lifecycle", name = "lifecycle-viewmodel-compose", version.ref = "lifecycle" }
androidx-activity-compose = { group = "androidx.activity", name = "activity-compose", version.ref = "activityCompose" }
androidx-compose-bom = { group = "androidx.compose", name = "compose-bom", version.ref = "composeBom" }
androidx-ui = { group = "androidx.compose.ui", name = "ui" }
androidx-ui-tooling = { group = "androidx.compose.ui", name = "ui-tooling" }
androidx-ui-tooling-preview = { group = "androidx.compose.ui", name = "ui-tooling-preview" }
androidx-material3 = { group = "androidx.compose.material3", name = "material3" }
androidx-material-icons-core = { group = "androidx.compose.material", name = "material-icons-core" }
hilt-android = { group = "com.google.dagger", name = "hilt-android", version.ref = "hilt" }
hilt-compiler = { group = "com.google.dagger", name = "hilt-compiler", version.ref = "hilt" }
hilt-lifecycle-viewmodel-compose = { group = "androidx.hilt", name = "hilt-lifecycle-viewmodel-compose", version.ref = "hiltViewModelCompose" }

[plugins]
android-application = { id = "com.android.application", version.ref = "agp" }
kotlin-compose = { id = "org.jetbrains.kotlin.plugin.compose", version.ref = "kotlin" }
ksp = { id = "com.google.devtools.ksp", version.ref = "ksp" }
hilt = { id = "com.google.dagger.hilt.android", version.ref = "hilt" }

plugins {
    alias(libs.plugins.android.application) apply false
    alias(libs.plugins.kotlin.compose) apply false
    alias(libs.plugins.ksp) apply false
    alias(libs.plugins.hilt) apply false
}

plugins {
    alias(libs.plugins.android.application)
    alias(libs.plugins.kotlin.compose)
    alias(libs.plugins.ksp)
    alias(libs.plugins.hilt)
}

android {
    namespace = "mx.tec.tareas"
    compileSdk = 37

    defaultConfig {
        applicationId = "mx.tec.tareas"
        minSdk = 24
        targetSdk = 37
        versionCode = 1
        versionName = "1.0"
    }

    compileOptions {
        sourceCompatibility = JavaVersion.VERSION_17
        targetCompatibility = JavaVersion.VERSION_17
    }

    buildFeatures { compose = true }
}

dependencies {
    implementation(platform(libs.androidx.compose.bom))
    implementation(libs.androidx.core.ktx)
    implementation(libs.androidx.lifecycle.runtime.ktx)
    implementation(libs.androidx.lifecycle.viewmodel.compose)
    implementation(libs.androidx.activity.compose)
    implementation(libs.androidx.ui)
    implementation(libs.androidx.ui.tooling.preview)
    implementation(libs.androidx.material3)
    implementation(libs.androidx.material.icons.core)
    debugImplementation(libs.androidx.ui.tooling)

    // Hilt: la librería + el generador de código (KSP, no kapt)
    implementation(libs.hilt.android)
    ksp(libs.hilt.compiler)
    implementation(libs.hilt.lifecycle.viewmodel.compose)
}

package mx.tec.tareas

import android.app.Application
import dagger.hilt.android.HiltAndroidApp

/** Pieza 1: la app avisa que usa Hilt. Aquí vive el contenedor que Hilt genera. */
@HiltAndroidApp
class MiApp : Application()

package mx.tec.tareas

import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.activity.enableEdgeToEdge
import dagger.hilt.android.AndroidEntryPoint
import mx.tec.tareas.ui.screens.PantallaTareas
import mx.tec.tareas.ui.theme.TareasTheme

/** Pieza 2: esta Activity puede recibir dependencias de Hilt. */
@AndroidEntryPoint
class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        enableEdgeToEdge()
        setContent {
            TareasTheme { PantallaTareas() }
        }
    }
}

package mx.tec.tareas.data

import kotlinx.coroutines.delay
import mx.tec.tareas.domain.Tarea
import javax.inject.Inject

/**
 * Un servidor de mentira: tarda 1.5 s y siempre responde lo mismo.
 * En una app real aquí iría Retrofit, como en la Práctica 4. Hoy no hace falta
 * internet: el tema es quién construye a quién, no la red.
 */
class ApiRemota @Inject constructor() {

    suspend fun descargarTareas(): List<Tarea> {
        delay(1500)
        return listOf(
            Tarea("Entregar la práctica 8", "Móviles", "Hoy"),
            Tarea("Estudiar para el parcial", "Cálculo", "Jueves"),
            Tarea("Revisar el pull request del equipo", "Reto", "Viernes"),
            Tarea("Leer el capítulo 3", "Ética", "Lunes")
        )
    }
}

package mx.tec.tareas.data

import mx.tec.tareas.domain.Tarea
import javax.inject.Inject

/** El enchufe: quien lo usa no sabe de dónde vienen las tareas. */
interface TareasRepository {
    suspend fun obtenerTareas(): List<Tarea>
}

/** CFE: la fuente de verdad, que le pregunta a la API. */
class TareasRepositoryReal @Inject constructor(
    private val api: ApiRemota
) : TareasRepository {
    override suspend fun obtenerTareas() = api.descargarTareas()
}

/** La planta de emergencia: una tarea fija, al instante y sin red. */
class TareasRepositoryFalso @Inject constructor() : TareasRepository {
    override suspend fun obtenerTareas() = listOf(Tarea("Tarea de prueba", "Pruebas", "Nunca"))
}

package mx.tec.tareas.di

import dagger.Binds
import dagger.Module
import dagger.hilt.InstallIn
import dagger.hilt.components.SingletonComponent
import mx.tec.tareas.data.TareasRepository
import mx.tec.tareas.data.TareasRepositoryReal

/**
 * Hilt no puede adivinar qué implementación va en una interfaz. Este módulo se
 * lo dice: "cuando alguien pida TareasRepository, dale TareasRepositoryReal".
 */
@Module
@InstallIn(SingletonComponent::class)
abstract class RepositorioModule {

    @Binds
    abstract fun bindTareasRepo(
        impl: TareasRepositoryReal
    ): TareasRepository
}

package mx.tec.tareas.ui.state

import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.setValue
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import dagger.hilt.android.lifecycle.HiltViewModel
import kotlinx.coroutines.launch
import mx.tec.tareas.data.TareasRepository
import mx.tec.tareas.domain.Tarea
import javax.inject.Inject

@HiltViewModel
class TareasViewModel @Inject constructor(
    private val repo: TareasRepository
) : ViewModel() {

    var tareas by mutableStateOf<List<Tarea>>(emptyList())
        private set

    var cargando by mutableStateOf(false)
        private set

    init { cargar() }

    fun cargar() = viewModelScope.launch {
        cargando = true
        tareas = repo.obtenerTareas()
        cargando = false
    }
}

/** Con estado: le pide a Hilt el ViewModel ya armado, con todo lo que necesita. */
@Composable
fun PantallaTareas(vm: TareasViewModel = hiltViewModel()) {

git switch -c experimento-e1

package mx.tec.tareas.di

import dagger.Binds
import dagger.Module
import dagger.hilt.InstallIn
import dagger.hilt.components.SingletonComponent
import mx.tec.tareas.data.TareasRepository
import mx.tec.tareas.data.TareasRepositoryFalso

/**
 * Hilt no puede adivinar qué implementación va en una interfaz. Este módulo se
 * lo dice: "cuando alguien pida TareasRepository, dale TareasRepositoryReal".
 */
@Module
@InstallIn(SingletonComponent::class)
abstract class RepositorioModule {

    @Binds
    abstract fun bindTareasRepo(
        impl: TareasRepositoryFalso
    ): TareasRepository
}

git add -A ; git commit -m "experimento-e1: el falso en toda la app"
git switch main

git commit -m "checkpoint d5: hilt en cinco piezas" -m "Co-Authored-By: Claude <noreply@anthropic.com>"