Del escritorio al móvil

@Composable
fun ContadorPedidos() {
    // 1. remember: vive solo mientras exista esta composición.
    //    Se pierde al rotar.
    var borrador by remember { mutableStateOf("") }

    // 2. rememberSaveable: sobrevive a rotaciones e incluso a la
    //    muerte del proceso (viaja en un Bundle del sistema).
    var filtro by rememberSaveable { mutableStateOf("") }

    Column {
        OutlinedTextField(
            value = filtro,
            onValueChange = { filtro = it },
            label = { Text("Buscar pedido") }
        )
    }
}

class PedidosViewModel : ViewModel() {
    private val _pedidos = MutableStateFlow<List<Pedido>>(vacio())
    val pedidos: StateFlow<List<Pedido>> = _pedidos.asStateFlow()

    init {
        // Carga inicial: si el usuario rota a mitad, el resultado
        // ya está aquí cuando la pantalla nueva recolecte el flujo.
        viewModelScope.launch {
            _pedidos.value = repositorio.obtenerPedidos()
        }
    }
}

@Composable
fun ListadoScreen(viewModel: PedidosViewModel = viewModel()) {
    val pedidos by viewModel.pedidos.collectAsStateWithLifecycle()
    // ...
}

@Composable
fun PanelPedidos() {
    val config = LocalConfiguration.current
    if (config.screenWidthDp >= 600) {
        Fila { Listado(); Detalle() }   // tablet / horizontal
    } else {
        Column { Listado() }            // teléfono vertical
    }
}

@Composable
fun PedidosScreen(viewModel: PedidosViewModel = viewModel()) {
    // collectAsStateWithLifecycle suspende la recolección cuando la
    // pantalla pasa a segundo plano y la reanuda al volver.
    val estado by viewModel.estado.collectAsStateWithLifecycle()

    when (estado) {
        is UiState.Cargando -> Indicador()
        is UiState.Exito   -> Listado(estado.pedidos)
        is UiState.Error   -> AvisoError(estado.mensaje)
    }
}

@Composable
fun CronometroPedidos() {
    var segundos by remember { mutableIntStateOf(0) }

    LaunchedEffect(Unit) {
        // Nace con la composición y muere con ella: si la pantalla
        // sale de escena, la corrutina se cancela sola.
        while (true) {
            delay(1_000); segundos++
        }
    }
    Text("Pedido en camino: ${segundos}s")
}

DisposableEffect(lifecycleOwner) {
    val observador = LifecycleEventObserver { _, evento ->
        registrar("Evento: $evento")
    }
    lifecycleOwner.lifecycle.addObserver(observador)
    onDispose {
        lifecycleOwner.lifecycle.removeObserver(observador)
    }
}

@Composable
fun AppPedidos() {
    val navController = rememberNavController()

    NavHost(navController, startDestination = "listado") {
        composable("listado") {
            ListadoScreen(
                alAbrir = { id -> navController.navigate("detalle/$id") },
                alNuevo = { navController.navigate("nuevo") }
            )
        }
        composable(
            route = "detalle/{id}",
            arguments = listOf(navArgument("id") { type = NavType.LongType })
        ) { entrada ->
            DetalleScreen(pedidoId = entrada.arguments!!.getLong("id"))
        }
        composable("nuevo") {
            NuevoPedidoScreen(alGuardar = { navController.popBackStack() })
        }
    }
}

navController.navigate("listado") {
    popUpTo("ingreso") { inclusive = true }  // borra la pantalla de ingreso
}

composable(
    "detalle/{id}",
    deepLinks = listOf(navDeepLink { uriPattern = "pedidos://pedido/{id}" })
) { /* ... */ }

// Capa de red: contrato del API
interface PedidosApi {
    @GET("pedidos")
    suspend fun listar(): List<PedidoDto>

    @POST("pedidos")
    suspend fun crear(@Body pedido: PedidoNuevoDto): PedidoDto
}

// DTOs: espejo exacto del JSON que viaja (como tus contratos OpenAPI)
@Serializable
data class PedidoDto(
    val id: Long,
    val cliente: String,
    val total: Double,
    val estado: String
)

val api = Retrofit.Builder()
    .baseUrl("https://api.pedidos.pe/")
    // Interceptor: añade el token de sesión a cada petición (como tu filtro HTTP)
    .client(
        OkHttpClient.Builder()
            .addInterceptor { cadena ->
                val peticion = cadena.request().newBuilder()
                    .addHeader("Authorization", "Bearer ${sesion.token()}")
                    .build()
                cadena.proceed(peticion)
            }
            .build()
    )
    .addConverterFactory(json.asConverterFactory("application/json".toMediaType()))
    .build()
    .create(PedidosApi::class.java)

// Estado de pantalla: un tipo sellado evita estados imposibles
sealed interface UiState {
    data object Cargando : UiState
    data class Exito(val pedidos: List<PedidoDto>) : UiState
    data class Error(val mensaje: String) : UiState
}

