Avisos con imágenes: elegir, fotografiar y subir sin regalar los datos

git clone https://github.com/rpversontec/reto-imagenes-fastapi-docker.git
cd reto-imagenes-fastapi-docker
cp .env.example .env
docker compose up -d
bash smoke.sh

git clone https://github.com/rpversontec/practica-10-avisos-con-imagenes.git
cd practica-10-avisos-con-imagenes

[versions]
coil = "3.6.3"

[libraries]
coil-compose = { group = "io.coil-kt.coil3", name = "coil-compose", version.ref = "coil" }
coil-network-okhttp = { group = "io.coil-kt.coil3", name = "coil-network-okhttp", version.ref = "coil" }

    // Imágenes: Coil las baja y las pinta, con el mismo cliente que todo lo demás
    implementation(libs.coil.compose)
    implementation(libs.coil.network.okhttp)

package mx.tec.avisos.di

import android.content.Context
import coil3.ImageLoader
import coil3.network.okhttp.OkHttpNetworkFetcherFactory
import coil3.request.crossfade
import dagger.Module
import dagger.Provides
import dagger.hilt.InstallIn
import dagger.hilt.android.qualifiers.ApplicationContext
import dagger.hilt.components.SingletonComponent
import okhttp3.OkHttpClient
import javax.inject.Singleton

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

    /**
     * El que baja y pinta las imágenes, uno para toda la app.
     *
     * La línea que importa es la del cliente: Coil usa EL MISMO `OkHttpClient`
     * que Retrofit y el stream. Así cada imagen sale con `Authorization: Bearer`
     * puesto por el interceptor, y si el token venció, el authenticator lo
     * renueva — igual que con cualquier otra petición. Con un cliente propio,
     * Coil pediría las imágenes sin token y el servidor respondería 401.
     */
    @Provides
    @Singleton
    fun imageLoader(@ApplicationContext context: Context, cliente: OkHttpClient): ImageLoader =
        ImageLoader.Builder(context)
            .components { add(OkHttpNetworkFetcherFactory(callFactory = { cliente })) }
            .crossfade(true)
            .build()
}

package mx.tec.avisos

import android.app.Application
import coil3.ImageLoader
import coil3.PlatformContext
import coil3.SingletonImageLoader
import androidx.hilt.work.HiltWorkerFactory
import androidx.work.Configuration
import dagger.hilt.android.HiltAndroidApp
import mx.tec.avisos.notificaciones.Notificador
import mx.tec.avisos.trabajo.RevisarAvisosWorker
import javax.inject.Inject

/**
 * Vive tanto como el proceso. Declarada en el manifiesto con `android:name`.
 *
 * Ya no hay `AppContainer`: quién construye a quién está en `di/`, y Hilt
 * escribe el contenedor al compilar (Práctica 9).
 *
 * `Configuration.Provider`: WorkManager construye los workers, y por omisión
 * no sabe inyectarles nada. Con la fábrica de Hilt, sí. Por eso el manifiesto
 * apaga el arranque automático de WorkManager.
 *
 * `SingletonImageLoader.Factory`: lo mismo con Coil. Cada `AsyncImage` de la
 * app pide "el" ImageLoader, y aquí se le entrega el que armó Hilt.
 */
@HiltAndroidApp
class AvisosApplication : Application(), Configuration.Provider, SingletonImageLoader.Factory {

    @Inject lateinit var workerFactory: HiltWorkerFactory

    @Inject lateinit var imageLoader: ImageLoader

    @Inject lateinit var notificador: Notificador

    override val workManagerConfiguration: Configuration
        get() = Configuration.Builder().setWorkerFactory(workerFactory).build()

    override fun newImageLoader(context: PlatformContext): ImageLoader = imageLoader

    override fun onCreate() {
        super.onCreate()
        notificador.crearCanal()
        // El worker se programa una vez y queda programado aunque la app muera.
        RevisarAvisosWorker.programar(this)
    }
}

@Serializable
data class AvisoDto(
    val id: Int,
    val titulo: String,
    val cuerpo: String,
    val autor: String,
    val createdAt: String,
    /** La clave de la imagen en el servidor ("3f2a….jpg"), o null si el aviso no lleva. */
    val imagen: String? = null
)

package mx.tec.avisos.domain

