Kotlin & Kotlin Multiplatform: De Cero a Experto (2026) | Blog

Kotlin & Kotlin Multiplatform: De Cero a Experto (2026)

Curso

April 26, 2026

13h 05min read

📋 Índice General

#	Sección	Nivel	Tiempo
1	Introducción: ¿Qué es Kotlin y por qué aprenderlo?	🟢 Principiante	~15 min
2	Configuración del entorno de desarrollo	🟢 Principiante	~20 min
3	Fundamentos del lenguaje Kotlin	🟢 Principiante	~45 min
4	Programación orientada a objetos en Kotlin

Plataforma	Uso
Android	Lenguaje oficial. Toda la documentación oficial de Android usa Kotlin
Backend / Servidor	Con frameworks como Ktor, Spring Boot (con Kotlin DSL) o Quarkus
iOS	A través de Kotlin Multiplatform (KMP)
Web	Kotlin/JS compila a JavaScript
Desktop	Con Compose Multiplatform
Embedded/WASM	Kotlin/Wasm (WebAssembly), experimental pero muy prometedor


bash
brew install --cask temurin@21


bash
sudo apt update
sudo apt install temurin-21-jdk


bash
java -version
# Salida esperada: openjdk version "21.x.x" ...

mi-proyecto/
├── build.gradle.kts       ← Configuración del build (en Kotlin DSL)
├── settings.gradle.kts    ← Nombre del proyecto
├── gradle/
│   └── wrapper/           ← Gradle Wrapper (no necesitas instalar Gradle manualmente)
└── src/
    └── main/
        └── kotlin/
            └── Main.kt    ← Tu primer archivo Kotlin


kotlin
fun main() {
    println("Hello, World!")
}

Hello, World!


kotlin
// build.gradle.kts

plugins {
    kotlin("jvm") version "2.1.0"  // Plugin de Kotlin para JVM
    application                     // Plugin para aplicaciones ejecutables
}

group = "com.miempresa"   // Identificador de tu organización (estilo Java)
version = "1.0-SNAPSHOT"  // Versión de tu proyecto

repositories {
    mavenCentral()  // Repositorio donde Gradle descarga las dependencias
}

dependencies {
    // Aquí añadirás tus librerías. Por ejemplo:
    // implementation("io.ktor:ktor-client-core:3.0.0")
    testImplementation(kotlin("test"))  // Librería de testing de Kotlin
}

application {
    mainClass.set("MainKt")  // Clase principal (nota: Kotlin añade "Kt" al nombre del archivo)
}

Palabra clave	Significado	¿Se puede reasignar?
`val`	value (valor)	❌ No (inmutable, como `final` en Java)
`var`	variable	✅ Sí (mutable)


kotlin
fun main() {
    val nombre = "Carlos"     // Inmutable: no puedes cambiar su valor
    var edad = 25             // Mutable: puedes cambiar su valor

    // nombre = "Pedro"       // ❌ Error de compilación: Val cannot be reassigned
    edad = 26                 // ✅ Correcto

    println("$nombre tiene $edad años")
    // Salida: Carlos tiene 26 años
}


kotlin
fun main() {
    // Números enteros
    val entero: Int = 42
    val enteroLargo: Long = 10_000_000_000L  // El guion bajo mejora la legibilidad
    val enteroCorto: Short = 100
    val enteroByte: Byte = 127

    // Números decimales
    val decimal: Double = 3.14159
    val decimalSimple: Float = 3.14f

    // Texto
    val texto: String = "Hola, Kotlin"
    val caracter: Char = 'K'

    // Booleano
    val esVerdad: Boolean = true

    // Kotlin infiere el tipo si no lo especificas:
    val inferido = "Esto es un String"  // Kotlin sabe que es String
    val numero = 42                      // Kotlin sabe que es Int

    println(inferido.length)  // Puedes usar métodos de String directamente
    // Salida: 22
}


kotlin
fun main() {
    var nombre: String = "Ana"
    // nombre = null  // ❌ Error de compilación: Null can not be a value of a non-null type String

    // Para permitir nulos, añades "?" al tipo:
    var nombreNulable: String? = "Ana"
    nombreNulable = null  // ✅ Ahora sí está permitido
}


kotlin
fun main() {
    val nombre: String? = obtenerNombre()  // puede ser null

    // Opción 1: Safe call operator (?.)
    // Si nombre es null, devuelve null sin lanzar excepción
    val longitud = nombre?.length
    println(longitud)  // Imprime null si nombre es null, o el número si no lo es

    // Opción 2: Elvis operator (?:)
    // Si el lado izquierdo es null, usa el valor de la derecha como fallback
    val longitudSegura = nombre?.length ?: 0
    println(longitudSegura)  // Imprime 0 si nombre es null

    // Opción 3: Smart cast con if
    if (nombre != null) {
        // Dentro de este bloque, Kotlin sabe que nombre NO es null
        println(nombre.length)  // No necesitas "?."
    }

    // Opción 4: let (para ejecutar un bloque solo si no es null)
    nombre?.let { valor ->
        println("El nombre es: $valor")  // Solo se ejecuta si nombre != null
    }

    // Opción 5: !! (non-null assertion) — ÚSALO CON CUIDADO
    // Lanza NullPointerException si es null. Evítalo salvo que estés 100% seguro
    val longitudPeligrosa = nombre!!.length  // ⚠️ Puede lanzar excepción
}

fun obtenerNombre(): String? = null  // Simula una función que puede devolver null


kotlin
fun main() {
    val nombre = "María"
    val edad = 30

    // String template: usa $ para insertar variables
    println("Hola, $nombre!")

    // Expresiones dentro de ${...}
    println("El año que viene tendrás ${edad + 1} años")

    // Strings multilínea (triple comillas)
    val json = """
        {
            "nombre": "$nombre",
            "edad": $edad
        }
    """.trimIndent()  // trimIndent() elimina la indentación común
    println(json)

    // Operaciones comunes con Strings
    val texto = "  Kotlin es genial  "
    println(texto.trim())           // "Kotlin es genial"
    println(texto.uppercase())      // "  KOTLIN ES GENIAL  "
    println(texto.contains("genial")) // true
    println(texto.replace("genial", "increíble"))
    println("Kotlin".startsWith("Ko")) // true
    println("Kotlin".substring(0, 3))  // "Kot"
}


kotlin
fun main() {
    val numero = 7

    // if como expresión (devuelve un valor)
    val resultado = if (numero > 5) "grande" else "pequeño"
    println(resultado)  // "grande"

    // when: el switch moderno de Kotlin (mucho más potente)
    val dia = 3
    val nombreDia = when (dia) {
        1 -> "Lunes"
        2 -> "Martes"
        3 -> "Miércoles"
        4 -> "Jueves"
        5 -> "Viernes"
        6, 7 -> "Fin de semana"  // múltiples valores
        else -> "Día inválido"
    }
    println(nombreDia)  // "Miércoles"

    // when con rangos
    val nota = 85
    val calificacion = when (nota) {
        in 90..100 -> "Sobresaliente"
        in 70..89  -> "Notable"
        in 50..69  -> "Aprobado"
        else       -> "Suspenso"
    }
    println(calificacion)  // "Notable"

    // when con tipos (muy útil con sealed classes, lo veremos más adelante)
    val valor: Any = "Hola"
    when (valor) {
        is String -> println("Es un String de longitud ${valor.length}")
        is Int    -> println("Es un entero: $valor")
        is List<*>-> println("Es una lista con ${(valor as List<*>).size} elementos")
    }
}


kotlin
fun main() {
    // for con rangos
    for (i in 1..5) {
        print("$i ")  // 1 2 3 4 5
    }
    println()

    // Rango exclusivo (hasta 4, sin incluir 5)
    for (i in 1 until 5) {
        print("$i ")  // 1 2 3 4
    }
    println()

    // Con paso (step)
    for (i in 0..10 step 2) {
        print("$i ")  // 0 2 4 6 8 10
    }
    println()

    // Hacia atrás
    for (i in 5 downTo 1) {
        print("$i ")  // 5 4 3 2 1
    }
    println()

    // Iterar sobre una lista
    val frutas = listOf("manzana", "pera", "naranja")
    for (fruta in frutas) {
        println(fruta)
    }

    // Con índice
    for ((indice, fruta) in frutas.withIndex()) {
        println("$indice: $fruta")
    }

    // while
    var contador = 0
    while (contador < 3) {
        println("Contador: $contador")
        contador++
    }

    // repeat (más idiomático para repetir N veces)
    repeat(3) { iteracion ->
        println("Iteración $iteracion")
    }
}


kotlin
// Función básica
fun saludar(nombre: String): String {
    return "Hola, $nombre!"
}

// Función de expresión única (single-expression function)
// Cuando el cuerpo es una sola expresión, puedes omitir {} y return
fun saludarCorto(nombre: String) = "Hola, $nombre!"

// Parámetros con valores por defecto
fun crearUsuario(
    nombre: String,
    edad: Int = 18,           // valor por defecto
    activo: Boolean = true    // valor por defecto
): String {
    return "Usuario: $nombre, Edad: $edad, Activo: $activo"
}

// Funciones con argumentos nombrados
fun main() {
    println(saludar("Kotlin"))          // "Hola, Kotlin!"
    println(saludarCorto("Kotlin"))     // "Hola, Kotlin!"

    // Con valores por defecto no necesitas pasar todos los parámetros
    println(crearUsuario("Ana"))
    // Usuario: Ana, Edad: 18, Activo: true

    // Argumentos nombrados: puedes cambiar el orden
    println(crearUsuario(edad = 25, nombre = "Luis", activo = false))
    // Usuario: Luis, Edad: 25, Activo: false

    // Función con número variable de argumentos (vararg)
    println(sumar(1, 2, 3, 4, 5))  // 15
}

fun sumar(vararg numeros: Int): Int {
    return numeros.sum()
}


kotlin
// Unit es como "void" en Java: la función no devuelve nada útil
// Puedes omitirlo, es implícito
fun imprimirMensaje(mensaje: String): Unit {
    println(mensaje)
}
// Equivalente:
fun imprimirMensaje2(mensaje: String) {
    println(mensaje)
}

// Nothing: indica que la función NUNCA devuelve (lanza excepción o bucle infinito)
fun lanzarError(mensaje: String): Nothing {
    throw IllegalStateException(mensaje)
}


kotlin
// Clase con constructor primario
// Los parámetros del constructor primario pueden ser propiedades directamente con val/var
class Persona(
    val nombre: String,        // propiedad inmutable
    var edad: Int,             // propiedad mutable
    val email: String = ""     // con valor por defecto
) {
    // Propiedad calculada (getter personalizado)
    val esMayorDeEdad: Boolean
        get() = edad >= 18

    // Bloque init: se ejecuta cuando se crea el objeto
    init {
        require(edad >= 0) { "La edad no puede ser negativa" }
        require(nombre.isNotBlank()) { "El nombre no puede estar vacío" }
    }

    // Constructor secundario (menos común, prefiere valores por defecto)
    constructor(nombre: String) : this(nombre, 0) {
        println("Constructor secundario llamado")
    }

    // Método
    fun saludar(): String = "Hola, soy $nombre y tengo $edad años"

    // toString para representación legible
    override fun toString(): String = "Persona(nombre=$nombre, edad=$edad)"
}

fun main() {
    val persona = Persona("Ana", 25, "ana@email.com")
    println(persona.saludar())     // Hola, soy Ana y tengo 25 años
    println(persona.esMayorDeEdad) // true
    println(persona)               // Persona(nombre=Ana, edad=25)

    persona.edad = 26              // Podemos cambiar edad (es var)
    // persona.nombre = "Otra"    // ❌ Error: nombre es val
}


kotlin
data class Usuario(
    val id: Int,
    val nombre: String,
    val email: String
)

fun main() {
    val usuario1 = Usuario(1, "Carlos", "carlos@email.com")
    val usuario2 = Usuario(1, "Carlos", "carlos@email.com")
    val usuario3 = Usuario(2, "Ana", "ana@email.com")

    // equals() generado automáticamente (compara por valor, no por referencia)
    println(usuario1 == usuario2)  // true  (mismos valores)
    println(usuario1 == usuario3)  // false (diferentes valores)

    // toString() generado automáticamente
    println(usuario1)
    // Usuario(id=1, nombre=Carlos, email=carlos@email.com)

    // copy() para crear una copia modificando algunos campos
    val usuarioActualizado = usuario1.copy(email = "nuevo@email.com")
    println(usuarioActualizado)
    // Usuario(id=1, nombre=Carlos, email=nuevo@email.com)

    // Desestructuración
    val (id, nombre, email) = usuario1
    println("ID: $id, Nombre: $nombre")
}


kotlin
// Clase base (debe ser "open" para poder heredarse)
open class Animal(
    val nombre: String,
    val sonido: String
) {
    // Método "open" puede ser sobreescrito
    open fun hacerSonido(): String = "$nombre dice: $sonido"

    // Método "final" (por defecto en Kotlin): no puede sobreescribirse
    fun respirar() = "$nombre está respirando"
}

// Clase derivada
class Perro(nombre: String) : Animal(nombre, "Guau") {
    // Sobreescribimos el método
    override fun hacerSonido(): String = "¡${super.hacerSonido()}! ¡${super.hacerSonido()}!"

    fun buscarPalo() = "$nombre busca el palo"
}

class Gato(nombre: String) : Animal(nombre, "Miau") {
    override fun hacerSonido(): String = "${super.hacerSonido()}..."
}

// Clase abstracta: no puede instanciarse directamente
abstract class Figura {
    abstract fun area(): Double  // Sin implementación, las subclases DEBEN implementarlo
    abstract fun perimetro(): Double

    fun descripcion() = "Área: ${area()}, Perímetro: ${perimetro()}"
}

class Circulo(val radio: Double) : Figura() {
    override fun area() = Math.PI * radio * radio
    override fun perimetro() = 2 * Math.PI * radio
}

class Rectangulo(val ancho: Double, val alto: Double) : Figura() {
    override fun area() = ancho * alto
    override fun perimetro() = 2 * (ancho + alto)
}

fun main() {
    val perro = Perro("Rex")
    val gato = Gato("Whiskers")

    println(perro.hacerSonido())   // ¡Rex dice: Guau! ¡Rex dice: Guau!
    println(gato.hacerSonido())    // Whiskers dice: Miau...
    println(perro.buscarPalo())    // Rex busca el palo

    val circulo = Circulo(5.0)
    println(circulo.descripcion())
    // Área: 78.54, Perímetro: 31.42
}


kotlin
interface Volador {
    val velocidadMaxima: Int  // propiedad abstracta

    fun volar(): String  // método abstracto

    // Método con implementación por defecto
    fun aterrizar(): String = "Aterrizando suavemente a $velocidadMaxima km/h"
}

interface Nadador {
    fun nadar(): String = "Nadando"
}

// Una clase puede implementar múltiples interfaces
class Pato(override val velocidadMaxima: Int = 80) : Volador, Nadador {
    override fun volar() = "El pato vuela a $velocidadMaxima km/h"
    // nadar() y aterrizar() usan las implementaciones por defecto
}

fun main() {
    val pato = Pato()
    println(pato.volar())     // El pato vuela a 80 km/h
    println(pato.nadar())     // Nadando
    println(pato.aterrizar()) // Aterrizando suavemente a 80 km/h
}


kotlin
// Resultado de una operación de red
sealed class ResultadoRed<out T> {
    data class Exito<T>(val datos: T) : ResultadoRed<T>()
    data class Error(val mensaje: String, val codigo: Int) : ResultadoRed<Nothing>()
    object Cargando : ResultadoRed<Nothing>()
}

// Estado de la UI de login
sealed class EstadoLogin {
    object Inactivo : EstadoLogin()
    object Cargando : EstadoLogin()
    data class Exitoso(val nombreUsuario: String) : EstadoLogin()
    data class Fallido(val razon: String) : EstadoLogin()
}

fun procesarResultado(resultado: ResultadoRed<String>) {
    // when con sealed class: el compilador verifica que cubras TODOS los casos
    // Si añades una nueva subclase y olvidas el caso, el compilador te avisa
    when (resultado) {
        is ResultadoRed.Exito   -> println("✅ Datos recibidos: ${resultado.datos}")
        is ResultadoRed.Error   -> println("❌ Error ${resultado.codigo}: ${resultado.mensaje}")
        is ResultadoRed.Cargando-> println("⏳ Cargando...")
    }
}

fun main() {
    procesarResultado(ResultadoRed.Exito("datos del servidor"))
    procesarResultado(ResultadoRed.Error("No encontrado", 404))
    procesarResultado(ResultadoRed.Cargando)
}


kotlin
// object: crea un singleton (instancia única)
object ConfiguracionApp {
    const val VERSION = "2.0.0"
    val baseUrl = "https://api.miapp.com"

    fun obtenerHeaders() = mapOf(
        "Content-Type" to "application/json",
        "App-Version" to VERSION
    )
}

class BaseDeDatos private constructor() {
    companion object {
        // companion object: similar a métodos estáticos en Java
        // pero más potente porque puede implementar interfaces

        private var instancia: BaseDeDatos? = null

        fun obtenerInstancia(): BaseDeDatos {
            return instancia ?: BaseDeDatos().also { instancia = it }
        }

        const val NOMBRE_BD = "mi_base_de_datos"
    }

    fun consultar(query: String) = "Resultado de: $query"
}

fun main() {
    // Acceso directo sin instanciar (es un singleton)
    println(ConfiguracionApp.VERSION)   // "2.0.0"
    println(ConfiguracionApp.baseUrl)   // "https://api.miapp.com"

    // Singleton con companion object
    val bd1 = BaseDeDatos.obtenerInstancia()
    val bd2 = BaseDeDatos.obtenerInstancia()
    println(bd1 === bd2)  // true: misma instancia
    println(BaseDeDatos.NOMBRE_BD)  // "mi_base_de_datos"
}


kotlin
// Añadimos un método a String
fun String.capitalizar(): String {
    return this.split(" ")
        .joinToString(" ") { palabra -> 
            palabra.replaceFirstChar { it.uppercase() }
        }
}

// Añadimos un método a Int
fun Int.esPar(): Boolean = this % 2 == 0

// Extension function con receptor nulable
fun String?.oDefecto(defecto: String = "Desconocido"): String {
    return this ?: defecto
}

// Extension sobre una lista
fun <T> List<T>.segundoONull(): T? = if (this.size >= 2) this[1] else null

fun main() {
    println("hola mundo kotlin".capitalizar())  // "Hola Mundo Kotlin"
    println(4.esPar())  // true
    println(7.esPar())  // false

    val nombre: String? = null
    println(nombre.oDefecto())          // "Desconocido"
    println(nombre.oDefecto("Anónimo")) // "Anónimo"

    val lista = listOf("a", "b", "c")
    println(lista.segundoONull())       // "b"
    println(emptyList<String>().segundoONull())  // null
}


kotlin
fun main() {
    // Una lambda es una función anónima
    val saludar = { nombre: String -> "Hola, $nombre!" }
    println(saludar("Kotlin"))  // "Hola, Kotlin!"

    // Función de orden superior: recibe otra función como parámetro
    fun operacion(a: Int, b: Int, op: (Int, Int) -> Int): Int {
        return op(a, b)
    }

    val suma = operacion(3, 4) { x, y -> x + y }
    val producto = operacion(3, 4) { x, y -> x * y }
    println(suma)      // 7
    println(producto)  // 12

    // Cuando la lambda es el último parámetro, va fuera del paréntesis (trailing lambda)
    // Esta convención se usa MUCHO en Kotlin (Compose, Coroutines, etc.)
    val resultado = operacion(10, 5) { a, b ->
        println("Calculando $a - $b")
        a - b  // Último valor = valor de retorno de la lambda
    }
    println(resultado)  // 5

    // "it": nombre implícito cuando la lambda tiene UN solo parámetro
    val numeros = listOf(1, 2, 3, 4, 5)
    val dobles = numeros.map { it * 2 }
    println(dobles)  // [2, 4, 6, 8, 10]
}


kotlin
fun main() {
    // ===== LIST =====
    val lista = listOf(1, 2, 3, 4, 5)          // Inmutable
    val listaM = mutableListOf(1, 2, 3)         // Mutable
    listaM.add(4)
    listaM.removeAt(0)
    println(listaM)  // [2, 3, 4]

    // ===== SET =====
    val set = setOf(1, 2, 3, 2, 1)             // Sin duplicados, inmutable
    println(set)   // [1, 2, 3]
    val setM = mutableSetOf("a", "b")
    setM.add("c")

    // ===== MAP =====
    val mapa = mapOf(                           // Inmutable
        "nombre" to "Ana",
        "edad" to "25",
        "ciudad" to "Madrid"
    )
    println(mapa["nombre"])  // "Ana"
    println(mapa.getOrDefault("pais", "Desconocido"))  // "Desconocido"

    val mapaM = mutableMapOf<String, Int>()
    mapaM["puntos"] = 100
    mapaM["vidas"] = 3
    mapaM["puntos"] = mapaM["puntos"]!! + 50   // Actualizar valor
    println(mapaM)  // {puntos=150, vidas=3}
}


kotlin