class PedidosViewModel(private val repo: PedidosRepositorio) : ViewModel() {
    private val _estado = MutableStateFlow<UiState>(UiState.Cargando)
    val estado: StateFlow<UiState> = _estado.asStateFlow()

    fun cargar() = viewModelScope.launch {
        _estado.value = UiState.Cargando
        _estado.value = try {
            UiState.Exito(repo.listar())
        } catch (e: IOException) {
            UiState.Error("Sin conexión. Reintenta.")
        } catch (e: HttpException) {
            UiState.Error("El servidor respondió ${e.code()}")
        }
    }
}

val Context.sesionStore by preferencesDataStore(name = "sesion")

class SesionRepositorio(private val contexto: Context) {
    private val CLAVE_TOKEN = stringPreferencesKey("token")

    val token: Flow<String?> =
        contexto.sesionStore.data.map { it[CLAVE_TOKEN] }

    suspend fun guardar(token: String) {
        contexto.sesionStore.edit { it[CLAVE_TOKEN] = token }
    }

    suspend fun cerrarSesion() {
        contexto.sesionStore.edit { it.remove(CLAVE_TOKEN) }
    }
}

@Entity(tableName = "pedidos")
data class PedidoEntidad(
    @PrimaryKey val id: Long,
    val cliente: String,
    val total: Double,
    val estado: String
)

@Dao
interface PedidoDao {
    // Consulta viva: emite la lista actual y CADA vez que cambie
    @Query("SELECT * FROM pedidos ORDER BY id DESC")
    fun observarTodos(): Flow<List<PedidoEntidad>>

    @Upsert
    suspend fun guardar(pedidos: List<PedidoEntidad>)
}

@Database(entities = [PedidoEntidad::class], version = 1)
abstract class AppBaseDatos : RoomDatabase() {
    abstract fun pedidoDao(): PedidoDao
}

class PedidosRepositorio(private val api: PedidosApi, private val dao: PedidoDao) {

    fun observar(): Flow<List<PedidoEntidad>> = dao.observarTodos()

    suspend fun sincronizar() {
        runCatching { dao.guardar(api.listar().map { it.aEntidad() }) }
    }
}

<manifest ...>
    <uses-permission android:name="android.permission.INTERNET" />
    <uses-permission android:name="android.permission.CAMERA" />
    <application ...></application>
</manifest>

@Composable
fun PantallaFoto(alTenerPermiso: () -> Unit) {
    val contexto = LocalContext.current

    val pedirCamara = rememberLauncherForActivityResult(
        ActivityResultContracts.RequestPermission()
    ) { concedido ->
        if (concedido) alTenerPermiso()
        // si no: mostrar explicación y botón hacia ajustes
    }

    Button(onClick = {
        val estado = ContextCompat.checkSelfPermission(
            contexto, Manifest.permission.CAMERA)
        if (estado == PackageManager.PERMISSION_GRANTED) alTenerPermiso()
        else pedirCamara.launch(Manifest.permission.CAMERA)
    }) {
        Text("Tomar foto del pedido")
    }
}

@Composable
fun VistaPrevia(lifecycleOwner: LifecycleOwner = LocalLifecycleOwner.current) {
    val proveedor = remember { ProcessCameraProvider.getInstance(contexto) }

    AndroidView(
        factory = { ctx ->
            val vista = PreviewView(ctx)
            proveedor.addListener({
                val camara = proveedor.get()
                val preview = Preview.Builder().build().also {
                    it.setSurfaceProvider(vista.surfaceProvider)
                }
                camara.unbindAll()
                camara.bindToLifecycle(lifecycleOwner,
                    CameraSelector.DEFAULT_BACK_CAMERA, preview)
            }, ContextCompat.getMainExecutor(ctx))
            vista
        },
        modifier = Modifier.fillMaxSize()
    )
}

val captura = remember { ImageCapture.Builder().build() }

// al pulsar «Registrar entrega»:
val archivo = File(contexto.filesDir, "entrega_${System.currentTimeMillis()}.jpg")
val opciones = ImageCapture.OutputFileOptions.Builder(archivo).build()

captura.takePicture(opciones, executor,
    object : ImageCapture.OnImageSavedCallback {
        override fun onImageSaved(r: ImageCapture.OutputFileResults) {
            viewModel.adjuntarEvidencia(archivo.absolutePath)
        }
        override fun onError(e: ImageCaptureException) { avisar(e) }
    })

<uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />

fun FusedLocationProviderClient.flujoUbicaciones(): Flow<Location> =
    callbackFlow {
        val peticion = LocationRequest.Builder(
            Priority.PRIORITY_HIGH_ACCURACY, 5_000L  // cada 5 s
        ).build()

        val callback = object : LocationCallback() {
            override fun onLocationResult(r: LocationResult) {
                r.lastLocation?.let { trySend(it) }
            }
        }
        requestLocationUpdates(peticion, callback, Looper.getMainLooper())

        // awaitClose corre al cancelar el flujo (pantalla oculta, ViewModel muerto)
        awaitClose { removeLocationUpdates(callback) }
    }