/** Un aviso del tablón. Lo escribe un profesor; lo lee cualquiera con sesión. */
data class Aviso(
    val id: Int,
    val titulo: String,
    val cuerpo: String,
    val autor: String,
    val creadoEn: String,
    /** De dónde bajar la imagen, o null si el aviso no lleva. */
    val imagenUrl: String? = null
)

fun AvisoDto.toDomain() = Aviso(
    id = id,
    titulo = titulo,
    cuerpo = cuerpo,
    autor = autor,
    creadoEn = createdAt,
    // El servidor da la clave; la dirección completa la arma la app, que sabe a qué servidor habla.
    imagenUrl = imagen?.let { "${Network.BASE_URL}imagenes/$it" }
)

    nuevo: Boolean,
    modifier: Modifier = Modifier,
    imagen: Any? = null
) {

        if (imagen != null) {
            // Siempre 16:9, haya llegado la imagen o no: la lista no brinca cuando termina de bajar.
            // Mientras baja, y si falla, el mismo rectángulo de color. El 401 o el 404 se ven en el Logcat.
            AsyncImage(
                model = imagen,
                contentDescription = "Imagen del aviso",
                contentScale = ContentScale.Crop,
                placeholder = ColorPainter(MaterialTheme.colorScheme.surfaceContainerHighest),
                error = ColorPainter(MaterialTheme.colorScheme.surfaceContainerHighest),
                modifier = Modifier
                    .fillMaxWidth()
                    .aspectRatio(16f / 9f)
            )
        }

        nuevo = esReciente(aviso.creadoEn, ahora),
        imagen = aviso.imagenUrl,
        modifier = modifier

--> GET http://10.0.2.2:8000/api/imagenes/7ec3fc433d434894bca58ad2cf985d68.jpg
<-- 200 OK http://10.0.2.2:8000/api/imagenes/7ec3fc433d434894bca58ad2cf985d68.jpg (126ms, 48744-byte body)

adb shell run-as mx.tec.avisos rm -rf cache/image_cache

docker compose logs api

api-1  | INFO:     172.18.0.1:58326 - "GET /api/imagenes/e61f50f6a6204482a109e215c24871ad.jpg HTTP/1.1" 401 Unauthorized

[versions]
exifinterface = "1.4.2"

[libraries]
androidx-exifinterface = { group = "androidx.exifinterface", name = "exifinterface", version.ref = "exifinterface" }

    // Imágenes: Coil las baja y las pinta; ExifInterface lee cómo venía girada la foto
    implementation(libs.coil.compose)
    implementation(libs.coil.network.okhttp)
    implementation(libs.androidx.exifinterface)

package mx.tec.avisos.data.imagenes

import android.content.Context
import android.graphics.Bitmap
import android.graphics.BitmapFactory
import android.graphics.Matrix
import android.net.Uri
import android.provider.OpenableColumns
import android.util.Log
import androidx.exifinterface.media.ExifInterface
import dagger.hilt.android.qualifiers.ApplicationContext
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.withContext
import java.io.ByteArrayOutputStream
import java.io.IOException
import javax.inject.Inject
import kotlin.math.max
import kotlin.math.min

/** La imagen no se pudo leer: no existe, no es imagen, o el permiso para leerla ya caducó. */
class ImagenIlegible : IOException("No se pudo leer la imagen")

/**
 * Convierte la foto que eligió el usuario en lo que vale la pena mandar: un
 * JPEG de 1280 px por lado, como mucho, y sin metadatos.
 *
 * Una foto de teléfono pesa de 2 a 5 MB y mide 4000 px; en una tarjeta del
 * tablón se ve a 400. Mandarla tal cual es pagar con los datos del usuario
 * —y con la memoria del teléfono que la abra— píxeles que nadie va a ver.
 */
class CompresorDeImagen @Inject constructor(@ApplicationContext private val context: Context) {

    private val resolver get() = context.contentResolver

    /** Todo en `Dispatchers.IO`: leer y decodificar 4 MB en el hilo principal congela la pantalla. */
    suspend fun comprimir(uri: Uri): ByteArray = withContext(Dispatchers.IO) {
        // 1. Solo las medidas: con inJustDecodeBounds no se carga un solo píxel.
        val medidas = BitmapFactory.Options().apply { inJustDecodeBounds = true }
        resolver.openInputStream(uri)?.use { BitmapFactory.decodeStream(it, null, medidas) }
        if (medidas.outWidth <= 0) throw ImagenIlegible()

        // 2. Leerla ya reducida. inSampleSize = 2 lee uno de cada dos píxeles por lado
        //    (la cuarta parte de la memoria); se duplica mientras siga sobrando.
        var muestra = 1
        while (max(medidas.outWidth, medidas.outHeight) / (muestra * 2) >= LADO_MAX) muestra *= 2
        val leida = resolver.openInputStream(uri)?.use {
            BitmapFactory.decodeStream(it, null, BitmapFactory.Options().apply { inSampleSize = muestra })
        } ?: throw ImagenIlegible()

        // 3. Cómo venía girada. El teléfono guarda la foto "acostada" y anota en el
        //    EXIF cuánto hay que girarla para verla derecha. BitmapFactory no lo lee.
        val orientacion = resolver.openInputStream(uri)?.use {
            ExifInterface(it).getAttributeInt(ExifInterface.TAG_ORIENTATION, ExifInterface.ORIENTATION_NORMAL)
        } ?: ExifInterface.ORIENTATION_NORMAL

        // 4. El tamaño exacto y el giro, en una sola pasada.
        val escala = min(1f, LADO_MAX.toFloat() / max(leida.width, leida.height))
        val matriz = Matrix().apply {
            postScale(escala, escala)
            postRotate(grados(orientacion))
        }
        val lista = Bitmap.createBitmap(leida, 0, 0, leida.width, leida.height, matriz, true)

        // 5. Un JPEG nuevo. Bitmap.compress no escribe EXIF: la ubicación, el modelo
        //    del teléfono y la fecha de la foto original no viajan al servidor.
        val salida = ByteArrayOutputStream()
        lista.compress(Bitmap.CompressFormat.JPEG, CALIDAD, salida)
        val jpeg = salida.toByteArray()

        Log.i(TAG, "${medidas.outWidth}x${medidas.outHeight}, ${kb(tamano(uri))} → ${lista.width}x${lista.height}, ${kb(jpeg.size.toLong())}")
        jpeg
    }

    /** Lo que pesa el archivo original, según quien lo comparte (la galería o la cámara). */
    private fun tamano(uri: Uri): Long =
        resolver.query(uri, arrayOf(OpenableColumns.SIZE), null, null, null)?.use { c ->
            if (c.moveToFirst() && !c.isNull(0)) c.getLong(0) else -1L
        } ?: -1L

    private fun kb(bytes: Long) = if (bytes < 0) "? KB" else "${bytes / 1024} KB"

    private fun grados(orientacion: Int): Float = when (orientacion) {
        ExifInterface.ORIENTATION_ROTATE_90 -> 90f
        ExifInterface.ORIENTATION_ROTATE_180 -> 180f
        ExifInterface.ORIENTATION_ROTATE_270 -> 270f
        else -> 0f
    }

    private companion object {
        const val TAG = "Compresor"
        const val LADO_MAX = 1280
        const val CALIDAD = 80
    }
}

    /** Multipart: el archivo viaja como una "parte" del cuerpo, como en un formulario web con `<input type="file">`. */
    @Multipart
    @POST("imagenes")
    suspend fun subirImagen(@Part archivo: MultipartBody.Part): ImagenDto

/** `imagen`: la clave que devolvió `POST /imagenes`. Con null no se manda (explicitNulls = false). */
@Serializable
data class NuevoAvisoBody(val titulo: String, val cuerpo: String, val imagen: String? = null)

/** Lo que devuelve el servidor al recibir una imagen. */
@Serializable
data class ImagenDto(val id: String, val tipo: String, val bytes: Int)

    /** `imagen`: la clave que devolvió `ImagenesRepository.subir`, o null si el aviso no lleva. */
    suspend fun publicar(titulo: String, cuerpo: String, imagen: String? = null): Aviso =
        api.crearAviso(NuevoAvisoBody(titulo.trim(), cuerpo.trim(), imagen)).toDomain()

package mx.tec.avisos.data

import android.net.Uri
import mx.tec.avisos.data.imagenes.CompresorDeImagen
import mx.tec.avisos.data.remote.AvisosApi
import okhttp3.MediaType.Companion.toMediaType
import okhttp3.MultipartBody
import okhttp3.RequestBody.Companion.toRequestBody
import javax.inject.Inject
import javax.inject.Singleton

/**
 * Subir una imagen es dos pasos, y ninguno es de la pantalla: reducirla en el
 * teléfono y mandarla. A cambio, el servidor devuelve una clave, y esa clave
 * —no la imagen— es lo que viaja en el aviso.
 */
@Singleton
class ImagenesRepository @Inject constructor(
    private val api: AvisosApi,
    private val compresor: CompresorDeImagen
) {

    /** Devuelve la clave que el servidor le dio ("3f2a….jpg"). */
    suspend fun subir(uri: Uri): String {
        val jpeg = compresor.comprimir(uri)
        // Una "parte" del cuerpo multipart: el nombre del campo que espera el servidor,
        // un nombre de archivo, y los bytes con su tipo.
        val parte = MultipartBody.Part.createFormData(
            "archivo",
            "aviso.jpg",
            jpeg.toRequestBody("image/jpeg".toMediaType())
        )
        return api.subirImagen(parte).id
    }
}

package mx.tec.avisos.ui.state

import android.net.Uri
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.avisos.data.AvisosRepository
import mx.tec.avisos.data.ImagenesRepository
import mx.tec.avisos.data.imagenes.ImagenIlegible
import mx.tec.avisos.domain.AvisoValidator
import retrofit2.HttpException
import java.io.IOException
import javax.inject.Inject

/**
 * `etapa` es lo que se está haciendo, o null si no se está haciendo nada.
 * Con imagen, publicar es dos peticiones, y el usuario merece saber en cuál va.
 */
data class PublicarUiState(
    val titulo: String = "",
    val cuerpo: String = "",
    val imagen: Uri? = null,
    val etapa: String? = null,
    val error: String? = null
) {
    val enviando: Boolean = etapa != null

    val puedePublicar: Boolean = AvisoValidator.esValido(titulo, cuerpo) && !enviando

    val caracteresRestantes: Int = AvisoValidator.CUERPO_MAX - cuerpo.trim().length
}

@HiltViewModel
class PublicarViewModel @Inject constructor(
    private val avisos: AvisosRepository,
    private val imagenes: ImagenesRepository
) : ViewModel() {

    var uiState by mutableStateOf(PublicarUiState())
        private set

    fun onTituloChange(texto: String) {
        if (texto.length <= AvisoValidator.TITULO_MAX) uiState = uiState.copy(titulo = texto, error = null)
    }

    fun onCuerpoChange(texto: String) {
        if (texto.length <= AvisoValidator.CUERPO_MAX) uiState = uiState.copy(cuerpo = texto, error = null)
    }

    fun onImagenElegida(uri: Uri) {
        uiState = uiState.copy(imagen = uri, error = null)
    }

    fun quitarImagen() {
        uiState = uiState.copy(imagen = null, error = null)
    }

    /** `alTerminar` se llama solo si el servidor aceptó el aviso. Un error se queda a la vista. */
    fun publicar(alTerminar: () -> Unit) {
        if (!uiState.puedePublicar) return
        viewModelScope.launch {
            val imagen = uiState.imagen
            try {
                // Primero la imagen: si falla, no queda un aviso publicado sin ella.
                val clave = if (imagen != null) {
                    uiState = uiState.copy(etapa = "Subiendo la imagen…", error = null)
                    imagenes.subir(imagen)
                } else {
                    null
                }
                uiState = uiState.copy(etapa = "Publicando…", error = null)
                avisos.publicar(uiState.titulo, uiState.cuerpo, clave)
                uiState = uiState.copy(etapa = null)
                alTerminar()
            } catch (e: ImagenIlegible) {
                uiState = uiState.copy(etapa = null, error = "No se pudo leer esa imagen. Elige otra.")
            } catch (e: IOException) {
                uiState = uiState.copy(etapa = null, error = "No hay conexión. El aviso no se publicó.")
            } catch (e: HttpException) {
                uiState = uiState.copy(etapa = null, error = mensajeDe(e))
            }
        }
    }
}

    onCuerpoChange: (String) -> Unit,
    onGaleria: () -> Unit,
    onQuitarImagen: () -> Unit,
    onPublicar: () -> Unit,

                texto = uiState.etapa ?: "Publicar",

            // La imagen es opcional: una forma de conseguirla, y una de quitarla.
            Row(
                verticalAlignment = Alignment.CenterVertically,
                horizontalArrangement = Arrangement.spacedBy(espaciado.sm)
            ) {
                OutlinedButton(onClick = onGaleria, enabled = !uiState.enviando) {
                    Icon(painterResource(R.drawable.ic_galeria), contentDescription = null, modifier = Modifier.size(18.dp))
                    Spacer(Modifier.width(espaciado.sm))
                    Text("Galería")
                }
                if (uiState.imagen != null) {
                    TextButton(onClick = onQuitarImagen, enabled = !uiState.enviando) { Text("Quitar") }
                }
            }

                cuando = "ahora",
                nuevo = true,
                // La foto local, antes de subirla: la misma tarjeta, con una Uri en vez de una URL.
                imagen = uiState.imagen
            )