kotlin
fun main() {
    val numeros = (1..1_000_000).toList()

    // Con List (eager): crea 3 listas intermedias en memoria
    val resultadoLista = numeros
        .filter { it % 2 == 0 }   // Crea lista de 500.000 elementos
        .map { it * 3 }            // Crea otra lista de 500.000 elementos
        .take(5)                    // Finalmente toma 5

    // Con Sequence (lazy): procesa elemento a elemento, para cuando tiene 5
    val resultadoSequence = numeros
        .asSequence()              // Convierte a Sequence
        .filter { it % 2 == 0 }   // Lazy: no ejecuta aún
        .map { it * 3 }            // Lazy: no ejecuta aún
        .take(5)                    // Lazy: no ejecuta aún
        .toList()                   // Terminal: ejecuta todo, se para en el elemento 10

    println(resultadoLista)    // [6, 12, 18, 24, 30]
    println(resultadoSequence) // [6, 12, 18, 24, 30]
    // Mismo resultado, pero Sequence es MUCHO más eficiente con colecciones grandes
}


kotlin
// Código que parece síncrono pero es asíncrono internamente
suspend fun cargarDatos() {
    val datos = descargarDatos()  // Suspende sin bloquear el hilo
    mostrarEnUI(datos)            // Continúa cuando los datos llegaron
}


kotlin
dependencies {
    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.9.0")
}


kotlin
import kotlinx.coroutines.*

fun main() = runBlocking {
    // runBlocking: lanza una coroutine y bloquea el hilo hasta que termina
    // (solo usar en main() o tests, nunca en código de producción)
    
    println("Inicio en hilo: ${Thread.currentThread().name}")
    
    // launch: lanza una coroutine que no devuelve valor
    val job = launch {
        delay(1000)  // Suspende 1 segundo sin bloquear el hilo
        println("Coroutine completada")
    }
    
    println("Esto se imprime ANTES que la coroutine termina")
    job.join()  // Espera a que la coroutine termine
    println("Todo completado")
}
// Salida:
// Inicio en hilo: main
// Esto se imprime ANTES que la coroutine termina
// (espera 1 segundo)
// Coroutine completada
// Todo completado


kotlin
import kotlinx.coroutines.*

suspend fun obtenerUsuario(id: Int): String {
    delay(500)  // Simula llamada de red
    return "Usuario$id"
}

suspend fun obtenerPosts(userId: Int): List<String> {
    delay(800)  // Simula llamada de red
    return listOf("Post1 de $userId", "Post2 de $userId")
}

fun main() = runBlocking {
    
    // === SECUENCIAL (tarda 1300ms) ===
    val t1 = System.currentTimeMillis()
    val usuario = obtenerUsuario(1)    // Espera 500ms
    val posts = obtenerPosts(1)         // Espera 800ms más
    println("Secuencial tardó ${System.currentTimeMillis() - t1}ms")
    // ~1300ms

    // === PARALELO con async/await (tarda ~800ms) ===
    val t2 = System.currentTimeMillis()
    val usuarioDeferred = async { obtenerUsuario(2) }   // Inicia inmediatamente
    val postsDeferred = async { obtenerPosts(2) }        // Inicia inmediatamente
    
    val usuario2 = usuarioDeferred.await()  // Espera el resultado
    val posts2 = postsDeferred.await()      // Ya está listo o casi
    println("Paralelo tardó ${System.currentTimeMillis() - t2}ms")
    // ~800ms (ambas coroutines corrieron en paralelo)
}


kotlin
import kotlinx.coroutines.*

fun main() = runBlocking {
    // Dispatchers.Main → Hilo principal de UI (Android/Desktop)
    // Dispatchers.IO → Pool optimizado para I/O (red, base de datos, archivos)
    // Dispatchers.Default → Pool para cómputo intensivo (CPU)
    // Dispatchers.Unconfined → Sin restricción de hilo

    launch(Dispatchers.IO) {
        println("IO en: ${Thread.currentThread().name}")
        // Aquí harías llamadas de red o base de datos
    }

    launch(Dispatchers.Default) {
        println("Default en: ${Thread.currentThread().name}")
        // Aquí harías cálculos pesados
    }

    // withContext: cambia de dispatcher dentro de una coroutine
    val resultado = withContext(Dispatchers.IO) {
        // Simula operación de red
        delay(100)
        "datos de la red"
    }
    println("Recibido: $resultado")
}


kotlin
import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*

// Un Flow emite múltiples valores de forma asíncrona
fun obtenerTemperaturas(): Flow<Double> = flow {
    // flow { } es un builder de Flow
    while (true) {
        val temperatura = (15..35).random().toDouble()
        emit(temperatura)   // Emite un valor
        delay(1000)         // Espera 1 segundo
    }
}

fun numerosImpares(): Flow<Int> = flow {
    for (i in 1..10) {
        if (i % 2 != 0) emit(i)
        delay(100)
    }
}

fun main() = runBlocking {
    // Recolectar (consumir) un Flow
    numerosImpares()
        .filter { it > 3 }        // Filtra valores
        .map { it * it }           // Transforma
        .collect { valor ->        // Terminal: consume cada valor
            println(valor)
        }
    // Salida: 25, 49, 81

    // StateFlow: similar a LiveData, guarda el último valor emitido
    // SharedFlow: para eventos que no deben perderse
    // (Muy usados en arquitectura Android con ViewModel)
}


kotlin
import kotlinx.coroutines.*

fun main() = runBlocking {
    // try/catch funciona normalmente con coroutines
    val resultado = try {
        withContext(Dispatchers.IO) {
            // Simula un error de red
            throw Exception("Error de conexión")
            "datos"
        }
    } catch (e: Exception) {
        println("Error capturado: ${e.message}")
        "valor por defecto"
    }
    println("Resultado: $resultado")

    // CoroutineExceptionHandler: manejador global para coroutines launch{}
    val handler = CoroutineExceptionHandler { _, excepcion ->
        println("Excepción no manejada: ${excepcion.message}")
    }

    val job = launch(handler) {
        throw RuntimeException("¡Boom!")
    }
    job.join()
}

┌─────────────────────────────────────────────────────────┐
│                    Tu Aplicación                         │
├────────────────┬──────────────┬───────────────┬─────────┤
│   Android UI   │    iOS UI    │   Web UI      │Desktop  │
│  (Compose /    │  (SwiftUI /  │ (React / WASM)│(Compose)│
│   XML)         │   UIKit)     │               │         │
├────────────────┴──────────────┴───────────────┴─────────┤
│          CÓDIGO COMPARTIDO EN KOTLIN (KMP)               │
│  • Lógica de negocio                                     │
│  • Modelos de datos                                      │
│  • Llamadas a red (Ktor)                                 │
│  • Base de datos local (SQLDelight / Room)               │
│  • Serialización (kotlinx.serialization)                 │
│  • ViewModels / Presenters                               │
└─────────────────────────────────────────────────────────┘

	KMP	Flutter	React Native
Lenguaje	Kotlin	Dart	JavaScript/TypeScript
UI	Nativa (por defecto)	Propio (Canvas)	Componentes nativos
Rendimiento	Nativo	Muy bueno	Bueno
Integración nativa	⭐⭐⭐⭐⭐	⭐⭐⭐	⭐⭐⭐
Curva de aprendizaje	Media	Media	Baja (si sabes JS)
Madurez (2026)	⭐⭐⭐⭐	⭐⭐⭐⭐⭐	⭐⭐⭐⭐
Empresa detrás	JetBrains + Google	Google	Meta


kotlin
// En commonMain (código compartido):
expect fun obtenerPlataforma(): String  // "Espero" que cada plataforma implemente esto
expect fun getCurrentTimeMillis(): Long

// En androidMain (implementación Android):
actual fun obtenerPlataforma(): String = "Android ${android.os.Build.VERSION.SDK_INT}"
actual fun getCurrentTimeMillis(): Long = System.currentTimeMillis()

// En iosMain (implementación iOS):
actual fun obtenerPlataforma(): String = UIDevice.currentDevice.systemName() + " " +
    UIDevice.currentDevice.systemVersion
actual fun getCurrentTimeMillis(): Long = 
    (NSDate().timeIntervalSince1970 * 1000).toLong()

mi-app-kmp/
├── androidApp/              ← App Android (Jetpack Compose)
│   ├── src/
│   └── build.gradle.kts
├── iosApp/                  ← App iOS (Xcode project)
│   └── iosApp.xcodeproj
├── shared/                  ← MÓDULO COMPARTIDO (el corazón de KMP)
│   ├── src/
│   │   ├── commonMain/      ← Código para TODAS las plataformas
│   │   │   └── kotlin/
│   │   ├── androidMain/     ← Código específico Android
│   │   │   └── kotlin/
│   │   ├── iosMain/         ← Código específico iOS
│   │   │   └── kotlin/
│   │   ├── commonTest/      ← Tests compartidos
│   │   └── androidTest/
│   └── build.gradle.kts
├── build.gradle.kts         ← Build root
└── settings.gradle.kts


kotlin
// shared/build.gradle.kts
plugins {
    alias(libs.plugins.kotlinMultiplatform)
    alias(libs.plugins.androidLibrary)
    alias(libs.plugins.kotlinSerialization)   // Para kotlinx.serialization
    alias(libs.plugins.sqldelight)            // Para SQLDelight (base de datos)
}

kotlin {
    // Targets (plataformas destino)
    androidTarget {
        compilations.all {
            kotlinOptions.jvmTarget = "17"
        }
    }

    // iOS targets
    iosX64()           // Simulador iOS en Mac Intel
    iosArm64()         // Dispositivo iOS físico
    iosSimulatorArm64()// Simulador iOS en Mac Apple Silicon (M1/M2/M3/M4)

    // Opcional: Web (WASM o JS)
    // wasmJs { browser() }

    // Opcional: Desktop (JVM)
    // jvm("desktop")

    sourceSets {
        // commonMain: código compartido por TODAS las plataformas
        commonMain.dependencies {
            // Coroutines multiplataforma
            implementation(libs.kotlinx.coroutines.core)
            // Serialización JSON
            implementation(libs.kotlinx.serialization.json)
            // Cliente HTTP multiplataforma
            implementation(libs.ktor.client.core)
            implementation(libs.ktor.client.content.negotiation)
            implementation(libs.ktor.serialization.json)
            // Inyección de dependencias
            implementation(libs.koin.core)
            // Logging
            implementation(libs.napier)
        }

        // androidMain: solo para Android
        androidMain.dependencies {
            implementation(libs.ktor.client.android)  // Motor HTTP para Android
            implementation(libs.koin.android)
        }

        // iosMain: solo para iOS
        iosMain.dependencies {
            implementation(libs.ktor.client.darwin)   // Motor HTTP para iOS (Darwin)
        }

        // commonTest: tests compartidos
        commonTest.dependencies {
            implementation(libs.kotlin.test)
            implementation(libs.kotlinx.coroutines.test)
        }
    }
}


kotlin
// shared/src/commonMain/kotlin/data/remote/ApiService.kt

import io.ktor.client.*
import io.ktor.client.call.*
import io.ktor.client.plugins.contentnegotiation.*
import io.ktor.client.request.*
import io.ktor.serialization.kotlinx.json.*
import kotlinx.serialization.Serializable
import kotlinx.serialization.json.Json

// Modelo de datos serializable
@Serializable
data class Post(
    val id: Int,
    val userId: Int,
    val title: String,
    val body: String
)

// El cliente HTTP se crea en commonMain
// pero el motor (engine) es específico de cada plataforma
class ApiService(private val httpClient: HttpClient) {

    companion object {
        const val BASE_URL = "https://jsonplaceholder.typicode.com"
    }

    suspend fun obtenerPosts(): Result<List<Post>> = runCatching {
        httpClient.get("$BASE_URL/posts").body()
    }

    suspend fun obtenerPost(id: Int): Result<Post> = runCatching {
        httpClient.get("$BASE_URL/posts/$id").body()
    }
}

// Factory del HttpClient en commonMain
fun crearHttpClient(): HttpClient = HttpClient {
    install(ContentNegotiation) {
        json(Json {
            ignoreUnknownKeys = true    // Ignora campos extra del JSON
            isLenient = true            // Más permisivo con el formato
            prettyPrint = false
        })
    }
}


kotlin
// shared/src/commonMain/kotlin/domain/PostRepository.kt

// Repositorio que abstrae la fuente de datos
class PostRepository(private val apiService: ApiService) {

    suspend fun obtenerTodosPosts(): Result<List<Post>> {
        return apiService.obtenerPosts()
    }

    suspend fun obtenerPostPorId(id: Int): Result<Post> {
        return apiService.obtenerPost(id)
    }
}


kotlin
// shared/src/commonMain/kotlin/presentation/PostViewModel.kt
// Este ViewModel funciona en TODAS las plataformas

import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.flow.asStateFlow
import kotlinx.coroutines.launch

// Estado de la UI (sealed class)
sealed class PostsUiState {
    object Cargando : PostsUiState()
    data class Exitoso(val posts: List<Post>) : PostsUiState()
    data class Error(val mensaje: String) : PostsUiState()
}

class PostViewModel(
    private val repository: PostRepository,
    private val scope: CoroutineScope  // Inyectamos el scope para testabilidad
) {
    private val _uiState = MutableStateFlow<PostsUiState>(PostsUiState.Cargando)
    val uiState: StateFlow<PostsUiState> = _uiState.asStateFlow()

    fun cargarPosts() {
        scope.launch {
            _uiState.value = PostsUiState.Cargando

            repository.obtenerTodosPosts()
                .onSuccess { posts ->
                    _uiState.value = PostsUiState.Exitoso(posts)
                }
                .onFailure { error ->
                    _uiState.value = PostsUiState.Error(
                        error.message ?: "Error desconocido"
                    )
                }
        }
    }
}


kotlin
// Versión en libs.versions.toml (catálogo de versiones de Gradle)
// [versions]
// ktor = "3.1.0"
//
// [libraries]
// ktor-client-core = { module = "io.ktor:ktor-client-core", version.ref = "ktor" }
// ktor-client-android = { module = "io.ktor:ktor-client-android", version.ref = "ktor" }
// ktor-client-darwin = { module = "io.ktor:ktor-client-darwin", version.ref = "ktor" }

// Ejemplo completo con autenticación y manejo de errores
val client = HttpClient {
    install(ContentNegotiation) {
        json()
    }
    install(HttpTimeout) {
        requestTimeoutMillis = 15_000
        connectTimeoutMillis = 5_000
    }
    install(Logging) {
        level = LogLevel.BODY  // Para desarrollo; usa NONE en producción
    }
    defaultRequest {
        url("https://api.miapp.com/v1/")
        header("Authorization", "Bearer ${tokenProvider.getToken()}")
    }
}


kotlin
import kotlinx.serialization.*
import kotlinx.serialization.json.*

@Serializable
data class Config(
    val apiUrl: String,
    val timeout: Int = 30,
    @SerialName("max_retries") val maxReintentos: Int = 3,  // Nombre diferente en JSON
    val features: List<String> = emptyList()
)

val json = Json { prettyPrint = true; ignoreUnknownKeys = true }

fun main() {
    val config = Config(apiUrl = "https://api.ejemplo.com", timeout = 15)

    // Serializar a JSON string
    val jsonString = json.encodeToString(config)
    println(jsonString)

    // Deserializar de JSON string
    val configDesdeJson = json.decodeFromString<Config>(jsonString)
    println(configDesdeJson.apiUrl)
}


sql
-- shared/src/commonMain/sqldelight/database/Post.sq

CREATE TABLE post (
    id INTEGER NOT NULL PRIMARY KEY,
    userId INTEGER NOT NULL,
    title TEXT NOT NULL,
    body TEXT NOT NULL
);

selectAll:
SELECT * FROM post;

selectById:
SELECT * FROM post WHERE id = :id;

insertOrReplace:
INSERT OR REPLACE INTO post (id, userId, title, body)
VALUES (?, ?, ?, ?);

deleteAll:
DELETE FROM post;


kotlin
// Uso del DAO generado
class PostLocalDataSource(private val database: AppDatabase) {

    fun obtenerTodosPosts(): List<Post> =
        database.postQueries.selectAll().executeAsList()
            .map { it.toPost() }

    fun guardarPosts(posts: List<Post>) {
        database.transaction {
            database.postQueries.deleteAll()
            posts.forEach { post ->
                database.postQueries.insertOrReplace(
                    id = post.id.toLong(),
                    userId = post.userId.toLong(),
                    title = post.title,
                    body = post.body
                )
            }
        }
    }
}


kotlin
// shared/src/commonMain/kotlin/di/SharedModule.kt
import org.koin.dsl.module

val sharedModule = module {
    single { crearHttpClient() }
    single { ApiService(get()) }
    single { PostRepository(get()) }
    factory { params -> PostViewModel(get(), params.get()) }
}

// En androidMain
val androidModule = module {
    includes(sharedModule)
    // Dependencias específicas de Android
    single<Context> { androidContext() }
}

// Inicialización en Android Application class:
// startKoin { androidContext(this); modules(androidModule) }

Categoría	Librería	Versión	Notas
HTTP Client	`io.ktor:ktor-client-core`	3.1.x	Multiplataforma nativa
Serialización	`org.jetbrains.kotlinx:kotlinx-serialization-json`	1.8.x	JSON, CBOR, ProtoBuf
Base de datos	`app.cash.sqldelight`	2.0.x	SQL type-safe
DI	`io.insert-koin:koin-core`	4.0.x	Sencillo y KMP-ready
Coroutines	`org.jetbrains.kotlinx:kotlinx-coroutines-core`	1.9.x	Base para async
Settings/Prefs	`com.russhwolf:multiplatform-settings`	1.2.x	SharedPreferences/UserDefaults
Fechas/Tiempo	`org.jetbrains.kotlinx:kotlinx-datetime`	0.6.x	DateTime multiplataforma
Logging	`io.github.aakira:napier`	2.7.x	Logger KMP
UI (opcional)	`org.jetbrains.compose`	1.7.x	Compose Multiplatform
Testing	`io.mockk:mockk`	1.14.x	Mocking para tests

shared/
└── src/commonMain/kotlin/
    ├── domain/                  ← Capa de dominio (pura Kotlin, sin frameworks)
    │   ├── model/               ← Entidades de negocio
    │   │   └── Post.kt
    │   ├── repository/          ← Interfaces (contratos)
    │   │   └── IPostRepository.kt
    │   └── usecase/             ← Casos de uso
    │       └── ObtenerPostsUseCase.kt
    ├── data/                    ← Capa de datos
    │   ├── remote/              ← Fuentes remotas
    │   │   ├── dto/             ← Data Transfer Objects
    │   │   └── ApiService.kt
    │   ├── local/               ← Fuentes locales (base de datos)
    │   └── repository/          ← Implementaciones concretas
    │       └── PostRepositoryImpl.kt
    └── presentation/            ← ViewModels y estados de UI
        └── posts/
            ├── PostsViewModel.kt
            └── PostsUiState.kt


kotlin
// domain/repository/IPostRepository.kt
interface IPostRepository {
    suspend fun obtenerPosts(): Result<List<Post>>
    suspend fun obtenerPostLocal(id: Int): Post?
    suspend fun guardarPosts(posts: List<Post>)
}

// domain/usecase/ObtenerPostsUseCase.kt
class ObtenerPostsUseCase(private val repository: IPostRepository) {
    suspend operator fun invoke(): Result<List<Post>> {
        return repository.obtenerPosts()
            .onSuccess { posts ->
                repository.guardarPosts(posts)
            }
    }
}

// data/repository/PostRepositoryImpl.kt
class PostRepositoryImpl(
    private val apiService: ApiService,
    private val localDataSource: PostLocalDataSource
) : IPostRepository {

    override suspend fun obtenerPosts(): Result<List<Post>> {
        return apiService.obtenerPosts()
    }

    override suspend fun obtenerPostLocal(id: Int): Post? {
        return localDataSource.obtenerPorId(id)
    }

    override suspend fun guardarPosts(posts: List<Post>) {
        localDataSource.guardarTodos(posts)
    }
}


kotlin
// shared/src/commonTest/kotlin/domain/ObtenerPostsUseCaseTest.kt

import kotlinx.coroutines.test.runTest  // Para testear coroutines
import kotlin.test.*

class ObtenerPostsUseCaseTest {

    // Fake repository (implementación de prueba)
    private val fakeRepository = object : IPostRepository {
        var deberiaFallar = false
        val postsFake = listOf(
            Post(1, 1, "Título Test", "Cuerpo Test")
        )

        override suspend fun obtenerPosts(): Result<List<Post>> {
            return if (deberiaFallar) {
                Result.failure(Exception("Error de red simulado"))
            } else {
                Result.success(postsFake)
            }
        }

        override suspend fun obtenerPostLocal(id: Int) = null
        override suspend fun guardarPosts(posts: List<Post>) {}
    }

    private val useCase = ObtenerPostsUseCase(fakeRepository)

    @Test
    fun `cuando la red funciona, devuelve posts correctamente`() = runTest {
        val resultado = useCase()

        assertTrue(resultado.isSuccess)
        assertEquals(1, resultado.getOrNull()?.size)
        assertEquals("Título Test", resultado.getOrNull()?.first()?.title)
    }

    @Test
    fun `cuando la red falla, devuelve error`() = runTest {
        fakeRepository.deberiaFallar = true

        val resultado = useCase()

        assertTrue(resultado.isFailure)
        assertEquals("Error de red simulado", resultado.exceptionOrNull()?.message)
    }
}


yaml
# .github/workflows/kmp-ci.yml
name: KMP CI/CD

on:
  push:
    branches: [main, develop]
  pull_request:
    branches: [main]

