El mismo ViewModel en iOS

import androidx.lifecycle.ViewModel
import androidx.lifecycle.ViewModelProvider
import androidx.lifecycle.ViewModelStore
import androidx.lifecycle.viewModelScope
import androidx.lifecycle.viewmodel.initializer
import androidx.lifecycle.viewmodel.viewModelFactory
import kotlinx.coroutines.isActive
import kotlin.test.Test
 
// Un ViewModel cualquiera. private set: desde fuera se lee, solo cambia dentro.
class Contador : ViewModel() {
    var cuenta = 0
        private set
 
    fun sumar() { cuenta++ }
 
    // onCleared: lo llama el almacén cuando se vacía.
    override fun onCleared() { println("onCleared: el almacén me vació") }
}
 
class AlmacenDemoTest {
    @Test
    fun demo() {
        // El almacén y la fábrica: viewModelFactory { } crea la fábrica
        // e initializer { } dice qué fabricar cuando aún no hay ninguno.
        val almacen = ViewModelStore()
        val fabrica = viewModelFactory { initializer { Contador() } }
 
        // [Contador::class] pide uno de ese tipo: si ya hay, lo devuelve; si no, lo fabrica.
        val a = ViewModelProvider.create(almacen, fabrica)[Contador::class]
        val b = ViewModelProvider.create(almacen, fabrica)[Contador::class]
 
        println(a === b)   // === : ¿el mismo objeto?
        a.sumar()
        println(b.cuenta)  // b es a: ve el 1
 
        println(a.viewModelScope.isActive)  // isActive: ¿sigue viva su corrutina madre?
        almacen.clear()                     // vaciar: llama a onCleared y cancela el scope
        println(a.viewModelScope.isActive)
    }
}

true
1
true
onCleared: el almacén me vació
false

import Shared
 
/// El dueño del ciclo de vida de los ViewModel en iOS.
///
/// En Android, quien decide cuándo muere un ViewModel es el sistema. En iOS no
/// hay equivalente, así que hay que escribirlo: esta clase guarda el almacén y
/// lo vacía en `deinit`, que es lo que acaba llamando a `onCleared()` y cancela
/// el `viewModelScope`.
///
/// Es `ObservableObject` para poder usarla como `@StateObject` en la vista, que
/// es lo único que garantiza que SwiftUI la cree una sola vez y no cada vez
/// que vuelve a construir la vista.
final class IosViewModelStoreOwner: ObservableObject, ViewModelStoreOwner {
 
    // El almacén donde viven los ViewModel; es lo que exige ViewModelStoreOwner.
    let viewModelStore = ViewModelStore()
 
    // deinit: corre justo antes de que Swift libere esta clase.
    deinit {
        // Vacía el almacén: cada ViewModel recibe onCleared().
        viewModelStore.clear()
    }
}

src/iosMain/kotlin/com/sebastiannarvaez/pokedex/feature/home/HomeIos.kt

package com.sebastiannarvaez.pokedex.feature.home
 
import androidx.lifecycle.ViewModelProvider
import androidx.lifecycle.ViewModelStoreOwner
import androidx.lifecycle.viewmodel.initializer
import androidx.lifecycle.viewmodel.viewModelFactory
import com.rickclephas.kmp.nativecoroutines.NativeCoroutinesState
import com.sebastiannarvaez.pokedex.Pokedex
import kotlinx.coroutines.flow.StateFlow
 
/**
 * Crea el ViewModel dentro del almacén que le pasa Swift.
 *
 * El tipo de retorno es concreto, no genérico, a propósito: la función genérica
 * de la receta oficial obliga a pelearse con `KClass` desde Swift. Una función
 * por pantalla es más código, pero es código que se lee.
 */
fun homeViewModel(owner: ViewModelStoreOwner, pokedex: Pokedex): HomeViewModel =
    // ViewModelProvider entrega ViewModels guardados en un almacén: si ya hay
    // uno del tipo pedido, devuelve ese; si no, lo fabrica.
    ViewModelProvider.create(
        // El almacén donde vive: el IosViewModelStoreOwner que pasa Swift.
        owner = owner,
        // La fábrica: cómo construir el ViewModel cuando todavía no existe.
        // viewModelFactory { } crea la fábrica, e initializer { } dice cómo
        // se fabrica un HomeViewModel en concreto.
        factory = viewModelFactory { initializer { HomeViewModel(pokedex) } },
        // [HomeViewModel::class] pide uno de ese tipo; ::class es la
        // referencia a la clase (el KClass de antes).
    )[HomeViewModel::class]
 
/**
 * El estado, como algo que Swift puede recorrer.
 *
 * `@NativeCoroutinesState` y no `@NativeCoroutines`: además de la secuencia
 * asíncrona, genera la propiedad con el valor actual, que es lo que evita que
 * la pantalla parpadee vacía en el primer fotograma.
 *
 * Y es una **propiedad de extensión**, no una función: la anotación solo se
 * puede aplicar a propiedades, y el compilador lo dice sin rodeos.
 */
@NativeCoroutinesState
val HomeViewModel.uiStateForIos: StateFlow<HomeUiState>
    get() = uiState

import SwiftUI
import Shared
import KMPNativeCoroutinesAsync
 
struct ContentView: View {
 
    /// @StateObject y no @ObservedObject: con @ObservedObject SwiftUI crearía
    /// un dueño nuevo cada vez que se vuelve a construir la vista, el ViewModel
    /// se recrearía y el estado se perdería sin que nada avisara.
    @StateObject private var owner = IosViewModelStoreOwner()
 
    private let pokedex = Pokedex()
 
    @State private var estado = HomeUiState(greeting: "", heartbeat: 0)
 
    var body: some View {
        // let crea una constante local; body puede llevar líneas antes de la vista.
        // body se ejecuta muchas veces, pero no se crea un ViewModel cada vez:
        // el almacén del dueño ya tiene uno de este tipo y lo devuelve.
        let viewModel = HomeIosKt.homeViewModel(owner: owner, pokedex: pokedex)
 
        VStack(spacing: 8) {
            Text(estado.greeting)
                .font(.title2)
            Text("Latido \(estado.heartbeat)")
                .font(.footnote)
                .foregroundStyle(.secondary)
        }
        .padding()
        .task {
            // El valor actual primero, para no pintar un fotograma vacío.
            estado = viewModel.uiStateForIos
            do {
                for try await nuevo in asyncSequence(for: viewModel.uiStateForIosFlow) {
                    estado = nuevo
                }
            } catch {
                // Aquí solo llegan los errores del flujo. Si la vista desaparece,
                // la tarea se cancela y el bucle termina sin pasar por este catch.
            }
        }
    }
}
 
#Preview {
    ContentView()
}