<?xml version="1.0" encoding="utf-8"?>
<!-- Elegir una imagen que ya está en el teléfono. -->
<vector xmlns:android="http://schemas.android.com/apk/res/android"
    android:width="24dp"
    android:height="24dp"
    android:viewportWidth="24"
    android:viewportHeight="24">
    <path android:strokeColor="#FF000000" android:strokeWidth="2" android:strokeLineCap="round" android:strokeLineJoin="round" android:fillColor="#00000000" android:pathData="M5,4h14a2,2 0 0,1 2,2v12a2,2 0 0,1 -2,2H5a2,2 0 0,1 -2,-2V6a2,2 0 0,1 2,-2z" />
    <path android:strokeColor="#FF000000" android:strokeWidth="2" android:strokeLineCap="round" android:strokeLineJoin="round" android:fillColor="#00000000" android:pathData="M3,16l5,-5l4,4l3,-3l6,6" />
    <path android:strokeColor="#FF000000" android:strokeWidth="2" android:strokeLineCap="round" android:strokeLineJoin="round" android:fillColor="#00000000" android:pathData="M14,8.5a1.5,1.5 0 1,0 3,0a1.5,1.5 0 1,0 -3,0" />
</vector>

            // El selector de fotos del sistema: no pide permiso, porque el usuario elige
            // y la app solo recibe esa imagen. Devuelve null si el usuario se arrepiente.
            val galeria = rememberLauncherForActivityResult(ActivityResultContracts.PickVisualMedia()) { uri ->
                if (uri != null) viewModel.onImagenElegida(uri)
            }

                onGaleria = {
                    galeria.launch(PickVisualMediaRequest(ActivityResultContracts.PickVisualMedia.ImageOnly))
                },
                onQuitarImagen = viewModel::quitarImagen,