jobs:
  # Tests compartidos (corren en Linux, más rápido y barato)
  test-shared:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-java@v4
        with:
          java-version: '21'
          distribution: 'temurin'
      - name: Ejecutar tests compartidos
        run: ./gradlew :shared:allTests

  # Tests y build Android
  test-android:
    runs-on: ubuntu-latest
    needs: test-shared
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-java@v4
        with:
          java-version: '21'
          distribution: 'temurin'
      - name: Build Android
        run: ./gradlew :androidApp:assembleDebug
      - name: Tests Android
        run: ./gradlew :androidApp:testDebugUnitTest

  # Build iOS (requiere macOS)
  build-ios:
    runs-on: macos-14  # Apple Silicon (M1)
    needs: test-shared
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-java@v4
        with:
          java-version: '21'
          distribution: 'temurin'
      - name: Compilar framework iOS
        run: ./gradlew :shared:linkDebugFrameworkIosSimulatorArm64
      - name: Build Xcode (simulador)
        run: |
          xcodebuild -project iosApp/iosApp.xcodeproj \
            -scheme iosApp \
            -destination 'platform=iOS Simulator,name=iPhone 16' \
            CODE_SIGNING_ALLOWED=NO \
            build

┌────────────────────────────────────────────────────────┐
│              Compose Multiplatform (CMP)                │
│                                                        │
│  @Composable fun PantallaInicio() { ... }              │
│                     ↓  UN SOLO CÓDIGO                  │
├──────────┬──────────┬──────────┬───────────────────────┤
│ Android  │   iOS    │ Desktop  │      Web (WASM)        │
│ (estable)│ (estable)│ (estable)│    (experimental)      │
└──────────┴──────────┴──────────┴───────────────────────┘


kotlin
// build.gradle.kts (nivel raíz)
plugins {
    alias(libs.plugins.kotlinMultiplatform).apply(false)
    alias(libs.plugins.androidApplication).apply(false)
    alias(libs.plugins.jetbrainsCompose).apply(false)  // ← Plugin CMP
    alias(libs.plugins.composeCompiler).apply(false)   // ← Compilador Compose K2
}


toml
# gradle/libs.versions.toml
[versions]
compose-multiplatform = "1.7.3"
kotlin = "2.1.0"
 
[plugins]
jetbrainsCompose = { id = "org.jetbrains.compose", version.ref = "compose-multiplatform" }
composeCompiler = { id = "org.jetbrains.kotlin.plugin.compose", version.ref = "kotlin" }


kotlin
// shared/build.gradle.kts
plugins {
    alias(libs.plugins.kotlinMultiplatform)
    alias(libs.plugins.androidLibrary)
    alias(libs.plugins.jetbrainsCompose)
    alias(libs.plugins.composeCompiler)
}
 
kotlin {
    androidTarget()
    iosX64(); iosArm64(); iosSimulatorArm64()
    jvm("desktop")   // Para Desktop
 
    sourceSets {
        commonMain.dependencies {
            // Compose Multiplatform
            implementation(compose.runtime)
            implementation(compose.foundation)
            implementation(compose.material3)          // Material Design 3
            implementation(compose.ui)
            implementation(compose.components.resources) // Recursos compartidos
            implementation(compose.components.uiToolingPreview)
 
            // Navegación KMP
            implementation(libs.navigation.compose)    // androidx.navigation 2.8+
        }
        androidMain.dependencies {
            implementation(compose.preview)
            implementation(libs.androidx.activity.compose)
        }
        val desktopMain by getting {
            dependencies {
                implementation(compose.desktop.currentOs)
            }
        }
    }
}
 
compose.desktop {
    application {
        mainClass = "MainKt"
        nativeDistributions {
            targetFormats(TargetFormat.Dmg, TargetFormat.Msi, TargetFormat.Deb)
            packageName = "MiAppDesktop"
            packageVersion = "1.0.0"
        }
    }
}


kotlin


kotlin
// shared/src/commonMain/kotlin/ui/theme/AppTheme.kt
 
import androidx.compose.foundation.isSystemInDarkTheme
import androidx.compose.material3.*
import androidx.compose.runtime.*
import androidx.compose.ui.graphics.Color
 
// Paleta de colores personalizada
private val colorPrimario = Color(0xFF6650A4)      // Púrpura Material 3
private val colorSecundario = Color(0xFF625B71)
private val colorTerciario = Color(0xFF7D5260)
 
private val EsquemaClaro = lightColorScheme(
    primary = colorPrimario,
    secondary = colorSecundario,
    tertiary = colorTerciario,
    background = Color(0xFFFFFBFE),
    surface = Color(0xFFFFFBFE),
    onPrimary = Color.White,
    onBackground = Color(0xFF1C1B1F),
    onSurface = Color(0xFF1C1B1F),
)
 
private val EsquemaOscuro = darkColorScheme(
    primary = Color(0xFFD0BCFF),
    secondary = Color(0xFFCCC2DC),
    tertiary = Color(0xFFEFB8C8),
    background = Color(0xFF1C1B1F),
    surface = Color(0xFF1C1B1F),
    onPrimary = Color(0xFF381E72),
    onBackground = Color(0xFFE6E1E5),
    onSurface = Color(0xFFE6E1E5),
)
 
@Composable
fun AppTheme(
    darkTheme: Boolean = isSystemInDarkTheme(),
    content: @Composable () -> Unit
) {
    val colorScheme = if (darkTheme) EsquemaOscuro else EsquemaClaro
 
    MaterialTheme(
        colorScheme = colorScheme,
        typography = Typography(),  // Puedes personalizar la tipografía aquí
        content = content
    )
}


kotlin


kotlin
// shared/src/commonMain/kotlin/navigation/AppNavigation.kt
 
import androidx.navigation.NavHostController
import androidx.navigation.compose.NavHost
import androidx.navigation.compose.composable
import androidx.navigation.compose.rememberNavController
import androidx.compose.runtime.Composable
 
// Define las rutas como sealed class para type-safety
sealed class Ruta(val path: String) {
    object ListaPosts : Ruta("posts")
    object DetallePost : Ruta("posts/{postId}") {
        fun conId(id: Int) = "posts/$id"
    }
    object Configuracion : Ruta("configuracion")
}
 
@Composable
fun AppNavigation(viewModelFactory: ViewModelFactory) {
    val navController = rememberNavController()
 
    AppTheme {
        NavHost(
            navController = navController,
            startDestination = Ruta.ListaPosts.path
        ) {
            composable(Ruta.ListaPosts.path) {
                PostsScreen(
                    viewModel = viewModelFactory.createPostsViewModel(),
                    onPostClick = { id ->
                        navController.navigate(Ruta.DetallePost.conId(id))
                    }
                )
            }
 
            composable(Ruta.DetallePost.path) { backStackEntry ->
                val postId = backStackEntry.arguments?.getString("postId")?.toIntOrNull()
                if (postId != null) {
                    DetallePostScreen(
                        postId = postId,
                        viewModel = viewModelFactory.createDetalleViewModel(postId),
                        onVolver = { navController.popBackStack() }
                    )
                }
            }
 
            composable(Ruta.Configuracion.path) {
                ConfiguracionScreen()
            }
        }
    }
}

shared/src/commonMain/
└── composeResources/
    ├── drawable/
    │   ├── logo.xml        ← Vector drawable
    │   └── banner.png      ← Imagen
    ├── font/
    │   └── inter.ttf       ← Fuente personalizada
    └── values/
        └── strings.xml     ← Strings (i18n)


xml
<!-- shared/src/commonMain/composeResources/values/strings.xml -->
<resources>
    <string name="app_name">Mi App KMP</string>
    <string name="posts_title">Posts</string>
    <string name="error_generic">Ha ocurrido un error inesperado</string>
    <string name="loading">Cargando...</string>
</resources>


kotlin
// Uso de recursos en composables
import miapp.shared.generated.resources.*
import org.jetbrains.compose.resources.stringResource
import org.jetbrains.compose.resources.painterResource
import org.jetbrains.compose.resources.Font
 
@Composable
fun EjemploRecursos() {
    // Strings localizados
    Text(text = stringResource(Res.string.app_name))
 
    // Imágenes
    Image(
        painter = painterResource(Res.drawable.logo),
        contentDescription = "Logo"
    )
 
    // Fuente personalizada
    val interFont = FontFamily(Font(Res.font.inter))
    Text(text = "Texto con fuente Inter", fontFamily = interFont)
}


kotlin
class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContent {
            // Llama directamente a tu composable compartido
            AppNavigation(viewModelFactory = AppViewModelFactory())
        }
    }
}


swift
import SwiftUI
import shared  // El framework KMP compilado
 
struct ContentView: View {
    var body: some View {
        // ComposeUIViewController integra Compose en SwiftUI
        ComposeView()
            .ignoresSafeArea(.keyboard)
    }
}
 
// MainViewController.kt (en iosMain)
// Esta función la llama Swift
fun MainViewController() = ComposeUIViewController {
    AppNavigation(viewModelFactory = AppViewModelFactory())
}


kotlin
// build.gradle.kts (proyecto servidor independiente)
plugins {
    kotlin("jvm") version "2.1.0"
    id("io.ktor.plugin") version "3.1.0"
    kotlin("plugin.serialization") version "2.1.0"
}
 
application {
    mainClass.set("com.miapi.ApplicationKt")
    // Para desarrollo: hot-reload automático
    val isDevelopment = project.ext.has("development")
    applicationDefaultJvmArgs = listOf("-Dio.ktor.development=$isDevelopment")
}
 
dependencies {
    // Ktor Server
    implementation("io.ktor:ktor-server-core-jvm:3.1.0")
    implementation("io.ktor:ktor-server-netty-jvm:3.1.0")      // Motor Netty
    implementation("io.ktor:ktor-server-content-negotiation-jvm:3.1.0")
    implementation("io.ktor:ktor-serialization-kotlinx-json-jvm:3.1.0")
    implementation("io.ktor:ktor-server-auth-jvm:3.1.0")        // Autenticación
    implementation("io.ktor:ktor-server-auth-jwt-jvm:3.1.0")    // JWT
    implementation("io.ktor:ktor-server-cors-jvm:3.1.0")        // CORS
    implementation("io.ktor:ktor-server-call-logging-jvm:3.1.0")// Logging
    implementation("io.ktor:ktor-server-request-validation:3.1.0")// Validación
    implementation("io.ktor:ktor-server-status-pages:3.1.0")    // Error handling
 
    // Base de datos
    implementation("org.jetbrains.exposed:exposed-core:0.55.0")
    implementation("org.jetbrains.exposed:exposed-dao:0.55.0")
    implementation("org.jetbrains.exposed:exposed-jdbc:0.55.0")
    implementation("org.jetbrains.exposed:exposed-kotlin-datetime:0.55.0")
    implementation("com.zaxxer:HikariCP:5.1.0")                 // Connection pool
    implementation("org.postgresql:postgresql:42.7.4")          // Driver PostgreSQL
 
    // DI
    implementation("io.insert-koin:koin-ktor:4.0.0")
 
    // Logging
    implementation("ch.qos.logback:logback-classic:1.5.12")
 
    // Testing
    testImplementation("io.ktor:ktor-server-test-host-jvm:3.1.0")
    testImplementation("org.jetbrains.kotlin:kotlin-test-junit:2.1.0")
}


kotlin
// src/main/kotlin/com/miapi/Application.kt
 
package com.miapi
 
import com.miapi.plugins.*
import io.ktor.server.application.*
import io.ktor.server.engine.*
import io.ktor.server.netty.*
 
fun main() {
    embeddedServer(
        factory = Netty,
        port = System.getenv("PORT")?.toInt() ?: 8080,
        host = "0.0.0.0",
        module = Application::module
    ).start(wait = true)
}
 
fun Application.module() {
    configureSecurity()       // JWT, roles
    configureSerialization()  // JSON
    configureHTTP()           // CORS, compresión
    configureMonitoring()     // Logging, métricas
    configureValidation()     // Validación de requests
    configureStatusPages()    // Manejo de errores
    configureDatabases()      // Conexión DB
    configureDI()             // Koin
    configureRouting()        // Rutas de la API
}


kotlin
// src/main/kotlin/com/miapi/plugins/Serialization.kt
import io.ktor.serialization.kotlinx.json.*
import io.ktor.server.application.*
import io.ktor.server.plugins.contentnegotiation.*
import kotlinx.serialization.json.Json
 
fun Application.configureSerialization() {
    install(ContentNegotiation) {
        json(Json {
            prettyPrint = true
            isLenient = true
            ignoreUnknownKeys = true
            encodeDefaults = false  // No incluye campos con valor default en JSON
        })
    }
}


kotlin
// src/main/kotlin/com/miapi/plugins/Security.kt
import com.auth0.jwt.JWT
import com.auth0.jwt.algorithms.Algorithm
import io.ktor.server.auth.*
import io.ktor.server.auth.jwt.*
import io.ktor.server.application.*
 
const val JWT_SECRET = System.getenv("JWT_SECRET") ?: "secreto-para-desarrollo"
const val JWT_ISSUER = "miapi.com"
const val JWT_AUDIENCE = "usuarios"
 
fun Application.configureSecurity() {
    authentication {
        jwt("auth-jwt") {
            realm = "Mi API"
            verifier(
                JWT.require(Algorithm.HMAC256(JWT_SECRET))
                    .withAudience(JWT_AUDIENCE)
                    .withIssuer(JWT_ISSUER)
                    .build()
            )
            validate { credential ->
                if (credential.payload.getClaim("userId").asString() != null) {
                    JWTPrincipal(credential.payload)
                } else {
                    null
                }
            }
        }
    }
}


kotlin
// src/main/kotlin/com/miapi/plugins/StatusPages.kt
// Manejo global de errores
import io.ktor.http.*
import io.ktor.server.application.*
import io.ktor.server.plugins.statuspages.*
import io.ktor.server.response.*
import kotlinx.serialization.Serializable
 
@Serializable
data class ErrorResponse(
    val codigo: Int,
    val mensaje: String,
    val detalle: String? = null
)
 
fun Application.configureStatusPages() {
    install(StatusPages) {
        // Maneja excepciones personalizadas
        exception<RecursoNoEncontradoException> { call, cause ->
            call.respond(
                HttpStatusCode.NotFound,
                ErrorResponse(404, cause.message ?: "Recurso no encontrado")
            )
        }
 
        exception<NoAutorizadoException> { call, _ ->
            call.respond(
                HttpStatusCode.Unauthorized,
                ErrorResponse(401, "No autorizado")
            )
        }
 
        exception<ValidacionException> { call, cause ->
            call.respond(
                HttpStatusCode.UnprocessableEntity,
                ErrorResponse(422, "Error de validación", cause.mensaje)
            )
        }
 
        // Catch-all para errores no controlados
        exception<Throwable> { call, cause ->
            call.application.log.error("Error no controlado", cause)
            call.respond(
                HttpStatusCode.InternalServerError,
                ErrorResponse(500, "Error interno del servidor")
            )
        }
 
        // Estado HTTP no manejado
        status(HttpStatusCode.NotFound) { call, status ->
            call.respond(status, ErrorResponse(404, "Ruta no encontrada"))
        }
    }
}
 
// Excepciones personalizadas
class RecursoNoEncontradoException(mensaje: String) : Exception(mensaje)
class NoAutorizadoException : Exception("No autorizado")
class ValidacionException(val mensaje: String) : Exception(mensaje)


kotlin
// src/main/kotlin/com/miapi/database/tables/Users.kt
 
import org.jetbrains.exposed.sql.Table
import org.jetbrains.exposed.kotlin.datetime.timestamp
 
// Definición de la tabla (DSL API)
object Users : Table("users") {
    val id = integer("id").autoIncrement()
    val nombre = varchar("nombre", 100)
    val email = varchar("email", 255).uniqueIndex()
    val passwordHash = varchar("password_hash", 255)
    val activo = bool("activo").default(true)
    val creadoEn = timestamp("creado_en")
    override val primaryKey = PrimaryKey(id)
}
 
object Posts : Table("posts") {
    val id = integer("id").autoIncrement()
    val userId = integer("user_id").references(Users.id)
    val titulo = varchar("titulo", 200)
    val contenido = text("contenido")
    val publicado = bool("publicado").default(false)
    val creadoEn = timestamp("creado_en")
    override val primaryKey = PrimaryKey(id)
}


kotlin
// src/main/kotlin/com/miapi/database/DatabaseFactory.kt
 
import com.zaxxer.hikari.HikariConfig
import com.zaxxer.hikari.HikariDataSource
import kotlinx.coroutines.Dispatchers
import org.jetbrains.exposed.sql.*
import org.jetbrains.exposed.sql.transactions.experimental.newSuspendedTransaction
import org.jetbrains.exposed.sql.transactions.transaction
 
object DatabaseFactory {
    fun init() {
        val config = HikariConfig().apply {
            jdbcUrl = System.getenv("DATABASE_URL") ?: "jdbc:postgresql://localhost:5432/midb"
            driverClassName = "org.postgresql.Driver"
            username = System.getenv("DB_USER") ?: "postgres"
            password = System.getenv("DB_PASSWORD") ?: "postgres"
            maximumPoolSize = 10
            isAutoCommit = false
            transactionIsolation = "TRANSACTION_REPEATABLE_READ"
            validate()
        }
 
        Database.connect(HikariDataSource(config))
 
        // Crear tablas si no existen
        transaction {
            SchemaUtils.create(Users, Posts)
        }
    }
 
    // Función helper para ejecutar queries de forma suspendida
    suspend fun <T> dbQuery(block: suspend Transaction.() -> T): T =
        newSuspendedTransaction(Dispatchers.IO) { block() }
}


kotlin


kotlin


kotlin
// src/test/kotlin/com/miapi/routes/UserRoutesTest.kt
 
import io.ktor.client.request.*
import io.ktor.client.statement.*
import io.ktor.http.*
import io.ktor.server.testing.*
import kotlinx.serialization.json.Json
import kotlin.test.*
 
class UserRoutesTest {
 
    // Fake repository para tests
    private val fakeRepo = FakeUserRepository()
 
    @Test
    fun `GET users devuelve lista vacía cuando no hay usuarios`() = testApplication {
        application { module(userRepository = fakeRepo) }
 
        val response = client.get("/api/v1/users")
 
        assertEquals(HttpStatusCode.OK, response.status)
        val body = Json.decodeFromString<PaginatedResponse<UserDto>>(response.bodyAsText())
        assertEquals(0, body.total)
    }
 
    @Test
    fun `POST users crea usuario correctamente`() = testApplication {
        application { module(userRepository = fakeRepo) }
 
        val response = client.post("/api/v1/users") {
            contentType(ContentType.Application.Json)
            setBody("""{"nombre":"Test","email":"test@test.com","password":"12345678"}""")
        }
 
        assertEquals(HttpStatusCode.Created, response.status)
        val usuario = Json.decodeFromString<UserDto>(response.bodyAsText())
        assertEquals("Test", usuario.nombre)
    }
 
    @Test
    fun `GET users por id inválido devuelve 422`() = testApplication {
        application { module(userRepository = fakeRepo) }
 
        val response = client.get("/api/v1/users/abc")
        assertEquals(HttpStatusCode.UnprocessableEntity, response.status)
    }
}

┌──────────────────────────────────────────────────────┐
│                        UI (View)                      │
│                                                      │
│  Observa State ←────────────  Envía Intent ──────→   │
└──────────────────┬───────────────────────────────────┘
                   │ State                 ↑ Intent
                   │                      │
┌──────────────────▼───────────────────────────────────┐
│                    ViewModel / Store                  │
│                                                      │
│  State = reduce(State_anterior + Intent)              │
└──────────────────────────────────────────────────────┘


kotlin
// shared/src/commonMain/kotlin/presentation/base/MviViewModel.kt
 
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.flow.*
import kotlinx.coroutines.launch
 
// ViewModel base genérico para MVI
abstract class MviViewModel<S : Any, I : Any, E : Any>(
    private val initialState: S,
    protected val scope: CoroutineScope
) {
    // Estado actual de la UI (inmutable hacia afuera)
    private val _state = MutableStateFlow(initialState)
    val state: StateFlow<S> = _state.asStateFlow()
 
    // Eventos de un solo uso (navegación, snackbars, etc.)
    private val _events = MutableSharedFlow<E>(extraBufferCapacity = 10)
    val events: SharedFlow<E> = _events.asSharedFlow()
 
    // Punto de entrada para los intents del usuario
    fun onIntent(intent: I) {
        scope.launch {
            processIntent(intent)
        }
    }
 
    // Cada ViewModel implementa su propia lógica
    protected abstract suspend fun processIntent(intent: I)
 
    // Helper para actualizar el estado de forma segura
    protected fun updateState(transform: S.() -> S) {
        _state.update { it.transform() }
    }
 
    // Helper para emitir eventos de un solo uso
    protected suspend fun emitEvent(event: E) {
        _events.emit(event)
    }
}


kotlin
// shared/src/commonMain/kotlin/presentation/posts/PostsMvi.kt
 
import kotlinx.serialization.Serializable
 
// === STATE ===
// El estado completo de la pantalla de posts
data class PostsState(
    val posts: List<Post> = emptyList(),
    val estaCargando: Boolean = false,
    val error: String? = null,
    val busqueda: String = "",
    val paginaActual: Int = 1,
    val hasMasPaginas: Boolean = true
) {
    // Estado derivado: posts filtrados por búsqueda
    val postsFiltrados: List<Post>
        get() = if (busqueda.isBlank()) posts
                else posts.filter {
                    it.title.contains(busqueda, ignoreCase = true) ||
                    it.body.contains(busqueda, ignoreCase = true)
                }
}
 