class RepartoViewModel(
    private val cliente: FusedLocationProviderClient
) : ViewModel() {

    @OptIn(ExperimentalCoroutinesApi::class)
    val ubicacion: StateFlow<Location?> = cliente
        .flujoUbicaciones()
        .flowWithLifecycle(ProcessLifecycleOwner.get().lifecycle)
        .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5_000), null)
}

@Composable
fun Listado(pedidos: List<PedidoEntidad>, alAbrir: (Long) -> Unit) {
    LazyColumn(verticalArrangement = Arrangement.spacedBy(8.dp)) {
        items(
            items = pedidos,
            key = { it.id },          // identidad estable: animaciones y estado correctos
            contentType = { "pedido" } // ayuda al reciclaje
        ) { pedido ->
            TarjetaPedido(pedido) { alAbrir(pedido.id) }
        }
    }
}

@Composable
fun TarjetaPedido(pedido: PedidoEntidad, onClick: () -> Unit) {
    Card(onClick = onClick, modifier = Modifier.fillMaxWidth()) {
        Column(Modifier.padding(16.dp)) {
            Text("#${pedido.id} · ${pedido.cliente}",
                 style = MaterialTheme.typography.titleMedium)
            Text("S/. ${"%.2f".format(pedido.total)} — ${pedido.estado}",
                 style = MaterialTheme.typography.bodyMedium,
                 color = MaterialTheme.colorScheme.secondary)
        }
    }
}

LazyVerticalGrid(
    columns = GridCells.Fixed(2),
    contentPadding = PaddingValues(8.dp),
    horizontalArrangement = Arrangement.spacedBy(8.dp),
    verticalArrangement = Arrangement.spacedBy(8.dp)
) {
    items(productos, key = { it.codigo }) { producto ->
        TarjetaProducto(producto)
    }
}

class SincronizadorPedidos(contexto: Context, params: WorkerParameters) :
    CoroutineWorker(contexto, params) {

    override suspend fun doWork(): Result {
        return try {
            repositorio.sincronizar()          // sube lo guardado sin conexión
            Result.success()
        } catch (e: IOException) {
            Result.retry()                      // reintenta con backoff exponencial
        } catch (e: Exception) {
            Result.failure()
        }
    }
}

// Programación (por ejemplo, al cerrar el formulario):
val peticion = OneTimeWorkRequestBuilder<SincronizadorPedidos>()
    .setConstraints(
        Constraints.Builder().setRequiredNetworkType(NetworkType.CONNECTED).build()
    )
    .setBackoffCriteria(BackoffPolicy.EXPONENTIAL, 30_000L, TimeUnit.MILLISECONDS)
    .build()

WorkManager.getInstance(contexto).enqueue(peticion)

fun crearCanal(contexto: Context) {
    val canal = NotificationChannel(
        "pedidos", "Estado de pedidos", NotificationManager.IMPORTANCE_DEFAULT
    ).apply { description = "Avisos cuando cambia tu pedido" }
    contexto.getSystemService(NotificationManager::class.java)
        .createNotificationChannel(canal)
}

fun avisarPedidoListo(contexto: Context, pedidoId: Long) {
    val intento = Intent(contexto, MainActivity::class.java).apply {
        data = Uri.parse("pedidos://pedido/$pedidoId")   // deep link del capítulo 4
    }
    val pendiente = PendingIntent.getActivity(
        contexto, pedidoId.toInt(), intento,
        PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
    )
    val aviso = NotificationCompat.Builder(contexto, "pedidos")
        .setSmallIcon(R.drawable.ic_pedido)
        .setContentTitle("Tu pedido está listo")
        .setContentText("Pedido #$pedidoId salió a reparto")
        .setContentIntent(pendiente)
        .setAutoCancel(true)
        .build()

    NotificationManagerCompat.from(contexto).notify(pedidoId.toInt(), aviso)
}

// app/build.gradle.kts
android {
    signingConfigs {
        create("release") {
            storeFile = file(System.getenv("KEYSTORE") ?: "pedidos.jks")
            storePassword = System.getenv("KEYSTORE_PASS")
            keyAlias = "pedidos"
            keyPassword = System.getenv("KEY_PASS")
        }
    }
    buildTypes {
        release {
            isMinifyEnabled = true
            signingConfig = signingConfigs.getByName("release")
        }
    }
}

# .github/workflows/release.yml (resumen)
jobs:
  release:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-java@v4
        with: { distribution: temurin, java-version: '17' }
      - run: ./gradlew bundleRelease
        env:
          KEYSTORE: ${{ secrets.KEYSTORE_B64 }}
          KEYSTORE_PASS: ${{ secrets.KEYSTORE_PASS }}
          KEY_PASS: ${{ secrets.KEY_PASS }}