4032x3024, 2082 KB → 960x1280, 34 KB
--> POST http://10.0.2.2:8000/api/imagenes (35951-byte body)
<-- 201 Created http://10.0.2.2:8000/api/imagenes (89ms, 79-byte body)
--> POST http://10.0.2.2:8000/api/avisos (150-byte body)
<-- 201 Created http://10.0.2.2:8000/api/avisos (82ms, 214-byte body)

        <!--
          Le presta a la cámara un archivo de esta app para que escriba la foto.
          La autoridad es el nombre con que se piden las direcciones (FotosTemporales);
          exported="false" + grantUriPermissions: nadie entra, salvo a quien se le preste.
        -->
        <provider
            android:name="androidx.core.content.FileProvider"
            android:authorities="${applicationId}.fotos"
            android:exported="false"
            android:grantUriPermissions="true">
            <meta-data
                android:name="android.support.FILE_PROVIDER_PATHS"
                android:resource="@xml/rutas_de_fotos" />
        </provider>

<?xml version="1.0" encoding="utf-8"?>
<!--
  Las carpetas que FileProvider puede prestar a otra app. Solo una: files/fotos/,
  la de FotosTemporales. Todo lo demás de la app sigue siendo privado.
-->
<paths>
    <files-path name="fotos" path="fotos/" />