// === INTENT ===
// Todas las acciones posibles del usuario
sealed class PostsIntent {
    object CargarPosts : PostsIntent()
    object CargarMasPosts : PostsIntent()
    object Recargar : PostsIntent()
    data class BuscarPosts(val query: String) : PostsIntent()
    data class ClickPost(val postId: Int) : PostsIntent()
    data class EliminarPost(val postId: Int) : PostsIntent()
}
 
// === EVENT ===
// Efectos de un solo uso (no son estado persistente)
sealed class PostsEvent {
    data class NavegateToDetail(val postId: Int) : PostsEvent()
    data class MostrarSnackbar(val mensaje: String) : PostsEvent()
    object ScrollToTop : PostsEvent()
}


kotlin


kotlin
// shared/src/commonMain/kotlin/ui/screens/PostsMviScreen.kt
 
@Composable
fun PostsMviScreen(
    viewModel: PostsMviViewModel,
    navController: NavController
) {
    val state by viewModel.state.collectAsState()
    val snackbarHostState = remember { SnackbarHostState() }
 
    // Manejar eventos de un solo uso
    LaunchedEffect(Unit) {
        viewModel.events.collect { event ->
            when (event) {
                is PostsEvent.NavegateToDetail ->
                    navController.navigate(Ruta.DetallePost.conId(event.postId))
 
                is PostsEvent.MostrarSnackbar ->
                    snackbarHostState.showSnackbar(event.mensaje)
 
                is PostsEvent.ScrollToTop -> { /* scroll to top */ }
            }
        }
    }
 
    Scaffold(snackbarHost = { SnackbarHost(snackbarHostState) }) { padding ->
        Column(modifier = Modifier.padding(padding)) {
 
            // Barra de búsqueda
            SearchBar(
                query = state.busqueda,
                onQueryChange = { viewModel.onIntent(PostsIntent.BuscarPosts(it)) }
            )
 
            // Lista de posts filtrados
            LazyColumn {
                items(state.postsFiltrados, key = { it.id }) { post ->
                    PostCard(
                        post = post,
                        onClick = { viewModel.onIntent(PostsIntent.ClickPost(post.id)) }
                    )
                }
 
                // Indicador de carga al final para paginación
                if (state.estaCargando) {
                    item {
                        Box(Modifier.fillMaxWidth(), contentAlignment = Alignment.Center) {
                            CircularProgressIndicator(modifier = Modifier.padding(16.dp))
                        }
                    }
                }
            }
        }
    }
}

Código Kotlin (KMP)          Framework iOS generado
──────────────────────        ──────────────────────
class PostViewModel    →      @objc class PostViewModel
fun cargarPosts()      →      func cargarPosts()
data class Post        →      @objc class Post (con propiedades)
suspend fun x()        →      PROBLEMA → necesita adaptación
Flow<T>                →      PROBLEMA → necesita adaptación


kotlin
// shared/build.gradle.kts
plugins {
    id("co.touchlab.skie") version "0.9.0"
}


kotlin
// Con SKIE, esto en Kotlin:
class PostViewModel {
    val posts: StateFlow<PostsState> = _posts.asStateFlow()
    suspend fun cargarPosts() { ... }
}


swift
// Se convierte automáticamente en esto en Swift:
// (sin ningún código de adaptación extra)
 
let viewModel = PostViewModel()
 
// Observar un StateFlow como AsyncSequence
Task {
    for await state in viewModel.posts {
        self.state = state
    }
}
 
// Llamar a suspend fun como async/await
Task {
    await viewModel.cargarPosts()
}


kotlin
// shared/src/iosMain/kotlin/presentation/PostViewModelWrapper.kt
// Esta clase es solo para iOS; Android usa el ViewModel directamente
 
import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
 
// Wrapper que expone callbacks en lugar de Flows
class PostViewModelIos(
    private val viewModel: PostsMviViewModel
) {
    private val scope = MainScope()  // Scope vinculado al hilo principal de iOS
 
    // Expone el estado como callback en lugar de Flow
    fun observarEstado(onState: (PostsState) -> Unit): () -> Unit {
        val job = scope.launch {
            viewModel.state.collect { estado ->
                onState(estado)
            }
        }
        // Devuelve función de cancelación
        return { job.cancel() }
    }
 
    fun cargarPosts() {
        scope.launch { viewModel.onIntent(PostsIntent.CargarPosts) }
    }
 
    // Importante: cancelar el scope cuando el ViewModel se destruye
    fun onDestroy() {
        scope.cancel()
    }
}


swift
// Uso en SwiftUI (sin SKIE)
class PostsSwiftViewModel: ObservableObject {
    @Published var state = PostsState()
    
    private let viewModel = PostViewModelIos(
        viewModel: PostsMviViewModel(/* ... */)
    )
    private var cancelObserver: (() -> Void)?
    
    init() {
        cancelObserver = viewModel.observarEstado { [weak self] newState in
            DispatchQueue.main.async {
                self?.state = newState
            }
        }
        viewModel.cargarPosts()
    }
    
    func cargarPosts() {
        viewModel.cargarPosts()
    }
    
    deinit {
        cancelObserver?()
        viewModel.onDestroy()
    }
}
 
struct PostsView: View {
    @StateObject private var viewModel = PostsSwiftViewModel()
    
    var body: some View {
        List(viewModel.state.posts, id: \.id) { post in
            Text(post.title)
        }
        .onAppear { viewModel.cargarPosts() }
    }
}


kotlin
import kotlin.native.ObjCName
 
// Cambia el nombre en Swift/Objective-C
@ObjCName("PostItem", exact = true)
data class Post(val id: Int, val title: String, val body: String)
 
// Oculta una clase del framework Swift
@HiddenFromObjC
internal class ClaseInternaDeSoloKotlin(...)
 
// Hacer que una interfaz sea más amigable para Swift
@ObjCName("PostRepositoryProtocol")
interface IPostRepository {
    @ObjCName("fetchPosts")
    suspend fun obtenerPosts(): Result<List<Post>>
}


kotlin
// En iosMain: usar APIs de iOS desde Kotlin
import platform.UIKit.*
import platform.Foundation.*
import platform.CoreLocation.*
 
actual class LocationService {
    private val locationManager = CLLocationManager()
 
    actual fun solicitarPermisos() {
        locationManager.requestWhenInUseAuthorization()
    }
 
    actual fun obtenerUbicacion(): Pair<Double, Double>? {
        val loc = locationManager.location ?: return null
        return Pair(loc.coordinate.useContents { latitude }, 
                    loc.coordinate.useContents { longitude })
    }
}
 
// Mostrar un UIAlertController desde Kotlin
fun mostrarAlertaIOS(titulo: String, mensaje: String) {
    val alert = UIAlertController.alertControllerWithTitle(
        title = titulo,
        message = mensaje,
        preferredStyle = UIAlertControllerStyleAlert
    )
    alert.addAction(
        UIAlertAction.actionWithTitle("OK", style = UIAlertActionStyleDefault, handler = null)
    )
    UIApplication.sharedApplication.keyWindow?.rootViewController
        ?.presentViewController(alert, animated = true, completion = null)
}


kotlin
// Tracing manual para el profiler
import androidx.tracing.trace
 
fun operacionCritica() {
    trace("MiOperacion") {  // Aparece como sección en el profiler
        // ... código a medir
    }
}


kotlin
// ❌ MALO: Se recompone CADA VEZ que cambia cualquier parte del estado
@Composable
fun PantallaCompleta(viewModel: MiViewModel) {
    val estadoCompleto by viewModel.state.collectAsState()
    ItemCaro(estadoCompleto.contador)  // Se recompone si cambia CUALQUIER campo del estado
}
 
// ✅ BUENO: Solo se recompone cuando cambia el contador
@Composable
fun PantallaCompleta(viewModel: MiViewModel) {
    val contador by viewModel.state
        .map { it.contador }           // Seleccionamos solo lo que necesitamos
        .collectAsState(initial = 0)
    ItemCaro(contador)
}
 
// Usar remember para cálculos costosos
@Composable
fun ListaFiltrada(items: List<Item>, query: String) {
    // ✅ Solo recalcula cuando items o query cambian
    val filtrados = remember(items, query) {
        items.filter { it.nombre.contains(query, ignoreCase = true) }
    }
    // ... usar filtrados
}
 
// Usar key en LazyColumn para reutilizar composables
@Composable
fun Lista(items: List<Item>) {
    LazyColumn {
        items(
            items = items,
            key = { it.id }  // ✅ Evita recrear composables cuando cambia el orden
        ) { item ->
            ItemComposable(item)
        }
    }
}
 
// @Stable y @Immutable para tipos que Compose no puede inferir como estables
@Immutable
data class ConfiguracionUI(
    val colorPrimario: Color,
    val mostrarAyuda: Boolean
)


kotlin
// ❌ MALO: lanzar demasiadas coroutines individuales
suspend fun procesarLista(items: List<Item>) {
    items.forEach { item ->
        launch { procesarItem(item) }  // Una coroutine por item puede ser demasiado
    }
}
 
// ✅ BUENO: usar chunking o limitación de concurrencia
import kotlinx.coroutines.sync.Semaphore
 
suspend fun procesarListaOptimizado(items: List<Item>) {
    val semaforo = Semaphore(permits = 4)  // Máximo 4 concurrent
    items.map { item ->
        async {
            semaforo.withPermit {
                procesarItem(item)
            }
        }
    }.awaitAll()
}
 
// Usar channelFlow para producers complejos
fun datosDesdeMultiplesFuentes(): Flow<Dato> = channelFlow {
    launch { fuente1.collect { send(it) } }
    launch { fuente2.collect { send(it) } }
}
 
// Compartir un Flow caro entre múltiples colectores
class MiRepository(private val api: ApiService) {
    // Sin shareIn: cada colector hace una llamada de red independiente
    // Con shareIn: todos comparten la misma llamada de red
    val datosCompartidos = api.obtenerDatos()
        .shareIn(
            scope = repositoryScope,
            started = SharingStarted.WhileSubscribed(5000),  // Para 5s después del último colector
            replay = 1  // Emite el último valor a nuevos colectores
        )
}


kotlin
// shared/build.gradle.kts — Configuración de optimización para iOS release
 
kotlin {
    iosArm64 {
        binaries.framework("shared") {
            // En release, activa optimizaciones
            if (!debuggable) {
                freeCompilerArgs += listOf(
                    "-Xbinary=bundleId=com.miapp.shared",
                    // Optimización de tamaño de binario
                    "-opt-in=kotlin.native.internal.InternalForKotlinNative"
                )
            }
        }
    }
}


bash
# En Xcode, cuando el app está pausado en un breakpoint de Kotlin,
# puedes usar el LLDB con comandos Kotlin:
# (lldb) expression -- import shared
# (lldb) po miVariable


kotlin
// shared/src/commonMain/kotlin/utils/Logger.kt
import io.github.aakira.napier.Napier
import io.github.aakira.napier.DebugAntilog
 
// Inicialización (solo en debug)
fun initNapier() {
    Napier.base(DebugAntilog())
}
 
// Uso en cualquier parte del código compartido
class PostRepository(private val api: ApiService) {
    suspend fun obtenerPosts(): Result<List<Post>> {
        Napier.d("Iniciando carga de posts", tag = "PostRepository")
        return api.obtenerPosts()
            .onSuccess { Napier.i("Posts cargados: ${it.size}", tag = "PostRepository") }
            .onFailure { Napier.e("Error cargando posts", it, tag = "PostRepository") }
    }
}


kotlin
// androidApp/build.gradle.kts
android {
    signingConfigs {
        create("release") {
            // Lee las credenciales de variables de entorno (nunca las hardcodees)
            storeFile = file(System.getenv("KEYSTORE_PATH") ?: "keystore.jks")
            storePassword = System.getenv("KEYSTORE_PASSWORD")
            keyAlias = System.getenv("KEY_ALIAS")
            keyPassword = System.getenv("KEY_PASSWORD")
        }
    }
 
    buildTypes {
        release {
            isMinifyEnabled = true           // Activa R8/ProGuard
            isShrinkResources = true         // Elimina recursos no usados
            signingConfig = signingConfigs.getByName("release")
            proguardFiles(
                getDefaultProguardFile("proguard-android-optimize.txt"),
                "proguard-rules.pro"
            )
        }
    }
}

# proguard-rules.pro
 
# Mantener clases de kotlinx.serialization
-keepattributes *Annotation*, InnerClasses
-dontnote kotlinx.serialization.AnnotationsKt
-keepclassmembers class kotlinx.serialization.json.** { *** Companion; }
-keepclasseswithmembers class kotlinx.serialization.json.** { kotlinx.serialization.KSerializer serializer(...); }
 
# Mantener data classes serializables
-keep @kotlinx.serialization.Serializable class * { *; }
 
# Ktor
-keep class io.ktor.** { *; }
-keep class kotlinx.coroutines.** { *; }
 
# SQLDelight
-keep class app.cash.sqldelight.** { *; }


bash
./gradlew :androidApp:bundleRelease
# El archivo .aab estará en: androidApp/build/outputs/bundle/release/


kotlin
// shared/build.gradle.kts
kotlin {
    // Genera un XCFramework unificado para todos los targets iOS
    val xcfName = "shared"
 
    targets.withType<org.jetbrains.kotlin.gradle.plugin.mpp.KotlinNativeTarget> {
        binaries.framework {
            baseName = xcfName
            isStatic = true  // Framework estático (recomendado para iOS)
        }
    }
}


bash
# Generar el XCFramework para distribución
./gradlew :shared:assembleSharedXCFramework
 
# El XCFramework estará en:
# shared/build/XCFrameworks/release/shared.xcframework


swift
// Package.swift
// swift-tools-version:5.9
import PackageDescription
 
let package = Package(
    name: "shared",
    platforms: [.iOS(.v16)],
    products: [
        .library(name: "shared", targets: ["shared"])
    ],
    targets: [
        .binaryTarget(
            name: "shared",
            path: "./shared/build/XCFrameworks/release/shared.xcframework"
        )
    ]
)


ruby
# fastlane/Fastfile
 
# Carril para Android
lane :deploy_android do
  gradle(
    task: "bundle",
    build_type: "Release",
    project_dir: "androidApp/",
    properties: {
      "android.injected.signing.store.file" => ENV["KEYSTORE_PATH"],
      "android.injected.signing.store.password" => ENV["KEYSTORE_PASSWORD"],
      "android.injected.signing.key.alias" => ENV["KEY_ALIAS"],
      "android.injected.signing.key.password" => ENV["KEY_PASSWORD"]
    }
  )
  upload_to_play_store(
    track: "internal",  # internal → alpha → beta → production
    aab: "androidApp/build/outputs/bundle/release/androidApp-release.aab"
  )
end
 
# Carril para iOS
lane :deploy_ios do
  # Primero compilamos el framework KMP
  sh("cd .. && ./gradlew :shared:assembleSharedXCFramework")
 
  # Actualiza automáticamente los certificados y perfiles
  match(type: "appstore")
 
  # Build y firma
  gym(
    scheme: "iosApp",
    workspace: "iosApp/iosApp.xcworkspace",
    export_method: "app-store"
  )
 
  # Sube a TestFlight
  upload_to_testflight(
    skip_waiting_for_build_processing: true
  )
end


yaml
# .github/workflows/deploy.yml — Deploy automático desde CI
 
name: Deploy a Stores
 
on:
  push:
    tags:
      - 'v*'  # Se activa con tags tipo v1.0.0, v1.2.3
 
jobs:
  deploy-android:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-java@v4
        with: { java-version: '21', distribution: 'temurin' }
      - name: Deploy Android
        env:
          KEYSTORE_PATH: ${{ secrets.KEYSTORE_PATH }}
          KEYSTORE_PASSWORD: ${{ secrets.KEYSTORE_PASSWORD }}
          KEY_ALIAS: ${{ secrets.KEY_ALIAS }}
          KEY_PASSWORD: ${{ secrets.KEY_PASSWORD }}
        run: bundle exec fastlane deploy_android
 
  deploy-ios:
    runs-on: macos-14
    needs: deploy-android  # Espera a que Android termine primero
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-java@v4
        with: { java-version: '21', distribution: 'temurin' }
      - name: Deploy iOS
        env:
          MATCH_PASSWORD: ${{ secrets.MATCH_PASSWORD }}
          APP_STORE_CONNECT_API_KEY: ${{ secrets.APP_STORE_CONNECT_API_KEY }}
        run: bundle exec fastlane deploy_ios


kotlin
// build.gradle.kts (nivel raíz)
// Gestiona la versión de forma centralizada
 
object AppVersion {
    const val MAJOR = 1
    const val MINOR = 3
    const val PATCH = 0
 
    val name get() = "$MAJOR.$MINOR.$PATCH"
    val code get() = MAJOR * 10000 + MINOR * 100 + PATCH  // Ej: 10300
}


kotlin
// androidApp/build.gradle.kts
android {
    defaultConfig {
        versionCode = AppVersion.code    // 10300
        versionName = AppVersion.name    // "1.3.0"
    }
}


kotlin
import androidx.compose.animation.core.*
import androidx.compose.foundation.background
import androidx.compose.foundation.clickable
import androidx.compose.foundation.layout.*
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Text
import androidx.compose.runtime.*
import androidx.compose.ui.Modifier
import androidx.compose.ui.draw.clip
import androidx.compose.ui.draw.scale
import androidx.compose.ui.unit.dp

@Composable
fun BotonAnimado(texto: String, onClick: () -> Unit) {
    var presionado by remember { mutableStateOf(false) }

    // Anima el tamaño: cuando presionado=true va a 0.95f, cuando false vuelve a 1f
    val escala by animateFloatAsState(
        targetValue = if (presionado) 0.95f else 1f,
        animationSpec = spring(
            dampingRatio = Spring.DampingRatioMediumBouncy,  // Efecto rebote
            stiffness = Spring.StiffnessLow
        ),
        label = "escala_boton"  // Label requerida para debugging en Android Studio
    )

    // Anima el color de fondo
    val colorFondo by animateColorAsState(
        targetValue = if (presionado)
            MaterialTheme.colorScheme.primaryContainer
        else
            MaterialTheme.colorScheme.primary,
        animationSpec = tween(durationMillis = 200),
        label = "color_boton"
    )

    // Anima el radio de las esquinas
    val radio by animateDpAsState(
        targetValue = if (presionado) 24.dp else 12.dp,
        animationSpec = tween(durationMillis = 150),
        label = "radio_boton"
    )

    Box(
        modifier = Modifier
            .scale(escala)
            .clip(RoundedCornerShape(radio))
            .background(colorFondo)
            .clickable {
                presionado = !presionado
                onClick()
            }
            .padding(horizontal = 24.dp, vertical = 12.dp)
    ) {
        Text(
            text = texto,
            color = MaterialTheme.colorScheme.onPrimary,
            style = MaterialTheme.typography.labelLarge
        )
    }
}

Función	Tipo animado
`animateFloatAsState`	`Float`
`animateDpAsState`	`Dp`
`animateColorAsState`	`Color`
`animateSizeAsState`	`Size`
`animateOffsetAsState`	`Offset`
`animateIntAsState`	`Int`
`animateIntOffsetAsState`	`IntOffset`
`animateValueAsState<T>`	Cualquier tipo con `TwoWayConverter`


kotlin
// spring(): simula física de resorte. El más natural
val especResorte = spring<Float>(
    dampingRatio = Spring.DampingRatioMediumBouncy,  // Cuánto rebota
    stiffness = Spring.StiffnessLow  // Qué tan rígido (rápido)
)
// dampingRatio: 
//   NoBouncy (1.0) = sin rebote
//   LowBouncy (0.75) = poco rebote
//   MediumBouncy (0.5) = rebote medio (el más usado)
//   HighBouncy (0.2) = mucho rebote
// stiffness:
//   VeryLow = muy lento, flojo
//   Low = lento
//   Medium = velocidad normal
//   High = rápido
//   VeryHigh = muy rápido

// tween(): duración fija con easing
val especTween = tween<Float>(
    durationMillis = 300,
    delayMillis = 100,  // Espera antes de empezar
    easing = FastOutSlowInEasing  // Aceleración → deceleración (Material Design)
    // Otros easings:
    // LinearEasing, LinearOutSlowInEasing, FastOutLinearInEasing
    // CubicBezierEasing(0.4f, 0f, 0.2f, 1f) → personalizado
)

// keyframes(): define valores intermedios exactos
val especKeyframes = keyframes<Float> {
    durationMillis = 500
    0f at 0            // En el ms 0, valor = 0
    0.8f at 200        // En el ms 200, valor = 0.8
    0.95f at 350       // En el ms 350, valor = 0.95
    1f at 500          // En el ms 500, valor = 1
}

// repeatable(): repite la animación
val especRepetible = repeatable<Float>(
    iterations = 3,              // Número de repeticiones (o Infinite)
    animation = tween(500),
    repeatMode = RepeatMode.Reverse  // Reverse = ida y vuelta, Restart = reinicia
)

// infiniteRepeatable(): repite indefinidamente (para loaders, pulsos, etc.)
val especInfinito = infiniteRepeatable<Float>(
    animation = tween(1000, easing = LinearEasing),
    repeatMode = RepeatMode.Reverse
)


kotlin


kotlin


kotlin
import androidx.compose.animation.*
import androidx.compose.material3.Text
import androidx.compose.runtime.*

@Composable
fun ContadorAnimado(contador: Int) {
    AnimatedContent(
        targetState = contador,
        transitionSpec = {
            // initialState es el valor anterior, targetState el nuevo
            if (targetState > initialState) {
                // Subiendo: nuevo entra desde arriba, viejo sale por abajo
                slideInVertically { height -> -height } + fadeIn() togetherWith
                    slideOutVertically { height -> height } + fadeOut()
            } else {
                // Bajando: nuevo entra desde abajo, viejo sale por arriba
                slideInVertically { height -> height } + fadeIn() togetherWith
                    slideOutVertically { height -> -height } + fadeOut()
            }.using(
                SizeTransform(clip = false)  // No recorta el contenido durante la transición
            )
        },
        label = "contador_animado"
    ) { valorActual ->
        Text(
            text = "$valorActual",
            style = MaterialTheme.typography.displayLarge
        )
    }
}

// AnimatedContent para estados de carga
@Composable
fun ContentConEstados(estado: EstadoCarga) {
    AnimatedContent(
        targetState = estado,
        transitionSpec = {
            fadeIn(tween(300)) togetherWith fadeOut(tween(150))
        },
        label = "estado_carga"
    ) { estadoActual ->
        when (estadoActual) {
            EstadoCarga.CARGANDO -> CircularProgressIndicator()
            EstadoCarga.EXITO -> Text("✅ ¡Listo!")
            EstadoCarga.ERROR -> Text("❌ Error")
        }
    }
}

enum class EstadoCarga { CARGANDO, EXITO, ERROR }


kotlin


kotlin
import androidx.compose.animation.core.*
import androidx.compose.foundation.background
import androidx.compose.foundation.layout.*
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.material3.*
import androidx.compose.runtime.*
import androidx.compose.ui.draw.clip
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.unit.dp

enum class EstadoTarjeta { COLAPSADA, EXPANDIDA }

@Composable
fun TarjetaExpandible(contenido: String) {
    var estado by remember { mutableStateOf(EstadoTarjeta.COLAPSADA) }

    // updateTransition sincroniza todas las animaciones al mismo estado
    val transicion = updateTransition(
        targetState = estado,
        label = "tarjeta_expandible"
    )

    // Cada propiedad tiene su propia spec pero están sincronizadas
    val altura by transicion.animateDp(
        transitionSpec = { spring(dampingRatio = Spring.DampingRatioMediumBouncy) },
        label = "altura_tarjeta"
    ) { estadoActual ->
        when (estadoActual) {
            EstadoTarjeta.COLAPSADA -> 80.dp
            EstadoTarjeta.EXPANDIDA -> 240.dp
        }
    }

    val colorFondo by transicion.animateColor(
        transitionSpec = { tween(300) },
        label = "color_fondo_tarjeta"
    ) { estadoActual ->
        when (estadoActual) {
            EstadoTarjeta.COLAPSADA -> MaterialTheme.colorScheme.surfaceVariant
            EstadoTarjeta.EXPANDIDA -> MaterialTheme.colorScheme.primaryContainer
        }
    }

    val radio by transicion.animateDp(
        transitionSpec = { tween(300) },
        label = "radio_tarjeta"
    ) { estadoActual ->
        when (estadoActual) {
            EstadoTarjeta.COLAPSADA -> 12.dp
            EstadoTarjeta.EXPANDIDA -> 24.dp
        }
    }

    Box(
        modifier = Modifier
            .fillMaxWidth()
            .height(altura)
            .clip(RoundedCornerShape(radio))
            .background(colorFondo)
            .clickable {
                estado = when (estado) {
                    EstadoTarjeta.COLAPSADA -> EstadoTarjeta.EXPANDIDA
                    EstadoTarjeta.EXPANDIDA -> EstadoTarjeta.COLAPSADA
                }
            }
            .padding(16.dp)
    ) {
        Text(contenido)
    }
}


kotlin
// wearApp/build.gradle.kts
plugins {
    alias(libs.plugins.androidApplication)
    alias(libs.plugins.kotlinAndroid)
}

android {
    namespace = "com.miapp.wear"
    compileSdk = 35

    defaultConfig {
        minSdk = 30  // Wear OS 3.0+
        targetSdk = 35
    }
}

dependencies {
    // Accede al módulo shared de KMP
    implementation(project(":shared"))

    // Compose for Wear OS
    implementation(libs.wear.compose.material)
    implementation(libs.wear.compose.foundation)
    implementation(libs.wear.compose.navigation)

    // Horologist: librería oficial de Google para Wear OS con Compose
    // Proporciona componentes optimizados: listas con scroll circular, etc.
    implementation(libs.horologist.compose.layout)
    implementation(libs.horologist.compose.material)
    implementation(libs.horologist.data.core)

    // Lifecycle y ViewModel para Wear
    implementation(libs.androidx.lifecycle.runtime.compose)
    implementation(libs.androidx.lifecycle.viewmodel.compose)
}


toml
# gradle/libs.versions.toml — Versiones Wear OS 2026
[versions]
wear-compose = "1.4.1"
horologist = "0.6.20"

[libraries]
wear-compose-material = { module = "androidx.wear.compose:compose-material3", version.ref = "wear-compose" }
wear-compose-foundation = { module = "androidx.wear.compose:compose-foundation", version.ref = "wear-compose" }
wear-compose-navigation = { module = "androidx.wear.compose:compose-navigation", version.ref = "wear-compose" }
horologist-compose-layout = { module = "com.google.android.horologist:horologist-compose-layout", version.ref = "horologist" }
horologist-compose-material = { module = "com.google.android.horologist:horologist-compose-material", version.ref = "horologist" }
horologist-data-core = { module = "com.google.android.horologist:horologist-data-core", version.ref = "horologist" }


kotlin
// wearApp/src/main/kotlin/com/miapp/wear/presentation/WearMainScreen.kt

import androidx.compose.foundation.layout.*
import androidx.compose.runtime.*
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.unit.dp
import androidx.wear.compose.material3.*
import com.google.android.horologist.compose.layout.*
import com.miapp.shared.presentation.PostsState  // ← Clase del módulo KMP compartido
import com.miapp.shared.presentation.PostsMviViewModel

@Composable
fun WearMainScreen(viewModel: PostsMviViewModel) {
    // Reusa el mismo ViewModel KMP en Wear OS
    val estado by viewModel.state.collectAsState()

    // ScalingLazyColumn: la lista circular optimizada para relojes
    AppScaffold {
        ScalingLazyColumn(
            modifier = Modifier.fillMaxSize(),
            columnState = rememberColumnState(),
            horizontalAlignment = Alignment.CenterHorizontally
        ) {
            item {
                ListHeader {
                    Text("Posts", style = MaterialTheme.typography.titleSmall)
                }
            }

            when (val s = estado) {
                is PostsState.Cargando -> item {
                    CircularProgressIndicator()
                }
                is PostsState.Exitoso -> items(
                    count = s.posts.size.coerceAtMost(10)  // Máximo 10 en reloj
                ) { index ->
                    val post = s.posts[index]
                    // Chip: el componente de lista principal en Wear OS
                    Chip(
                        label = {
                            Text(
                                post.title.take(30) + if (post.title.length > 30) "…" else "",
                                style = MaterialTheme.typography.bodySmall
                            )
                        },
                        onClick = { /* navegar */ },
                        modifier = Modifier.fillMaxWidth()
                    )
                }
                is PostsState.Error -> item {
                    Text(s.mensaje, style = MaterialTheme.typography.bodySmall)
                }
            }
        }
    }
}


kotlin
// shared/build.gradle.kts
kotlin {
    androidTarget()

    // iOS
    iosX64(); iosArm64(); iosSimulatorArm64()

    // tvOS — añade estas líneas
    tvosX64()
    tvosArm64()
    tvosSimulatorArm64()

    sourceSets {
        // commonMain compartido por iOS y tvOS (tienen APIs similares)
        val appleMain by creating {
            dependsOn(commonMain.get())
        }
        val iosMain by getting { dependsOn(appleMain) }
        val tvosMain by getting { dependsOn(appleMain) }

        // Dependencias específicas de tvOS
        tvosMain.dependencies {
            // Las mismas dependencias que iOS generalmente funcionan
            implementation(libs.ktor.client.darwin)
        }
    }
}


kotlin
// shared/src/tvosMain/kotlin/platform/TvRemoteHandler.kt

import platform.TVUIKit.*
import platform.UIKit.*

// En tvOS, la navegación se basa en el foco (focus navigation)
// El Siri Remote envía gestos y botones al sistema de foco de UIKit

actual class PlatformRemoteHandler {
    // En CMP 1.8+, el soporte de Siri Remote está integrado en Compose
    // No necesitas código nativo para los casos básicos de navegación

    // Para casos avanzados, puedes añadir reconocedores de gestos
    fun configurarGestos(viewController: UIViewController) {
        // Swipe arriba
        val swipeUp = UISwipeGestureRecognizer(
            target = viewController,
            action = NSSelectorFromString("handleSwipeUp:")
        ).apply {
            direction = UISwipeGestureRecognizerDirectionUp
        }
        viewController.view.addGestureRecognizer(swipeUp)
    }
}


kotlin
// tvApp/src/tvosMain/kotlin/TvMainViewController.kt

import androidx.compose.foundation.layout.*
import androidx.compose.material3.*
import androidx.compose.runtime.*
import androidx.compose.ui.Modifier
import androidx.compose.ui.unit.dp
import moe.tlaster.precompose.PreComposeApp

// El EntryPoint para tvOS es el mismo que iOS
fun TvMainViewController() = ComposeUIViewController {
    AppTheme {
        TvPantallaInicio()
    }
}

@Composable
fun TvPantallaInicio() {
    // En tvOS conviene usar layouts horizontales con navegación por foco
    Row(
        modifier = Modifier
            .fillMaxSize()
            .padding(48.dp),  // tvOS tiene márgenes más grandes (TV Safe Area)
        horizontalArrangement = Arrangement.spacedBy(32.dp)
    ) {
        // Sidebar de navegación
        Column(
            modifier = Modifier.width(300.dp),
            verticalArrangement = Arrangement.spacedBy(8.dp)
        ) {
            Text("Mi App TV", style = MaterialTheme.typography.headlineLarge)
            Spacer(Modifier.height(16.dp))
            // Botones enfocables con el Siri Remote
            listOf("Inicio", "Posts", "Favoritos", "Configuración").forEach { item ->
                FilledTonalButton(
                    onClick = { /* navegar */ },
                    modifier = Modifier.fillMaxWidth()
                ) {
                    Text(item)
                }
            }
        }

        // Contenido principal
        Box(modifier = Modifier.weight(1f)) {
            Text("Contenido principal aquí")
        }
    }
}


kotlin
// shared/build.gradle.kts
kotlin {
    androidTarget()
    iosX64(); iosArm64(); iosSimulatorArm64()
    jvm("desktop")

    // Target Web con Wasm
    wasmJs {
        browser {
            commonWebpackConfig {
                devServer = KotlinWebpackConfig.DevServer(
                    port = 8080,
                    open = mapOf("app" to mapOf("name" to "google-chrome"))
                )
            }
        }
        binaries.executable()  // Genera un archivo ejecutable en el navegador
    }

    sourceSets {
        commonMain.dependencies {
            implementation(compose.runtime)
            implementation(compose.foundation)
            implementation(compose.material3)
            implementation(compose.ui)
            implementation(libs.kotlinx.coroutines.core)
            implementation(libs.kotlinx.serialization.json)
        }

        // Código compartido entre JS y Wasm (web en general)
        val webMain by creating {
            dependsOn(commonMain.get())
        }

        // En Kotlin 2.2.20+ hay un source set webMain compartido para js y wasmJs
        val wasmJsMain by getting {
            dependsOn(webMain)
            dependencies {
                implementation(libs.ktor.client.js)  // Motor HTTP para Wasm/JS
            }
        }
    }
}


kotlin
// shared/src/wasmJsMain/kotlin/main.kt

import androidx.compose.ui.ExperimentalComposeUiApi
import androidx.compose.ui.window.CanvasBasedWindow

// CanvasBasedWindow: renderiza Compose en un elemento <canvas> del HTML
@OptIn(ExperimentalComposeUiApi::class)
fun main() {
    CanvasBasedWindow(
        title = "Mi App KMP Web",
        canvasElementId = "composeCanvas"  // ID del canvas en index.html
    ) {
        AppTheme {
            AppNavigation(viewModelFactory = WebViewModelFactory())
        }
    }
}


html
<!-- wasmJsMain/resources/index.html -->
<!DOCTYPE html>
<html lang="es">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Mi App KMP Web</title>
    <style>
        * { margin: 0; padding: 0; box-sizing: border-box; }
        body { background: #FFFBFE; }
        /* El canvas ocupa toda la ventana */
        #composeCanvas {
            width: 100vw;
            height: 100vh;
            display: block;
        }
    </style>
</head>
<body>
    <!-- Compose renderiza aquí -->
    <canvas id="composeCanvas"></canvas>
    <!-- Script generado por el compilador Kotlin/Wasm -->
    <script src="mi-app-web.js"></script>
</body>
</html>


kotlin
// Llamar APIs del DOM desde Kotlin/Wasm
import kotlinx.browser.document
import kotlinx.browser.window
import org.w3c.dom.*

fun obtenerParametroUrl(nombre: String): String? {
    val urlParams = URLSearchParams(window.location.search)
    return urlParams.get(nombre)
}

fun copiarAlPortapapeles(texto: String) {
    window.navigator.clipboard.writeText(texto)
}

// Llamar a una función JavaScript externa
@JsModule("./miLibreria.js")
@JsNonModule
external fun funcionDeJavaScript(param: String): String

// Exponer código Kotlin a JavaScript con @JsExport
@JsExport
fun funcionParaJavaScript(valor: Int): Int = valor * 2


kotlin
// Composable específico para Web con interop HTML
// CMP 1.9.0 introduce WebElementView para incrustar HTML nativo en Compose
// (Experimental en la versión actual)

import androidx.compose.runtime.Composable

@Composable
fun MapaInteractivo(latitud: Double, longitud: Double) {
    // WebElementView permite incrustar un elemento HTML nativo en Compose Web
    // Es útil para mapas, videos, iframes, etc.
    // Nota: Solo disponible en el target wasmJs/js
    // En Android/iOS usarías WebView o MapKit nativo
}


kotlin
// commonMain
expect fun abrirUrl(url: String)
expect fun compartir(titulo: String, texto: String, url: String)
expect fun descargarArchivo(nombre: String, contenido: ByteArray)

// wasmJsMain (implementación web)
actual fun abrirUrl(url: String) {
    window.open(url, "_blank")
}

actual fun compartir(titulo: String, texto: String, url: String) {
    // Web Share API (disponible en móviles y Chrome de escritorio)
    val shareData = js("({ title: titulo, text: texto, url: url })")
    window.navigator.share(shareData)
}

actual fun descargarArchivo(nombre: String, contenido: ByteArray) {
    val blob = Blob(arrayOf(contenido.toJsArray()))
    val url = URL.createObjectURL(blob)
    val link = document.createElement("a") as HTMLAnchorElement
    link.href = url
    link.download = nombre
    link.click()
    URL.revokeObjectURL(url)
}

// androidMain
actual fun abrirUrl(url: String) {
    // Usa el Intent del sistema Android
    val intent = android.content.Intent(android.content.Intent.ACTION_VIEW)
    intent.data = android.net.Uri.parse(url)
    // ...
}

// iosMain
actual fun abrirUrl(url: String) {
    platform.UIKit.UIApplication.sharedApplication
        .openURL(platform.Foundation.NSURL(string = url))
}


bash
# Desarrollo local con hot-reload
./gradlew :shared:wasmJsBrowserDevelopmentRun

# Build de producción (genera archivos estáticos)
./gradlew :shared:wasmJsBrowserDistribution

# Los archivos están en: shared/build/dist/wasmJs/productionExecutable/
# Puedes subirlos a cualquier CDN (Netlify, Vercel, GitHub Pages, Cloudflare Pages)


yaml
# .github/workflows/deploy-web.yml
name: Deploy Web App

on:
  push:
    branches: [main]

jobs:
  deploy:
    runs-on: ubuntu-latest
    permissions:
      contents: write

    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-java@v4
        with: { java-version: '21', distribution: 'temurin' }

      - name: Build Wasm web app
        run: ./gradlew :shared:wasmJsBrowserDistribution

      - name: Deploy to GitHub Pages
        uses: JamesIves/github-pages-deploy-action@v4
        with:
          folder: shared/build/dist/wasmJs/productionExecutable
          branch: gh-pages

K1 (viejo)                    K2 (nuevo, actual)
─────────────────────         ──────────────────────────
Frontend separado por         Frontend unificado para todas
target (JVM, JS, Native)      las plataformas
~45s compilación grande       ~22s compilación grande (2x más rápido)
Inferencia de tipos limitada  Inferencia mejorada, más errores en compile-time
Sin soporte multi-módulo opt. Gradle Isolated Projects compatible
kapt para procesadores        KSP2 (procesamiento nativo K2)


kotlin
// build.gradle.kts — Configurar KSP2 en lugar de kapt
plugins {
    alias(libs.plugins.kotlinMultiplatform)
    alias(libs.plugins.ksp)  // com.google.devtools.ksp
    // NO uses: id("kotlin-kapt") ← DEPRECATED
}

kotlin {
    sourceSets {
        commonMain.dependencies {
            // Room KMP con KSP2
            implementation(libs.room.runtime)
            implementation(libs.room.ktx)
        }
    }
}

// Configuración de KSP para cada target
dependencies {
    // KSP genera código para Room en cada plataforma
    add("kspAndroid", libs.room.compiler)
    add("kspIosArm64", libs.room.compiler)
    add("kspIosX64", libs.room.compiler)
    add("kspIosSimulatorArm64", libs.room.compiler)
    add("kspJvm", libs.room.compiler)  // Para desktop
}


toml
# gradle/libs.versions.toml
[versions]
ksp = "2.3.0-1.0.31"  # Versión KSP sincronizada con Kotlin 2.3.0
room = "2.8.3"         # Room KMP estable

[plugins]
ksp = { id = "com.google.devtools.ksp", version.ref = "ksp" }

[libraries]
room-runtime = { module = "androidx.room:room-runtime", version.ref = "room" }
room-ktx = { module = "androidx.room:room-ktx", version.ref = "room" }
room-compiler = { module = "androidx.room:room-compiler", version.ref = "room" }


kotlin
// shared/src/commonMain/kotlin/data/local/AppDatabase.kt

import androidx.room.*
import kotlinx.coroutines.flow.Flow

// Entidad
@Entity(tableName = "posts")
data class PostEntity(
    @PrimaryKey val id: Int,
    val userId: Int,
    val title: String,
    val body: String,
    val guardadoEn: Long = System.currentTimeMillis()
)

// DAO
@Dao
interface PostDao {
    @Query("SELECT * FROM posts ORDER BY guardadoEn DESC")
    fun observarTodos(): Flow<List<PostEntity>>  // Flow para reactividad

    @Query("SELECT * FROM posts WHERE id = :id")
    suspend fun obtenerPorId(id: Int): PostEntity?

    @Upsert  // INSERT OR REPLACE — más moderno que @Insert(onConflict = REPLACE)
    suspend fun guardarTodos(posts: List<PostEntity>)

    @Query("DELETE FROM posts")
    suspend fun eliminarTodos()

    @Transaction
    suspend fun reemplazarTodos(posts: List<PostEntity>) {
        eliminarTodos()
        guardarTodos(posts)
    }
}

// Base de datos
@Database(
    entities = [PostEntity::class],
    version = 1,
    exportSchema = true  // Exporta el esquema para migraciones
)
@TypeConverters(Converters::class)
abstract class AppDatabase : RoomDatabase() {
    abstract fun postDao(): PostDao
}

// Converters para tipos no soportados por SQLite
class Converters {
    @TypeConverter
    fun listAString(lista: List<String>): String = lista.joinToString(",")

    @TypeConverter
    fun stringAList(valor: String): List<String> =
        if (valor.isEmpty()) emptyList() else valor.split(",")
}


kotlin
// Factory de la base de datos — expect/actual para cada plataforma

// commonMain
expect fun crearBaseDeDatos(): AppDatabase

// androidMain
actual fun crearBaseDeDatos(): AppDatabase {
    return Room.databaseBuilder(
        context = applicationContext,
        klass = AppDatabase::class,
        name = "miapp.db"
    ).build()
}

// iosMain
actual fun crearBaseDeDatos(): AppDatabase {
    val dbPath = NSFileManager.defaultManager.URLForDirectory(
        directory = NSDocumentDirectory,
        inDomain = NSUserDomainMask,
        appropriateForURL = null,
        create = true,
        error = null
    )!!.path + "/miapp.db"

    return Room.databaseBuilder<AppDatabase>(
        name = dbPath
    ).build()
}


kotlin
// commonMain — usa ViewModel directamente, sin wrappers propios
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope  // CoroutineScope automático

class PostsViewModel(
    private val useCase: ObtenerPostsUseCase
) : ViewModel() {
    // viewModelScope se cancela automáticamente cuando el ViewModel se destruye
    // Funciona igual en Android, iOS y Desktop

    private val _state = MutableStateFlow<PostsUiState>(PostsUiState.Cargando)
    val state: StateFlow<PostsUiState> = _state.asStateFlow()

    init {
        cargarPosts()
    }

    fun cargarPosts() {
        viewModelScope.launch {
            _state.value = PostsUiState.Cargando
            useCase()
                .onSuccess { _state.value = PostsUiState.Exitoso(it) }
                .onFailure { _state.value = PostsUiState.Error(it.message ?: "Error") }
        }
    }

    // onCleared() se llama automáticamente cuando el ViewModel se destruye
    override fun onCleared() {
        super.onCleared()
        // Limpieza si necesaria
    }
}