</paths>

package mx.tec.avisos.data.imagenes

import android.content.Context
import android.net.Uri
import androidx.core.content.FileProvider
import dagger.hilt.android.qualifiers.ApplicationContext
import java.io.File
import javax.inject.Inject

/**
 * Los archivos donde escribe la cámara. La cámara es OTRA app: no puede
 * escribir en las carpetas privadas de esta. Se le presta una dirección
 * `content://` con permiso de escritura para ese único archivo — eso es lo que
 * hace `FileProvider` — y la foto queda en la carpeta de la app, no en la galería.
 *
 * En `filesDir` y no en `cacheDir`: el caché lo vacía el SISTEMA cuando a otra
 * app le falta espacio, y la que suele pedirlo es justo la cámara, al guardar.
 * Al escribir esta práctica pasó así: la foto se perdía entre el disparo y el
 * regreso. Lo de `filesDir` solo lo borra la app, y por eso existe `limpiar()`.
 */
class FotosTemporales @Inject constructor(@ApplicationContext private val context: Context) {

    // La misma carpeta que declara res/xml/rutas_de_fotos.xml. Si no coinciden, FileProvider se niega.
    private val carpeta: File get() = File(context.filesDir, "fotos").apply { mkdirs() }

    /** Un archivo vacío para la próxima foto, y la dirección que se le presta a la cámara. */
    fun nueva(): Uri {
        val archivo = File.createTempFile("foto-", ".jpg", carpeta)
        return FileProvider.getUriForFile(context, "${context.packageName}.fotos", archivo)
    }