kotlin
// Integración con Koin 4.x para inyección de ViewModel en KMP
import org.koin.core.module.dsl.viewModel  // API moderna de Koin 4
import org.koin.dsl.module

val viewModelModule = module {
    viewModel { PostsViewModel(get()) }
    viewModel { params -> DetalleViewModel(params.get(), get()) }
}


kotlin
// gradle.properties — Activar optimizaciones de build

# K2 Compiler (predeterminado desde Kotlin 2.0, pero puedes forzarlo)
kotlin.incremental=true
kotlin.incremental.multiplatform=true

# Compilación incremental de Kotlin/Native
kotlin.incremental.native=true

# Gradle Isolated Projects (experimental, pero muy impactante en proyectos grandes)
org.gradle.unsafe.isolated-projects=true

# Build cache (reutiliza resultados de compilación entre builds)
org.gradle.caching=true

# JVM para Gradle daemon con más memoria
org.gradle.jvmargs=-Xmx4g -XX:MaxMetaspaceSize=1g -XX:+UseParallelGC

# Kotlin Daemon
kotlin.daemon.jvm.options=-Xmx3g -Xms512m


toml
# gradle/libs.versions.toml — Asegúrate de usar 3.1.1+
[versions]
ktor = "3.3.0"  # Nunca uses < 3.1.1


kotlin
// shared/src/androidMain/kotlin/network/SecureHttpClient.android.kt

import io.ktor.client.*
import io.ktor.client.engine.okhttp.*
import okhttp3.CertificatePinner
import okhttp3.OkHttpClient
import java.util.concurrent.TimeUnit

actual fun crearHttpClientSeguro(config: SecurityConfig): HttpClient {
    // OkHttp tiene soporte nativo para certificate pinning
    val certificatePinner = CertificatePinner.Builder()
        .add(
            config.host,
            // SHA-256 del Subject Public Key Info (SPKI) del certificado
            // Obtén estos hashes así: openssl s_client -connect tudominio.com:443 |
            //   openssl x509 -pubkey -noout |
            //   openssl rsa -pubin -outform DER |
            //   openssl dgst -sha256 -binary | base64
            "sha256/${config.pinPrincipal}",
            "sha256/${config.pinBackup}"  // Siempre incluye un backup pin
        )
        .build()

    val okHttpClient = OkHttpClient.Builder()
        .certificatePinner(certificatePinner)
        .connectTimeout(10, TimeUnit.SECONDS)
        .readTimeout(30, TimeUnit.SECONDS)
        .writeTimeout(30, TimeUnit.SECONDS)
        .build()

    return HttpClient(OkHttp) {
        engine {
            preconfigured = okHttpClient
        }
        configurarPluginsComunes()
    }
}


kotlin
// shared/src/iosMain/kotlin/network/SecureHttpClient.ios.kt

import io.ktor.client.*
import io.ktor.client.engine.darwin.*
import platform.Foundation.*

actual fun crearHttpClientSeguro(config: SecurityConfig): HttpClient {
    return HttpClient(Darwin) {
        engine {
            // Darwin (NSURLSession) usa el sistema de certificados de iOS
            // Para pinning, implementamos el challenge handler
            handleChallenge { session, task, challenge, completionHandler ->
                val serverTrust = challenge.protectionSpace.serverTrust
                    ?: return@handleChallenge completionHandler(
                        NSURLSessionAuthChallengeCancelAuthenticationChallenge, null
                    )

                // Validar el certificado manualmente
                val certificadoValido = validarCertificado(
                    serverTrust = serverTrust,
                    host = challenge.protectionSpace.host,
                    pinsEsperados = listOf(config.pinPrincipal, config.pinBackup)
                )

                if (certificadoValido) {
                    val credencial = NSURLCredential.credentialForTrust(serverTrust)
                    completionHandler(NSURLSessionAuthChallengeUseCredential, credencial)
                } else {
                    completionHandler(NSURLSessionAuthChallengeCancelAuthenticationChallenge, null)
                }
            }
        }
        configurarPluginsComunes()
    }
}

private fun validarCertificado(
    serverTrust: SecTrustRef,
    host: String,
    pinsEsperados: List<String>
): Boolean {
    // Extraer la clave pública del certificado del servidor
    val certificado = SecTrustGetCertificateAtIndex(serverTrust, 0) ?: return false
    val clavePublica = SecCertificateCopyKey(certificado) ?: return false
    val datosClavePublica = SecKeyCopyExternalRepresentation(clavePublica, null) ?: return false

    // Calcular SHA-256 y comparar con los pins
    val hashBytes = (datosClavePublica as NSData).toByteArray()
    val hashBase64 = calcularSHA256Base64(hashBytes)

    return hashBase64 in pinsEsperados
}


kotlin
// commonMain — Modelo de configuración de seguridad
data class SecurityConfig(
    val host: String,
    val pinPrincipal: String,   // Hash SHA-256 del certificado principal
    val pinBackup: String       // Hash SHA-256 del certificado de backup
)

// NUNCA hardcodees los pines en el código fuente directamente
// Cárgalos desde un archivo de configuración cifrado o variables de entorno
// En desarrollo/debug, puedes desactivar el pinning con un flag:
val securityConfig = if (BuildConfig.DEBUG) {
    SecurityConfig("api.miapp.com", "", "")  // Sin pinning en debug
} else {
    SecurityConfig(
        host = "api.miapp.com",
        pinPrincipal = BuildConfig.CERT_PIN_PRIMARY,   // Valor de secrets.properties
        pinBackup = BuildConfig.CERT_PIN_BACKUP
    )
}


toml
# gradle/libs.versions.toml
[versions]
multiplatform-settings = "1.3.0"

[libraries]
# Almacenamiento normal
mp-settings = { module = "com.russhwolf:multiplatform-settings", version.ref = "multiplatform-settings" }
# Almacenamiento seguro (usa Keychain en iOS, EncryptedSharedPreferences en Android)
mp-settings-secure = { module = "com.russhwolf:multiplatform-settings-secure", version.ref = "multiplatform-settings" }
# Integración con coroutines/Flow
mp-settings-coroutines = { module = "com.russhwolf:multiplatform-settings-coroutines", version.ref = "multiplatform-settings" }


kotlin
// shared/src/commonMain/kotlin/data/storage/SecureTokenStore.kt

import com.russhwolf.settings.Settings
import com.russhwolf.settings.coroutines.FlowSettings
import com.russhwolf.settings.coroutines.toFlowSettings
import kotlinx.coroutines.flow.Flow

// Interfaz para el almacenamiento de tokens
interface TokenStore {
    fun guardarAccessToken(token: String)
    fun obtenerAccessToken(): String?
    fun guardarRefreshToken(token: String)
    fun obtenerRefreshToken(): String?
    fun observarToken(): Flow<String?>  // Reactivo
    fun limpiar()
}

class TokenStoreImpl(
    private val settings: Settings,  // Inyectado: SecureSettings en prod, normal en tests
) : TokenStore {
    companion object {
        private const val KEY_ACCESS_TOKEN = "access_token"
        private const val KEY_REFRESH_TOKEN = "refresh_token"
    }

    private val flowSettings: FlowSettings = settings.toFlowSettings()

    override fun guardarAccessToken(token: String) {
        settings.putString(KEY_ACCESS_TOKEN, token)
    }

    override fun obtenerAccessToken(): String? =
        settings.getStringOrNull(KEY_ACCESS_TOKEN)

    override fun guardarRefreshToken(token: String) {
        settings.putString(KEY_REFRESH_TOKEN, token)
    }

    override fun obtenerRefreshToken(): String? =
        settings.getStringOrNull(KEY_REFRESH_TOKEN)

    // Flow que emite cuando el token cambia
    override fun observarToken(): Flow<String?> =
        flowSettings.getStringOrNullFlow(KEY_ACCESS_TOKEN)

    override fun limpiar() {
        settings.remove(KEY_ACCESS_TOKEN)
        settings.remove(KEY_REFRESH_TOKEN)
    }
}


kotlin
// androidMain — Usa EncryptedSharedPreferences (AES-256-GCM)
import android.content.Context
import androidx.security.crypto.EncryptedSharedPreferences
import androidx.security.crypto.MasterKey
import com.russhwolf.settings.SharedPreferencesSettings

actual fun crearSettingsSeguro(context: Context): Settings {
    val masterKey = MasterKey.Builder(context)
        .setKeyScheme(MasterKey.KeyScheme.AES256_GCM)  // Cifrado AES-256-GCM
        .build()

    val sharedPreferences = EncryptedSharedPreferences.create(
        context,
        "secure_prefs",
        masterKey,
        EncryptedSharedPreferences.PrefKeyEncryptionScheme.AES256_SIV,
        EncryptedSharedPreferences.PrefValueEncryptionScheme.AES256_GCM
    )

    return SharedPreferencesSettings(sharedPreferences)
}


kotlin
// iosMain — Usa el Keychain del sistema (el lugar más seguro en iOS)
import com.russhwolf.settings.KeychainSettings

actual fun crearSettingsSeguro(): Settings {
    // KeychainSettings almacena en el Keychain de iOS/macOS
    // Es el equivalente al llavero de tu Mac — accesible solo por tu app
    return KeychainSettings(service = "com.miapp.secure")
}


kotlin
// commonMain
interface CifradoService {
    fun cifrar(datos: ByteArray, clave: ByteArray): ByteArray
    fun descifrar(datosCifrados: ByteArray, clave: ByteArray): ByteArray
    fun generarClave(): ByteArray  // Genera clave AES-256 aleatoria
}

// androidMain — AES-256-GCM via JCA (Java Cryptography Architecture)
import javax.crypto.Cipher
import javax.crypto.KeyGenerator
import javax.crypto.spec.GCMParameterSpec
import javax.crypto.spec.SecretKeySpec

class CifradoServiceAndroid : CifradoService {
    companion object {
        private const val ALGORITMO = "AES/GCM/NoPadding"
        private const val TAG_LENGTH_BIT = 128
        private const val IV_LENGTH_BYTE = 12
    }

    override fun cifrar(datos: ByteArray, clave: ByteArray): ByteArray {
        val cipher = Cipher.getInstance(ALGORITMO)
        val iv = ByteArray(IV_LENGTH_BYTE).also {
            java.security.SecureRandom().nextBytes(it)
        }
        cipher.init(Cipher.ENCRYPT_MODE, SecretKeySpec(clave, "AES"),
            GCMParameterSpec(TAG_LENGTH_BIT, iv))
        val datosCifrados = cipher.doFinal(datos)
        // Devuelve IV + datos cifrados concatenados
        return iv + datosCifrados
    }

    override fun descifrar(datosCifrados: ByteArray, clave: ByteArray): ByteArray {
        val cipher = Cipher.getInstance(ALGORITMO)
        val iv = datosCifrados.sliceArray(0 until IV_LENGTH_BYTE)
        val datos = datosCifrados.sliceArray(IV_LENGTH_BYTE until datosCifrados.size)
        cipher.init(Cipher.DECRYPT_MODE, SecretKeySpec(clave, "AES"),
            GCMParameterSpec(TAG_LENGTH_BIT, iv))
        return cipher.doFinal(datos)
    }

    override fun generarClave(): ByteArray {
        val keyGen = KeyGenerator.getInstance("AES")
        keyGen.init(256, java.security.SecureRandom())
        return keyGen.generateKey().encoded
    }
}


kotlin
// iosMain — AES-256-GCM via CommonCrypto (nativo iOS/macOS)
import platform.CoreCrypto.*
import platform.Foundation.*
import kotlin.experimental.ExperimentalNativeApi

class CifradoServiceIos : CifradoService {
    override fun cifrar(datos: ByteArray, clave: ByteArray): ByteArray {
        val iv = ByteArray(12).also { SecRandomCopyBytes(kSecRandomDefault, 12, it.refTo(0)) }
        // ... implementación con CCCrypt o CryptoKit via cinterop
        return iv + cifrarConAesGcm(datos, clave, iv)
    }

    override fun descifrar(datosCifrados: ByteArray, clave: ByteArray): ByteArray {
        val iv = datosCifrados.sliceArray(0 until 12)
        val datos = datosCifrados.sliceArray(12 until datosCifrados.size)
        return descifrarConAesGcm(datos, clave, iv)
    }

    override fun generarClave(): ByteArray {
        return ByteArray(32).also { SecRandomCopyBytes(kSecRandomDefault, 32, it.refTo(0)) }
    }
}


kotlin
// gradle.properties
kotlin.native.binary.stackCanaries=true


kotlin
kotlin {
    iosArm64 {
        binaries.framework("shared") {
            // Activa stack canaries en release
            binaryOption("stackCanaries", "true")
        }
    }
}


kotlin
// androidApp/build.gradle.kts
android {
    buildTypes {
        release {
            isMinifyEnabled = true           // Activa R8 (minificación + ofuscación)
            isShrinkResources = true         // Elimina recursos no usados

            // R8 full mode: más agresivo, menor tamaño (actívalo cuando tengas
            // todas las reglas de keep configuradas correctamente)
            proguardFiles(
                getDefaultProguardFile("proguard-android-optimize.txt"),
                "proguard-rules.pro"
            )
        }
    }
}

# proguard-rules.pro — Reglas para R8 en proyectos KMP 2026

# ============================================================
# KOTLIN
# ============================================================
# Mantener metadata de Kotlin (necesaria para reflection y serialización)
-keepattributes *Annotation*
-keepattributes RuntimeVisibleAnnotations
-keepattributes AnnotationDefault

# Mantener companion objects de Kotlin
-keepclassmembers class ** {
    ** Companion;
}

# ============================================================
# KOTLINX SERIALIZATION
# ============================================================
-keepattributes InnerClasses
-dontnote kotlinx.serialization.AnnotationsKt
-keep class kotlinx.serialization.** { *; }
-keepclassmembers @kotlinx.serialization.Serializable class ** {
    *** Companion;
    *** serializer();
    kotlinx.serialization.KSerializer serializer(...);
}
# Mantener tus data classes serializables
-keep @kotlinx.serialization.Serializable class com.miapp.** { *; }

# ============================================================
# KTOR
# ============================================================
-keep class io.ktor.** { *; }
-keep class kotlinx.coroutines.** { *; }
-dontwarn io.ktor.**

# ============================================================
# ROOM
# ============================================================
-keep class * extends androidx.room.RoomDatabase
-keep @androidx.room.Entity class *
-keep @androidx.room.Dao class *
-dontwarn androidx.room.**

# ============================================================
# KOIN
# ============================================================
-keep class org.koin.** { *; }
-keepclassmembers class * {
    @org.koin.core.annotation.* <fields>;
    @org.koin.core.annotation.* <methods>;
}

# ============================================================
# GENERAL
# ============================================================
# Mantener enums (R8 puede eliminarlos si no los detecta)
-keepclassmembers enum * {
    public static **[] values();
    public static ** valueOf(java.lang.String);
}

# Mantener Parcelables
-keep class * implements android.os.Parcelable {
    public static final android.os.Parcelable$Creator *;
}

monorepo/
├── apps/
│   ├── androidApp/
│   ├── iosApp/
│   ├── desktopApp/
│   └── webApp/
├── features/                 ← Módulos por feature (vertical slicing)
│   ├── feature-auth/
│   │   ├── src/commonMain/
│   │   ├── src/androidMain/
│   │   └── build.gradle.kts
│   ├── feature-posts/
│   ├── feature-profile/
│   └── feature-settings/
├── core/                     ← Módulos de infraestructura (horizontal slicing)
│   ├── core-network/
│   ├── core-database/
│   ├── core-ui/              ← Design system compartido
│   ├── core-testing/
│   └── core-analytics/
├── build-logic/              ← Convention plugins (la clave de monorepos limpios)
│   ├── convention/
│   │   ├── src/main/kotlin/
│   │   │   ├── KmpLibraryPlugin.kt
│   │   │   ├── KmpFeaturePlugin.kt
│   │   │   └── AndroidAppPlugin.kt
│   │   └── build.gradle.kts
│   └── settings.gradle.kts
├── gradle/
│   └── libs.versions.toml    ← Catálogo de versiones centralizado
├── build.gradle.kts
└── settings.gradle.kts


kotlin
// build-logic/convention/src/main/kotlin/KmpLibraryConventionPlugin.kt

import org.gradle.api.Plugin
import org.gradle.api.Project
import org.gradle.kotlin.dsl.*
import org.jetbrains.kotlin.gradle.dsl.KotlinMultiplatformExtension

// Plugin para módulos de librería KMP (features, core modules)
class KmpLibraryConventionPlugin : Plugin<Project> {
    override fun apply(target: Project) = with(target) {
        with(pluginManager) {
            apply("org.jetbrains.kotlin.multiplatform")
            apply("com.android.library")
            apply("org.jetbrains.kotlin.plugin.compose")
            apply("org.jetbrains.compose")
        }

        extensions.configure<KotlinMultiplatformExtension> {
            // Targets estándar para todas las librerías
            androidTarget {
                compilations.all {
                    kotlinOptions.jvmTarget = "17"
                }
            }
            iosX64()
            iosArm64()
            iosSimulatorArm64()

            // Configuración estándar de sourceSets
            sourceSets {
                commonMain.dependencies {
                    // Dependencias que TODOS los módulos necesitan
                    implementation(libs.findLibrary("kotlinx-coroutines-core").get())
                    implementation(libs.findLibrary("kotlinx-serialization-json").get())
                    implementation(compose.runtime)
                    implementation(compose.foundation)
                    implementation(compose.material3)
                }
                commonTest.dependencies {
                    implementation(libs.findLibrary("kotlin-test").get())
                    implementation(libs.findLibrary("kotlinx-coroutines-test").get())
                }
            }
        }

        // Configuración Android estándar
        extensions.configure<com.android.build.api.dsl.LibraryExtension> {
            compileSdk = 36
            defaultConfig {
                minSdk = 24
            }
            compileOptions {
                sourceCompatibility = JavaVersion.VERSION_17
                targetCompatibility = JavaVersion.VERSION_17
            }
        }
    }
}


kotlin
// build-logic/convention/src/main/kotlin/KmpFeatureConventionPlugin.kt

// Plugin específico para módulos de feature — extiende el de librería
class KmpFeatureConventionPlugin : Plugin<Project> {
    override fun apply(target: Project) = with(target) {
        // Aplica primero el plugin base de librería
        pluginManager.apply(KmpLibraryConventionPlugin::class)

        extensions.configure<KotlinMultiplatformExtension> {
            sourceSets {
                commonMain.dependencies {
                    // Todos los features dependen de los módulos core
                    implementation(project(":core:core-ui"))
                    implementation(project(":core:core-network"))
                    implementation(libs.findLibrary("koin-core").get())
                    implementation(libs.findLibrary("androidx-lifecycle-viewmodel").get())
                    implementation(libs.findLibrary("androidx-navigation-compose").get())
                }
            }
        }
    }
}


kotlin
// build-logic/convention/build.gradle.kts

plugins {
    `kotlin-dsl`  // Permite escribir plugins en Kotlin DSL
}

group = "com.miapp.buildlogic"

dependencies {
    // Los plugins de Gradle deben estar disponibles aquí
    compileOnly(libs.android.gradlePlugin)
    compileOnly(libs.kotlin.gradlePlugin)
    compileOnly(libs.compose.gradlePlugin)
}

// Registra todos los plugins
gradlePlugin {
    plugins {
        register("kmpLibrary") {
            id = "miapp.kmp.library"
            implementationClass = "KmpLibraryConventionPlugin"
        }
        register("kmpFeature") {
            id = "miapp.kmp.feature"
            implementationClass = "KmpFeatureConventionPlugin"
        }
        register("androidApp") {
            id = "miapp.android.app"
            implementationClass = "AndroidAppConventionPlugin"
        }
    }
}


kotlin
// features/feature-posts/build.gradle.kts
// En lugar de 80 líneas de configuración, solo esto:
plugins {
    id("miapp.kmp.feature")  // ← Todo encapsulado en el convention plugin
}

kotlin {
    sourceSets {
        commonMain.dependencies {
            // Solo las dependencias específicas de este feature
            implementation(project(":core:core-database"))
        }
    }
}


toml


kotlin
// settings.gradle.kts (raíz del monorepo)

// Nombre del proyecto raíz
rootProject.name = "MiAppMonorepo"

// Incluye el módulo de build logic primero
pluginManagement {
    includeBuild("build-logic")  // Los convention plugins
    repositories {
        google {
            content {
                includeGroupByRegex("com\\.android.*")
                includeGroupByRegex("com\\.google.*")
                includeGroupByRegex("androidx.*")
            }
        }
        mavenCentral()
        gradlePluginPortal()
    }
}

dependencyResolutionManagement {
    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
    repositories {
        google()
        mavenCentral()
    }
    // Vincula el catálogo de versiones
    versionCatalogs {
        create("libs") {
            from(files("gradle/libs.versions.toml"))
        }
    }
}

// Apps
include(":apps:androidApp")
include(":apps:iosApp")  // No suele estar en Gradle, es un proyecto Xcode
include(":apps:desktopApp")
include(":apps:webApp")

// Features
include(":features:feature-auth")
include(":features:feature-posts")
include(":features:feature-profile")
include(":features:feature-settings")

// Core
include(":core:core-network")
include(":core:core-database")
include(":core:core-ui")
include(":core:core-testing")
include(":core:core-analytics")


kotlin
// Añadir a commonTest
// testImplementation("app.cash.turbine:turbine:1.2.0")

import app.cash.turbine.test
import app.cash.turbine.turbineScope
import kotlinx.coroutines.test.runTest
import kotlin.test.*

class PostsViewModelTest {
    private val fakeRepo = FakePostRepository()
    private val viewModel by lazy {
        PostsViewModel(ObtenerPostsUseCase(fakeRepo))
    }

    @Test
    fun `estado inicial es Cargando y luego Exitoso`() = runTest {
        viewModel.state.test {
            // awaitItem() espera el siguiente valor emitido
            assertEquals(PostsUiState.Cargando, awaitItem())
            assertEquals(PostsUiState.Exitoso(fakeRepo.posts), awaitItem())
            // cancelAndIgnoreRemainingEvents() cancela la colección limpiamente
            cancelAndIgnoreRemainingEvents()
        }
    }

    @Test
    fun `cuando la red falla, emite estado Error`() = runTest {
        fakeRepo.deberiaFallar = true

        viewModel.state.test {
            awaitItem()  // Cargando
            val estadoError = awaitItem()
            assertIs<PostsUiState.Error>(estadoError)
            assertTrue(estadoError.mensaje.isNotEmpty())
            cancelAndIgnoreRemainingEvents()
        }
    }

    @Test
    fun `múltiples flows en paralelo con turbineScope`() = runTest {
        turbineScope {
            val flow1 = viewModel.state.testIn(backgroundScope)
            val flow2 = viewModel.eventos.testIn(backgroundScope)

            assertEquals(PostsUiState.Cargando, flow1.awaitItem())
            // Verificar ambos flows en el mismo test
            cancelAndIgnoreRemainingEvents()
        }
    }
}


kotlin
// build-logic/convention/src/main/kotlin/KmpLibraryPlugin.kt
// Añadir al convention plugin:

pluginManager.apply("org.jetbrains.dokka")

// La documentación se genera con:
// ./gradlew dokkaHtml
// Resultado en: build/dokka/html/index.html


toml
# gradle/libs.versions.toml
[versions]
dokka = "2.0.0"

[plugins]
dokka = { id = "org.jetbrains.dokka", version.ref = "dokka" }


toml
[versions]
detekt = "1.23.8"

[plugins]
detekt = { id = "io.gitlab.arturbosch.detekt", version.ref = "detekt" }


kotlin
// Añadir al convention plugin
pluginManager.apply("io.gitlab.arturbosch.detekt")

extensions.configure<io.gitlab.arturbosch.detekt.extensions.DetektExtension> {
    config.setFrom("$rootDir/config/detekt/detekt.yml")
    buildUponDefaultConfig = true
    allRules = false
}


yaml
# config/detekt/detekt.yml
build:
  maxIssues: 0  # 0 = build falla si hay cualquier issue

style:
  MaxLineLength:
    maxLineLength: 140
  FunctionNaming:
    active: true
    functionPattern: '[a-z][a-zA-Z0-9]*'
    excludes: ['**/test/**', '**/*Test*']

complexity:
  LongMethod:
    threshold: 60
  LongParameterList:
    functionThreshold: 8
  CyclomaticComplexMethod:
    threshold: 15

coroutines:
  GlobalCoroutineUsage:
    active: true   # Prohíbe GlobalScope (usa viewModelScope o similar)
  InjectDispatcher:
    active: true   # Fuerza a inyectar dispatchers para testabilidad

Recurso	URL	Tipo
Documentación oficial Kotlin	kotlinlang.org	Docs
KMP Wizard (generador proyectos)	kmp.jetbrains.com	Herramienta
Kotlin Koans (ejercicios interactivos)	play.kotlinlang.org/koans	Práctica
Ktor Documentation	ktor.io/docs	Docs
SQLDelight	sqldelight.github.io	Docs
Kotlin YouTube Channel	YouTube: JetBrainsTV	Vídeos
Touchlab KMP Bootcamp	touchlab.co	Cursos

data class Producto(val nombre: String, val precio: Double, val categoria: String)

fun main() {
    val productos = listOf(
        Producto("Laptop", 999.99, "Electrónica"),
        Producto("Teclado", 79.99, "Electrónica"),
        Producto("Libro Kotlin", 35.00, "Libros"),
        Producto("Auriculares", 149.99, "Electrónica"),
        Producto("Libro Clean Code", 28.00, "Libros"),
        Producto("Ratón", 45.00, "Electrónica")
    )

    // filter: filtra elementos que cumplen una condición
    val electrónica = productos.filter { it.categoria == "Electrónica" }
    println("Electrónica: ${electrónica.size} productos")  // 4

    // map: transforma cada elemento
    val nombres = productos.map { it.nombre }
    println(nombres)  // [Laptop, Teclado, Libro Kotlin, ...]

    // map + filter encadenados
    val nombresCaros = productos
        .filter { it.precio > 100 }
        .map { it.nombre }
    println(nombresCaros)  // [Laptop, Auriculares]

    // sortedBy / sortedByDescending
    val ordenados = productos.sortedBy { it.precio }
    println(ordenados.first().nombre)  // "Libro Clean Code" (más barato)

    // groupBy: agrupa en un Map
    val porCategoria = productos.groupBy { it.categoria }
    porCategoria.forEach { (categoria, items) ->
        println("$categoria: ${items.size} productos")
    }
    // Electrónica: 4 productos
    // Libros: 2 productos

    // sumOf / maxOf / minOf / averageOf
    val precioTotal = productos.sumOf { it.precio }
    val masBarato = productos.minByOrNull { it.precio }
    val precioPromedio = productos.map { it.precio }.average()
    println("Total: $precioTotal")
    println("Más barato: ${masBarato?.nombre}")
    println("Promedio: $precioPromedio")

    // any / all / none: comprobaciones booleanas
    println(productos.any { it.precio > 1000 })   // false (ninguno > 1000)
    println(productos.all { it.precio > 0 })       // true
    println(productos.none { it.nombre.isEmpty() }) // true

    // find / firstOrNull: encontrar el primero
    val primerLibro = productos.find { it.categoria == "Libros" }
    println(primerLibro?.nombre)  // "Libro Kotlin"

    // flatMap: aplana una lista de listas
    val etiquetas = listOf(
        listOf("kotlin", "jvm"),
        listOf("android", "mobile"),
        listOf("backend", "jvm")
    )
    val todasEtiquetas = etiquetas.flatten()  // o flatMap { it }
    println(todasEtiquetas.distinct())  // sin duplicados: [kotlin, jvm, android, mobile, backend]

    // reduce / fold: acumular valores
    val suma = listOf(1, 2, 3, 4, 5).reduce { acc, elemento -> acc + elemento }
    println(suma)  // 15

    // fold con valor inicial
    val texto = listOf("Kotlin", "es", "genial").fold("") { acc, palabra ->
        if (acc.isEmpty()) palabra else "$acc $palabra"
    }
    println(texto)  // "Kotlin es genial"

    // partition: divide en dos listas (los que cumplen y los que no)
    val (caros, baratos) = productos.partition { it.precio > 100 }
    println("Caros: ${caros.size}, Baratos: ${baratos.size}")
}

// shared/src/commonMain/kotlin/ui/components/PostCard.kt
 
import androidx.compose.foundation.layout.*
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.material3.*
import androidx.compose.runtime.*
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.text.style.TextOverflow
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
 
// Este composable funciona igual en Android, iOS y Desktop
@Composable
fun PostCard(
    post: Post,
    onClick: () -> Unit,
    modifier: Modifier = Modifier
) {
    Card(
        onClick = onClick,
        modifier = modifier.fillMaxWidth(),
        shape = RoundedCornerShape(12.dp),
        colors = CardDefaults.cardColors(
            containerColor = MaterialTheme.colorScheme.surfaceVariant
        ),
        elevation = CardDefaults.cardElevation(defaultElevation = 2.dp)
    ) {
        Column(
            modifier = Modifier.padding(16.dp),
            verticalArrangement = Arrangement.spacedBy(8.dp)
        ) {
            Row(
                horizontalArrangement = Arrangement.SpaceBetween,
                verticalAlignment = Alignment.CenterVertically,
                modifier = Modifier.fillMaxWidth()
            ) {
                // Badge con el ID del post
                Surface(
                    color = MaterialTheme.colorScheme.primaryContainer,
                    shape = RoundedCornerShape(20.dp)
                ) {
                    Text(
                        text = "#${post.id}",
                        modifier = Modifier.padding(horizontal = 10.dp, vertical = 4.dp),
                        style = MaterialTheme.typography.labelMedium,
                        color = MaterialTheme.colorScheme.onPrimaryContainer,
                        fontWeight = FontWeight.Bold
                    )
                }
            }
 
            Text(
                text = post.title.replaceFirstChar { it.uppercase() },
                style = MaterialTheme.typography.titleMedium,
                fontWeight = FontWeight.SemiBold,
                maxLines = 2,
                overflow = TextOverflow.Ellipsis
            )
 
            Text(
                text = post.body,
                style = MaterialTheme.typography.bodySmall,
                color = MaterialTheme.colorScheme.onSurfaceVariant,
                maxLines = 3,
                overflow = TextOverflow.Ellipsis,
                lineHeight = 18.sp
            )
        }
    }
}

// shared/src/commonMain/kotlin/ui/screens/PostsScreen.kt
 
import androidx.compose.animation.*
import androidx.compose.foundation.layout.*
import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.foundation.lazy.items
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.Refresh
import androidx.compose.material3.*
import androidx.compose.runtime.*
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.unit.dp
 
@OptIn(ExperimentalMaterial3Api::class)
@Composable
fun PostsScreen(
    viewModel: PostViewModel,
    onPostClick: (Int) -> Unit
) {
    // Observamos el StateFlow del ViewModel
    val estado by viewModel.uiState.collectAsState()
 
    // LaunchedEffect: ejecuta código cuando entra en composición
    LaunchedEffect(Unit) {
        viewModel.cargarPosts()
    }
 
    Scaffold(
        topBar = {
            TopAppBar(
                title = { Text("Posts") },
                actions = {
                    IconButton(onClick = { viewModel.cargarPosts() }) {
                        Icon(Icons.Default.Refresh, contentDescription = "Recargar")
                    }
                },
                colors = TopAppBarDefaults.topAppBarColors(
                    containerColor = MaterialTheme.colorScheme.primaryContainer
                )
            )
        }
    ) { paddingValues ->
        Box(
            modifier = Modifier
                .fillMaxSize()
                .padding(paddingValues),
            contentAlignment = Alignment.Center
        ) {
            // AnimatedContent: anima la transición entre estados
            AnimatedContent(
                targetState = estado,
                transitionSpec = {
                    fadeIn() togetherWith fadeOut()
                }
            ) { estadoActual ->
                when (estadoActual) {
                    is PostsUiState.Cargando -> {
                        Column(
                            horizontalAlignment = Alignment.CenterHorizontally,
                            verticalArrangement = Arrangement.spacedBy(16.dp)
                        ) {
                            CircularProgressIndicator(
                                color = MaterialTheme.colorScheme.primary
                            )
                            Text(
                                "Cargando posts...",
                                style = MaterialTheme.typography.bodyMedium,
                                color = MaterialTheme.colorScheme.onSurfaceVariant
                            )
                        }
                    }
 
                    is PostsUiState.Error -> {
                        ErrorContent(
                            mensaje = estadoActual.mensaje,
                            onReintentar = { viewModel.cargarPosts() }
                        )
                    }
 
                    is PostsUiState.Exitoso -> {
                        ListaPosts(
                            posts = estadoActual.posts,
                            onPostClick = onPostClick
                        )
                    }
                }
            }
        }
    }
}
 
@Composable
private fun ListaPosts(
    posts: List<Post>,
    onPostClick: (Int) -> Unit
) {
    LazyColumn(
        modifier = Modifier.fillMaxSize(),
        contentPadding = PaddingValues(16.dp),
        verticalArrangement = Arrangement.spacedBy(12.dp)
    ) {
        // Header
        item {
            Text(
                text = "${posts.size} posts encontrados",
                style = MaterialTheme.typography.labelLarge,
                color = MaterialTheme.colorScheme.primary
            )
        }
 
        // Lista de posts
        items(
            items = posts,
            key = { it.id }  // key mejora el rendimiento de LazyColumn
        ) { post ->
            PostCard(
                post = post,
                onClick = { onPostClick(post.id) }
            )
        }
 
        // Footer con espacio
        item { Spacer(modifier = Modifier.height(16.dp)) }
    }
}
 
@Composable
private fun ErrorContent(
    mensaje: String,
    onReintentar: () -> Unit
) {
    Column(
        horizontalAlignment = Alignment.CenterHorizontally,
        verticalArrangement = Arrangement.spacedBy(16.dp),
        modifier = Modifier.padding(32.dp)
    ) {
        Text(
            text = "😕",
            style = MaterialTheme.typography.displayLarge
        )
        Text(
            text = "Algo salió mal",
            style = MaterialTheme.typography.titleLarge,
            color = MaterialTheme.colorScheme.error
        )
        Text(
            text = mensaje,
            style = MaterialTheme.typography.bodyMedium,
            color = MaterialTheme.colorScheme.onSurfaceVariant
        )
        Button(onClick = onReintentar) {
            Text("Reintentar")
        }
    }
}

// src/main/kotlin/com/miapi/data/UserRepository.kt
 
import kotlinx.serialization.Serializable
import org.jetbrains.exposed.sql.*
import org.jetbrains.exposed.sql.SqlExpressionBuilder.eq
import kotlinx.datetime.Clock
 
@Serializable
data class UserDto(val id: Int, val nombre: String, val email: String)
 
@Serializable
data class CreateUserRequest(val nombre: String, val email: String, val password: String)
 
interface UserRepository {
    suspend fun obtenerTodos(): List<UserDto>
    suspend fun obtenerPorId(id: Int): UserDto?
    suspend fun obtenerPorEmail(email: String): UserDto?
    suspend fun crear(request: CreateUserRequest): UserDto
    suspend fun actualizar(id: Int, nombre: String): UserDto?
    suspend fun eliminar(id: Int): Boolean
}
 
class UserRepositoryImpl : UserRepository {
 
    // Convierte una fila de la DB a un DTO
    private fun resultRowToUser(row: ResultRow) = UserDto(
        id = row[Users.id],
        nombre = row[Users.nombre],
        email = row[Users.email]
    )
 
    override suspend fun obtenerTodos(): List<UserDto> =
        DatabaseFactory.dbQuery {
            Users.selectAll()
                .where { Users.activo eq true }
                .orderBy(Users.creadoEn, SortOrder.DESC)
                .map(::resultRowToUser)
        }
 
    override suspend fun obtenerPorId(id: Int): UserDto? =
        DatabaseFactory.dbQuery {
            Users.selectAll()
                .where { Users.id eq id }
                .map(::resultRowToUser)
                .singleOrNull()
        }
 
    override suspend fun obtenerPorEmail(email: String): UserDto? =
        DatabaseFactory.dbQuery {
            Users.selectAll()
                .where { Users.email eq email }
                .map(::resultRowToUser)
                .singleOrNull()
        }
 
    override suspend fun crear(request: CreateUserRequest): UserDto =
        DatabaseFactory.dbQuery {
            val passwordHash = BCrypt.hashpw(request.password, BCrypt.gensalt())
 
            val id = Users.insertAndGetId {
                it[nombre] = request.nombre
                it[email] = request.email
                it[passwordHash] = passwordHash
                it[creadoEn] = Clock.System.now()
            }
 
            Users.selectAll()
                .where { Users.id eq id }
                .map(::resultRowToUser)
                .single()
        }
 
    override suspend fun actualizar(id: Int, nombre: String): UserDto? =
        DatabaseFactory.dbQuery {
            Users.update({ Users.id eq id }) {
                it[Users.nombre] = nombre
            }
            obtenerPorId(id)
        }
 
    override suspend fun eliminar(id: Int): Boolean =
        DatabaseFactory.dbQuery {
            // Soft delete: marcamos como inactivo en lugar de borrar
            Users.update({ Users.id eq id }) {
                it[activo] = false
            } > 0
        }
}

// src/main/kotlin/com/miapi/routes/UserRoutes.kt
 
import io.ktor.http.*
import io.ktor.server.application.*
import io.ktor.server.auth.*
import io.ktor.server.auth.jwt.*
import io.ktor.server.request.*
import io.ktor.server.response.*
import io.ktor.server.routing.*
import kotlinx.serialization.Serializable
 
@Serializable
data class PaginatedResponse<T>(
    val datos: List<T>,
    val total: Int,
    val pagina: Int,
    val porPagina: Int
)
 
fun Route.userRoutes(userRepository: UserRepository) {
 
    route("/api/v1/users") {
 
        // GET /api/v1/users — Listar todos (público)
        get {
            val pagina = call.request.queryParameters["pagina"]?.toIntOrNull() ?: 1
            val porPagina = call.request.queryParameters["porPagina"]?.toIntOrNull() ?: 20
 
            val usuarios = userRepository.obtenerTodos()
            val paginados = usuarios.drop((pagina - 1) * porPagina).take(porPagina)
 
            call.respond(
                PaginatedResponse(
                    datos = paginados,
                    total = usuarios.size,
                    pagina = pagina,
                    porPagina = porPagina
                )
            )
        }
 
        // GET /api/v1/users/{id} — Obtener uno (público)
        get("{id}") {
            val id = call.parameters["id"]?.toIntOrNull()
                ?: throw ValidacionException("ID inválido")
 
            val usuario = userRepository.obtenerPorId(id)
                ?: throw RecursoNoEncontradoException("Usuario con ID $id no encontrado")
 
            call.respond(usuario)
        }
 
        // POST /api/v1/users — Crear usuario (público)
        post {
            val request = call.receive<CreateUserRequest>()
 
            // Validaciones
            if (request.nombre.isBlank()) throw ValidacionException("El nombre es obligatorio")
            if (!request.email.contains("@")) throw ValidacionException("Email inválido")
            if (request.password.length < 8) throw ValidacionException("Password mínimo 8 caracteres")
 
            // Verificar si el email ya existe
            if (userRepository.obtenerPorEmail(request.email) != null) {
                throw ValidacionException("El email ya está en uso")
            }
 
            val nuevoUsuario = userRepository.crear(request)
            call.respond(HttpStatusCode.Created, nuevoUsuario)
        }
 
        // Rutas protegidas con JWT
        authenticate("auth-jwt") {
 
            // PUT /api/v1/users/{id} — Actualizar (autenticado)
            put("{id}") {
                val principal = call.principal<JWTPrincipal>()
                val tokenUserId = principal?.payload?.getClaim("userId")?.asString()?.toIntOrNull()
 
                val id = call.parameters["id"]?.toIntOrNull()
                    ?: throw ValidacionException("ID inválido")
 
                // Solo puede editar su propio perfil
                if (tokenUserId != id) throw NoAutorizadoException()
 
                @Serializable
                data class UpdateRequest(val nombre: String)
                val request = call.receive<UpdateRequest>()
 
                val actualizado = userRepository.actualizar(id, request.nombre)
                    ?: throw RecursoNoEncontradoException("Usuario no encontrado")
 
                call.respond(actualizado)
            }
 
            // DELETE /api/v1/users/{id} — Eliminar (autenticado)
            delete("{id}") {
                val principal = call.principal<JWTPrincipal>()
                val tokenUserId = principal?.payload?.getClaim("userId")?.asString()?.toIntOrNull()
                val id = call.parameters["id"]?.toIntOrNull()
                    ?: throw ValidacionException("ID inválido")
 
                if (tokenUserId != id) throw NoAutorizadoException()
 
                val eliminado = userRepository.eliminar(id)
                if (!eliminado) throw RecursoNoEncontradoException("Usuario no encontrado")
 
                call.respond(HttpStatusCode.NoContent)
            }
        }
    }
}

// shared/src/commonMain/kotlin/presentation/posts/PostsMviViewModel.kt
 
class PostsMviViewModel(
    private val obtenerPostsUseCase: ObtenerPostsUseCase,
    scope: CoroutineScope
) : MviViewModel<PostsState, PostsIntent, PostsEvent>(
    initialState = PostsState(),
    scope = scope
) {
    init {
        // Carga inicial automática
        onIntent(PostsIntent.CargarPosts)
    }
 
    override suspend fun processIntent(intent: PostsIntent) {
        when (intent) {
            is PostsIntent.CargarPosts -> cargarPosts()
            is PostsIntent.Recargar -> {
                updateState { copy(paginaActual = 1, posts = emptyList()) }
                cargarPosts()
                emitEvent(PostsEvent.ScrollToTop)
            }
            is PostsIntent.CargarMasPosts -> {
                if (!state.value.estaCargando && state.value.hasMasPaginas) {
                    cargarMasPosts()
                }
            }
            is PostsIntent.BuscarPosts -> {
                updateState { copy(busqueda = intent.query) }
            }
            is PostsIntent.ClickPost -> {
                emitEvent(PostsEvent.NavegateToDetail(intent.postId))
            }
            is PostsIntent.EliminarPost -> eliminarPost(intent.postId)
        }
    }
 
    private suspend fun cargarPosts() {
        updateState { copy(estaCargando = true, error = null) }
 
        obtenerPostsUseCase()
            .onSuccess { posts ->
                updateState {
                    copy(
                        posts = posts,
                        estaCargando = false,
                        hasMasPaginas = posts.size >= 20
                    )
                }
            }
            .onFailure { error ->
                updateState {
                    copy(
                        estaCargando = false,
                        error = error.message ?: "Error desconocido"
                    )
                }
                emitEvent(PostsEvent.MostrarSnackbar("Error al cargar posts"))
            }
    }
 
    private suspend fun cargarMasPosts() {
        updateState { copy(estaCargando = true) }
        val siguientePagina = state.value.paginaActual + 1
        // ... lógica de paginación
    }
 
    private suspend fun eliminarPost(id: Int) {
        // Optimistic update: eliminamos de la UI antes de confirmar
        val postOriginal = state.value.posts.find { it.id == id }
        updateState { copy(posts = posts.filter { it.id != id }) }
 
        // Aquí iría la llamada al repositorio
        // Si falla, restauramos
        val fallo = false // simula resultado
        if (fallo && postOriginal != null) {
            updateState { copy(posts = posts + postOriginal) }
            emitEvent(PostsEvent.MostrarSnackbar("No se pudo eliminar el post"))
        }
    }
}