    /** Ya se subió: las fotos originales no tienen por qué quedarse ocupando espacio. */
    fun limpiar() {
        carpeta.listFiles()?.forEach { it.delete() }
    }
}

@HiltViewModel
class PublicarViewModel @Inject constructor(
    private val avisos: AvisosRepository,
    private val imagenes: ImagenesRepository,
    private val fotos: FotosTemporales
) : ViewModel() {

    /** Dónde va a escribir la cámara. Lo crea quien sabe de archivos, no la pantalla. */
    fun nuevaFoto(): Uri = fotos.nueva()

                avisos.publicar(uiState.titulo, uiState.cuerpo, clave)
                fotos.limpiar()

    onGaleria: () -> Unit,
    onCamara: () -> Unit,
    onQuitarImagen: () -> Unit,

                OutlinedButton(onClick = onCamara, enabled = !uiState.enviando) {
                    Icon(painterResource(R.drawable.ic_camara), contentDescription = null, modifier = Modifier.size(18.dp))
                    Spacer(Modifier.width(espaciado.sm))
                    Text("Cámara")
                }

<?xml version="1.0" encoding="utf-8"?>
<!-- Tomar una foto con la app de cámara. -->
<vector xmlns:android="http://schemas.android.com/apk/res/android"
    android:width="24dp"
    android:height="24dp"
    android:viewportWidth="24"
    android:viewportHeight="24">
    <path android:strokeColor="#FF000000" android:strokeWidth="2" android:strokeLineCap="round" android:strokeLineJoin="round" android:fillColor="#00000000" android:pathData="M4,7h3l2,-3h6l2,3h3a1,1 0 0,1 1,1v11a1,1 0 0,1 -1,1H4a1,1 0 0,1 -1,-1V8a1,1 0 0,1 1,-1z" />
    <path android:strokeColor="#FF000000" android:strokeWidth="2" android:strokeLineCap="round" android:strokeLineJoin="round" android:fillColor="#00000000" android:pathData="M8.5,13.5a3.5,3.5 0 1,0 7,0a3.5,3.5 0 1,0 -7,0" />
</vector>

            // La cámara no devuelve la foto: la escribe donde se le dijo y responde true o false.
            // Hay que recordar DÓNDE, y recordarlo aunque Android mate el proceso mientras la
            // cámara está abierta. Por eso rememberSaveable, y no remember.
            var fotoPendiente by rememberSaveable { mutableStateOf<Uri?>(null) }
            val camara = rememberLauncherForActivityResult(ActivityResultContracts.TakePicture()) { tomada ->
                val uri = fotoPendiente
                if (tomada && uri != null) viewModel.onImagenElegida(uri)
                fotoPendiente = null
            }

                onCamara = {
                    val uri = viewModel.nuevaFoto()
                    fotoPendiente = uri
                    camara.launch(uri)
                },

adb shell am kill mx.tec.avisos

package mx.tec.avisos.ui.state

import android.net.Uri
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.setValue
import androidx.lifecycle.SavedStateHandle
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import dagger.hilt.android.lifecycle.HiltViewModel
import kotlinx.coroutines.launch
import mx.tec.avisos.data.AvisosRepository
import mx.tec.avisos.data.ImagenesRepository
import mx.tec.avisos.data.imagenes.FotosTemporales
import mx.tec.avisos.data.imagenes.ImagenIlegible
import mx.tec.avisos.domain.AvisoValidator
import retrofit2.HttpException
import java.io.IOException
import javax.inject.Inject

/**
 * `etapa` es lo que se está haciendo, o null si no se está haciendo nada.
 * Con imagen, publicar es dos peticiones, y el usuario merece saber en cuál va.
 */
data class PublicarUiState(
    val titulo: String = "",
    val cuerpo: String = "",
    val imagen: Uri? = null,
    val etapa: String? = null,
    val error: String? = null
) {
    val enviando: Boolean = etapa != null

    val puedePublicar: Boolean = AvisoValidator.esValido(titulo, cuerpo) && !enviando

    val caracteresRestantes: Int = AvisoValidator.CUERPO_MAX - cuerpo.trim().length
}

/**
 * `SavedStateHandle` lo pone Hilt, sin pedirlo en ningún módulo. Lo que se
 * guarda ahí sobrevive a que Android mate el proceso mientras el usuario está
 * en la cámara, y vuelve cuando el sistema recrea la pantalla.
 */
@HiltViewModel
class PublicarViewModel @Inject constructor(
    private val avisos: AvisosRepository,
    private val imagenes: ImagenesRepository,
    private val fotos: FotosTemporales,
    private val guardado: SavedStateHandle
) : ViewModel() {

    var uiState by mutableStateOf(
        PublicarUiState(
            titulo = guardado[TITULO] ?: "",
            cuerpo = guardado[CUERPO] ?: "",
            imagen = guardado[IMAGEN]
        )
    )
        private set

    /** Todo cambio de lo que el usuario escribió o eligió pasa por aquí, y queda guardado. */
    private fun editar(nuevo: PublicarUiState) {
        uiState = nuevo
        guardado[TITULO] = nuevo.titulo
        guardado[CUERPO] = nuevo.cuerpo
        guardado[IMAGEN] = nuevo.imagen
    }

    fun onTituloChange(texto: String) {
        if (texto.length <= AvisoValidator.TITULO_MAX) editar(uiState.copy(titulo = texto, error = null))
    }

    fun onCuerpoChange(texto: String) {
        if (texto.length <= AvisoValidator.CUERPO_MAX) editar(uiState.copy(cuerpo = texto, error = null))
    }

    fun onImagenElegida(uri: Uri) {
        editar(uiState.copy(imagen = uri, error = null))
    }

    fun quitarImagen() {
        editar(uiState.copy(imagen = null, error = null))
    }

    /** Dónde va a escribir la cámara. Lo crea quien sabe de archivos, no la pantalla. */
    fun nuevaFoto(): Uri = fotos.nueva()

    /** `alTerminar` se llama solo si el servidor aceptó el aviso. Un error se queda a la vista. */
    fun publicar(alTerminar: () -> Unit) {
        if (!uiState.puedePublicar) return
        viewModelScope.launch {
            val imagen = uiState.imagen
            try {
                // Primero la imagen: si falla, no queda un aviso publicado sin ella.
                val clave = if (imagen != null) {
                    uiState = uiState.copy(etapa = "Subiendo la imagen…", error = null)
                    imagenes.subir(imagen)
                } else {
                    null
                }
                uiState = uiState.copy(etapa = "Publicando…", error = null)
                avisos.publicar(uiState.titulo, uiState.cuerpo, clave)
                fotos.limpiar()
                uiState = uiState.copy(etapa = null)
                alTerminar()
            } catch (e: ImagenIlegible) {
                uiState = uiState.copy(etapa = null, error = "No se pudo leer esa imagen. Elige otra.")
            } catch (e: IOException) {
                uiState = uiState.copy(etapa = null, error = "No hay conexión. El aviso no se publicó.")
            } catch (e: HttpException) {
                uiState = uiState.copy(etapa = null, error = mensajeDe(e))
            }
        }
    }

    private companion object {
        const val TITULO = "titulo"
        const val CUERPO = "cuerpo"
        const val IMAGEN = "imagen"
    }
}

4032x3024, 2082 KB → 960x1280, 34 KB

        const val LADO_MAX = 8000
        const val CALIDAD = 100

4032x3024, 2095 KB → 4032x3024, 3676 KB
--> POST http://10.0.2.2:8000/api/imagenes (3765422-byte body)
<-- 413 Request Entity Too Large http://10.0.2.2:8000/api/imagenes (1439ms, 140-byte body)

        // 413, 415, 500…: si el servidor explicó qué pasó, eso es lo que hay que mostrar.
        else -> mensaje ?: "El servidor respondió ${e.code()}."

git commit -m "checkpoint c4: sobrevive a la muerte del proceso" -m "Co-Authored-By: Claude <noreply@anthropic.com>"