import androidx.compose.animation.core.*
import androidx.compose.foundation.background
import androidx.compose.foundation.layout.*
import androidx.compose.foundation.shape.CircleShape
import androidx.compose.runtime.*
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.draw.clip
import androidx.compose.ui.draw.scale
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.unit.dp

// Indicador de "grabando" (círculo que pulsa en rojo)
@Composable
fun IndicadorGrabando() {
    val transicionInfinita = rememberInfiniteTransition(label = "grabando")

    val escala by transicionInfinita.animateFloat(
        initialValue = 1f,
        targetValue = 1.3f,
        animationSpec = infiniteRepeatable(
            animation = tween(800, easing = FastOutSlowInEasing),
            repeatMode = RepeatMode.Reverse
        ),
        label = "escala_grabando"
    )

    val alfa by transicionInfinita.animateFloat(
        initialValue = 1f,
        targetValue = 0.4f,
        animationSpec = infiniteRepeatable(
            animation = tween(800),
            repeatMode = RepeatMode.Reverse
        ),
        label = "alfa_grabando"
    )

    Box(contentAlignment = Alignment.Center) {
        // Halo exterior (más transparente y grande)
        Box(
            modifier = Modifier
                .size(24.dp)
                .scale(escala)
                .clip(CircleShape)
                .background(Color.Red.copy(alpha = alfa * 0.4f))
        )
        // Círculo interior sólido
        Box(
            modifier = Modifier
                .size(14.dp)
                .clip(CircleShape)
                .background(Color.Red.copy(alpha = alfa))
        )
    }
}

// Efecto shimmer (loading skeleton)
@Composable
fun EfectoShimmer(modifier: Modifier = Modifier) {
    val transicion = rememberInfiniteTransition(label = "shimmer")

    val desplazamiento by transicion.animateFloat(
        initialValue = -300f,
        targetValue = 300f,
        animationSpec = infiniteRepeatable(
            animation = tween(1200, easing = LinearEasing),
            repeatMode = RepeatMode.Restart
        ),
        label = "shimmer_offset"
    )

    // El gradiente animado se actualiza con desplazamiento
    val gradiente = androidx.compose.ui.graphics.Brush.linearGradient(
        colors = listOf(
            Color.LightGray.copy(alpha = 0.6f),
            Color.White.copy(alpha = 0.9f),
            Color.LightGray.copy(alpha = 0.6f)
        ),
        start = androidx.compose.ui.geometry.Offset(desplazamiento, 0f),
        end = androidx.compose.ui.geometry.Offset(desplazamiento + 300f, 0f)
    )

    Box(
        modifier = modifier
            .clip(androidx.compose.foundation.shape.RoundedCornerShape(8.dp))
            .background(gradiente)
    )
}

// Uso del shimmer para skeleton loading
@Composable
fun TarjetaSkeleton() {
    Column(
        modifier = Modifier.padding(16.dp),
        verticalArrangement = Arrangement.spacedBy(8.dp)
    ) {
        EfectoShimmer(modifier = Modifier.fillMaxWidth().height(20.dp))
        EfectoShimmer(modifier = Modifier.fillMaxWidth(0.7f).height(16.dp))
        EfectoShimmer(modifier = Modifier.fillMaxWidth().height(80.dp))
    }
}

import androidx.compose.animation.*
import androidx.compose.foundation.layout.*
import androidx.compose.material3.Button
import androidx.compose.material3.Text
import androidx.compose.runtime.*
import androidx.compose.ui.Modifier
import androidx.compose.ui.unit.dp

@Composable
fun EjemploAnimatedVisibility() {
    var visible by remember { mutableStateOf(false) }

    Column(
        modifier = Modifier.padding(16.dp),
        verticalArrangement = Arrangement.spacedBy(16.dp)
    ) {
        Button(onClick = { visible = !visible }) {
            Text(if (visible) "Ocultar" else "Mostrar")
        }

        // AnimatedVisibility con transiciones personalizadas
        AnimatedVisibility(
            visible = visible,
            enter = slideInVertically(
                // La animación de entrada viene desde arriba
                initialOffsetY = { fullHeight -> -fullHeight },
                animationSpec = spring(dampingRatio = Spring.DampingRatioLowBouncy)
            ) + fadeIn(
                animationSpec = tween(300)
            ),
            exit = slideOutVertically(
                targetOffsetY = { fullHeight -> -fullHeight },
                animationSpec = tween(200)
            ) + fadeOut()
        ) {
            androidx.compose.material3.Card(
                modifier = Modifier.fillMaxWidth()
            ) {
                Text("¡Contenido animado!", modifier = Modifier.padding(16.dp))
            }
        }

        // expandIn / shrinkOut para contenido que "crece/encoge"
        AnimatedVisibility(
            visible = visible,
            enter = expandIn(expandFrom = Alignment.TopCenter),
            exit = shrinkOut(shrinkTowards = Alignment.TopCenter)
        ) {
            Box(
                modifier = Modifier
                    .fillMaxWidth()
                    .height(100.dp)
                    .background(MaterialTheme.colorScheme.secondaryContainer)
            )
        }
    }
}

// Modificador de animación DENTRO del contenido de AnimatedVisibility
@Composable
fun AnimatedVisibilityAvanzado() {
    var visible by remember { mutableStateOf(true) }

    AnimatedVisibility(
        visible = visible,
        enter = EnterTransition.None,  // Sin animación a nivel de contenedor
        exit = ExitTransition.None
    ) {
        Box(
            modifier = Modifier
                .fillMaxWidth()
                .animateEnterExit(  // Cada hijo puede tener su propia animación
                    enter = slideInHorizontally { it },
                    exit = slideOutHorizontally { -it }
                )
                .background(MaterialTheme.colorScheme.errorContainer)
                .padding(16.dp)
        ) {
            Text("Este elemento tiene su propia animación de entrada/salida")
        }
    }
}

import androidx.compose.animation.*
import androidx.compose.foundation.clickable
import androidx.compose.foundation.layout.*
import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.foundation.lazy.items
import androidx.compose.material3.*
import androidx.compose.runtime.*
import androidx.compose.ui.Modifier
import androidx.compose.ui.unit.dp

// IMPORTANTE: SharedTransitionLayout debe envolver tanto la lista como el detalle
// Normalmente lo pones alrededor de tu NavHost

@OptIn(ExperimentalSharedTransitionApi::class)
@Composable
fun AppConSharedTransitions() {
    // SharedTransitionLayout es el contenedor raíz necesario para shared elements
    SharedTransitionLayout {
        var seleccionado: Post? by remember { mutableStateOf(null) }

        // Pasamos el scope como parámetro a los composables hijos
        if (seleccionado == null) {
            ListaPostsConTransicion(
                posts = postsEjemplo,
                sharedTransitionScope = this,
                onPostClick = { seleccionado = it }
            )
        } else {
            DetallePostConTransicion(
                post = seleccionado!!,
                sharedTransitionScope = this,
                onVolver = { seleccionado = null }
            )
        }
    }
}

@OptIn(ExperimentalSharedTransitionApi::class)
@Composable
fun ListaPostsConTransicion(
    posts: List<Post>,
    sharedTransitionScope: SharedTransitionScope,
    onPostClick: (Post) -> Unit
) {
    // animatedVisibilityScope viene de AnimatedContent o NavHost automáticamente
    // cuando usas Navigation Compose. Aquí lo simulamos con AnimatedContent.
    AnimatedContent(
        targetState = posts,
        label = "lista_posts"
    ) { postsList ->
        with(sharedTransitionScope) {
            LazyColumn(contentPadding = PaddingValues(16.dp)) {
                items(postsList, key = { it.id }) { post ->
                    Card(
                        modifier = Modifier
                            .fillMaxWidth()
                            .padding(vertical = 6.dp)
                            .clickable { onPostClick(post) }
                    ) {
                        Row(modifier = Modifier.padding(12.dp)) {
                            // Este Text "viaja" a la pantalla de detalle
                            Text(
                                text = "#${post.id}",
                                modifier = Modifier.sharedElement(
                                    state = rememberSharedContentState(key = "post_id_${post.id}"),
                                    animatedVisibilityScope = this@AnimatedContent
                                ),
                                style = MaterialTheme.typography.titleMedium
                            )
                            Spacer(Modifier.width(12.dp))
                            Text(
                                text = post.title,
                                modifier = Modifier
                                    .weight(1f)
                                    .sharedElement(
                                        state = rememberSharedContentState(key = "post_title_${post.id}"),
                                        animatedVisibilityScope = this@AnimatedContent
                                    ),
                                style = MaterialTheme.typography.bodyMedium
                            )
                        }
                    }
                }
            }
        }
    }
}

# gradle/libs.versions.toml — Versiones 2026 (actualizadas a abril 2026)

[versions]
# Kotlin
kotlin = "2.3.0"
ksp = "2.3.0-1.0.31"          # SIEMPRE sincronizado con kotlin

# Compose
compose-multiplatform = "1.9.0"
compose-bom = "2026.04.01"    # BOM de Compose para Android

# Android
android-gradle-plugin = "8.8.2"
android-compileSdk = "36"
android-minSdk = "24"
android-targetSdk = "36"

# Jetpack KMP
room = "2.8.3"
datastore = "1.1.7"
lifecycle = "2.9.4"            # ViewModel KMP estable
navigation = "2.9.0"           # Navigation Compose KMP estable

# Red
ktor = "3.3.0"                 # ≥ 3.1.1 por seguridad

# Base de datos
sqldelight = "2.1.0"           # Alternativa a Room

# Serialización y formato
kotlinx-serialization = "1.8.1"
kotlinx-coroutines = "1.9.0"
kotlinx-datetime = "0.6.2"

# DI
koin = "4.1.0"

# Seguridad
security-crypto = "1.1.0-alpha07"  # EncryptedSharedPreferences

# Almacenamiento
multiplatform-settings = "1.3.0"

# Logging
napier = "2.7.1"

# Testing
turbine = "1.2.0"              # Testing de Flows (de Square)
mockk = "1.13.13"              # Mocking
kotest = "5.9.1"               # Testing framework

# Wear OS
wear-compose = "1.4.1"
horologist = "0.6.20"

# Desktop
conveyor = "1.11"              # Distribución de apps desktop

[libraries]
# Kotlin stdlib
kotlin-stdlib = { module = "org.jetbrains.kotlin:kotlin-stdlib", version.ref = "kotlin" }
kotlin-test = { module = "org.jetbrains.kotlin:kotlin-test", version.ref = "kotlin" }

# Coroutines
kotlinx-coroutines-core = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-core", version.ref = "kotlinx-coroutines" }
kotlinx-coroutines-android = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-android", version.ref = "kotlinx-coroutines" }
kotlinx-coroutines-test = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-test", version.ref = "kotlinx-coroutines" }

# Serialización
kotlinx-serialization-json = { module = "org.jetbrains.kotlinx:kotlinx-serialization-json", version.ref = "kotlinx-serialization" }
kotlinx-datetime = { module = "org.jetbrains.kotlinx:kotlinx-datetime", version.ref = "kotlinx-datetime" }

# Ktor client
ktor-client-core = { module = "io.ktor:ktor-client-core", version.ref = "ktor" }
ktor-client-android = { module = "io.ktor:ktor-client-android", version.ref = "ktor" }
ktor-client-darwin = { module = "io.ktor:ktor-client-darwin", version.ref = "ktor" }
ktor-client-okhttp = { module = "io.ktor:ktor-client-okhttp", version.ref = "ktor" }
ktor-client-js = { module = "io.ktor:ktor-client-js", version.ref = "ktor" }
ktor-client-content-negotiation = { module = "io.ktor:ktor-client-content-negotiation", version.ref = "ktor" }
ktor-serialization-json = { module = "io.ktor:ktor-serialization-kotlinx-json", version.ref = "ktor" }
ktor-client-logging = { module = "io.ktor:ktor-client-logging", version.ref = "ktor" }
ktor-client-auth = { module = "io.ktor:ktor-client-auth", version.ref = "ktor" }

# Room KMP
room-runtime = { module = "androidx.room:room-runtime", version.ref = "room" }
room-ktx = { module = "androidx.room:room-ktx", version.ref = "room" }
room-compiler = { module = "androidx.room:room-compiler", version.ref = "room" }  # KSP

# DataStore KMP
datastore-preferences = { module = "androidx.datastore:datastore-preferences-core", version.ref = "datastore" }

# Lifecycle / ViewModel KMP
androidx-lifecycle-viewmodel = { module = "androidx.lifecycle:lifecycle-viewmodel", version.ref = "lifecycle" }
androidx-lifecycle-viewmodel-compose = { module = "androidx.lifecycle:lifecycle-viewmodel-compose", version.ref = "lifecycle" }
androidx-lifecycle-runtime-compose = { module = "androidx.lifecycle:lifecycle-runtime-compose", version.ref = "lifecycle" }

# Navigation KMP
androidx-navigation-compose = { module = "androidx.navigation:navigation-compose", version.ref = "navigation" }

# Koin
koin-core = { module = "io.insert-koin:koin-core", version.ref = "koin" }
koin-android = { module = "io.insert-koin:koin-android", version.ref = "koin" }
koin-compose = { module = "io.insert-koin:koin-compose", version.ref = "koin" }
koin-compose-viewmodel = { module = "io.insert-koin:koin-compose-viewmodel", version.ref = "koin" }

# Almacenamiento seguro
mp-settings = { module = "com.russhwolf:multiplatform-settings", version.ref = "multiplatform-settings" }
mp-settings-secure = { module = "com.russhwolf:multiplatform-settings-secure", version.ref = "multiplatform-settings" }
mp-settings-coroutines = { module = "com.russhwolf:multiplatform-settings-coroutines", version.ref = "multiplatform-settings" }

# Logging
napier = { module = "io.github.aakira:napier", version.ref = "napier" }

# Testing
turbine = { module = "app.cash.turbine:turbine", version.ref = "turbine" }
mockk = { module = "io.mockk:mockk", version.ref = "mockk" }
kotest-assertions = { module = "io.kotest:kotest-assertions-core", version.ref = "kotest" }

# Build logic (solo para el módulo build-logic)
android-gradlePlugin = { module = "com.android.tools.build:gradle", version.ref = "android-gradle-plugin" }
kotlin-gradlePlugin = { module = "org.jetbrains.kotlin:kotlin-gradle-plugin", version.ref = "kotlin" }
compose-gradlePlugin = { module = "org.jetbrains.compose:compose-gradle-plugin", version.ref = "compose-multiplatform" }

[plugins]
# Android
androidApplication = { id = "com.android.application", version.ref = "android-gradle-plugin" }
androidLibrary = { id = "com.android.library", version.ref = "android-gradle-plugin" }

# Kotlin
kotlinMultiplatform = { id = "org.jetbrains.kotlin.multiplatform", version.ref = "kotlin" }
kotlinAndroid = { id = "org.jetbrains.kotlin.android", version.ref = "kotlin" }
kotlinSerialization = { id = "org.jetbrains.kotlin.plugin.serialization", version.ref = "kotlin" }
composeCompiler = { id = "org.jetbrains.kotlin.plugin.compose", version.ref = "kotlin" }
ksp = { id = "com.google.devtools.ksp", version.ref = "ksp" }

# Compose
jetbrainsCompose = { id = "org.jetbrains.compose", version.ref = "compose-multiplatform" }

# Convention plugins propios (definidos en build-logic)
kmpLibrary = { id = "miapp.kmp.library" }
kmpFeature = { id = "miapp.kmp.feature" }
androidApp = { id = "miapp.android.app" }

[bundles]
# Bundles: grupos de dependencias que se añaden juntas
ktor-client-common = ["ktor-client-core", "ktor-client-content-negotiation", "ktor-serialization-json", "ktor-client-logging"]
testing-common = ["kotlin-test", "kotlinx-coroutines-test", "turbine", "kotest-assertions"]

📋 Índice General

FUNDAMENTOS DE KOTLIN

Sección 1 · Introducción: ¿Qué es Kotlin y por qué aprenderlo?

¿Qué es Kotlin?

¿Dónde se usa Kotlin en 2026?

¿Por qué aprenderlo en 2026?

Sección 2 · Configuración del entorno de desarrollo

Herramientas que vamos a instalar

Paso 1 — Instalar JDK 21

Paso 2 — Instalar IntelliJ IDEA o Android Studio

Paso 3 — Tu primer proyecto Kotlin

El archivo build.gradle.kts explicado

Sección 3 · Fundamentos del lenguaje Kotlin

3.1 Variables: val vs var

3.2 Tipos de datos básicos

3.3 Null Safety — La característica más importante de Kotlin

3.4 Strings y Templates

3.5 Condicionales: if, when

3.6 Bucles: for, while, repeat

3.7 Funciones

3.8 Tipos de retorno: Unit y Nothing

PARTE II — PROGRAMACIÓN ORIENTADA A OBJETOS

Sección 4 · Programación Orientada a Objetos en Kotlin

4.1 Clases y constructores

4.2 Data Classes — Clases de datos

4.3 Herencia y clases abstractas

4.4 Interfaces

4.5 Sealed Classes — Jerarquías cerradas

4.6 Object, Companion Object y Singletons

4.7 Extension Functions — Ampliar clases sin heredarlas

PARTE III — FUNCIONAL Y COLECCIONES

Sección 5 · Funciones de orden superior, Lambdas y Colecciones

5.1 Lambdas y funciones de orden superior

5.2 Colecciones: List, Set, Map

5.3 Operaciones sobre colecciones

5.4 Sequences — Colecciones lazy

PARTE IV — ASINCRONÍA

Sección 6 · Coroutines y Programación Asíncrona

6.1 ¿Qué problema resuelven las coroutines?

6.2 Conceptos clave

6.3 launch vs async / await

6.4 Coroutine Scope y Context

6.5 Flow — Streams reactivos con Coroutines

6.6 Manejo de errores en Coroutines

PARTE V — KOTLIN MULTIPLATFORM

Sección 7 · Kotlin Multiplatform: Introducción y arquitectura

¿Qué es Kotlin Multiplatform (KMP)?

7.1 KMP vs otras soluciones multiplataforma

7.2 expect / actual — El corazón de KMP

Sección 8 · Configurando tu primer proyecto KMP

Usando el asistente oficial

8.1 Estructura de un proyecto KMP

8.2 El build.gradle.kts del módulo shared explicado

8.3 Un repositorio KMP completo paso a paso

Sección 9 · Librerías esenciales del ecosistema KMP (2026)

9.1 Networking: Ktor Client

9.2 Serialización: kotlinx.serialization

9.3 Base de datos: SQLDelight 2.x

9.4 Inyección de dependencias: Koin

9.5 Tabla completa del stack KMP 2026

PARTE VI — NIVEL EXPERTO

Sección 10 · Patrones avanzados, Testing y CI/CD

10.1 Clean Architecture en KMP

10.2 Testing en KMP

10.3 CI/CD con GitHub Actions

10.4 Consejos finales para el nivel experto

Sección 11 · Compose Multiplatform — UI compartida en todas las plataformas

¿Qué es Compose Multiplatform?

11.1 Configuración del proyecto CMP

11.2 Tu primer Composable compartido

11.3 Sistema de diseño: Tema compartido

11.4 Pantalla completa con LazyColumn y estados

11.5 Navegación con Navigation Compose Multiplatform

11.6 Recursos compartidos: imágenes, fuentes y strings

11.7 Cómo se integra en Android e iOS

PARTE VIII — BACKEND CON KOTLIN

Sección 12 · Ktor Server — Backend completo en Kotlin

12.1 Configurar un proyecto Ktor Server

12.2 Configuración de la aplicación (Application.kt)

12.3 Plugins de configuración

El archivo `build.gradle.kts` explicado

3.1 Variables: `val` vs `var`

3.5 Condicionales: `if`, `when`

3.6 Bucles: `for`, `while`, `repeat`

3.8 Tipos de retorno: `Unit` y `Nothing`

6.3 `launch` vs `async` / `await`

7.2 `expect` / `actual` — El corazón de KMP

8.2 El `build.gradle.kts` del módulo shared explicado

14.4 `@ObjCName` y visibilidad desde Swift

17.1 `animate*AsState` — Animaciones de valor simple

17.2 `AnimationSpec` — Cómo se mueve la animación

17.3 `rememberInfiniteTransition` — Animaciones continuas

17.4 `AnimatedVisibility` — Mostrar/Ocultar con animación

17.5 `AnimatedContent` — Transiciones entre contenidos

17.7 `updateTransition` — Múltiples propiedades sincronizadas

20.4 ViewModel KMP — `androidx.lifecycle:lifecycle-viewmodel`

21.3 Almacenamiento seguro con `multiplatform-settings`

21.4 Cifrado de datos con `expect/actual`