Del aviso a la ficha, en iOS

import SwiftUI
import UserNotifications
 
// Recibe el toque en un aviso de riego y dice qué planta era.
// `@MainActor`: toda la clase vive en el hilo principal (el de la pantalla); ver abajo por qué.
@MainActor
final class OyenteDeRiego: NSObject, ObservableObject, UNUserNotificationCenterDelegate {
    static let compartido = OyenteDeRiego()   // una sola instancia: la app y la vista usan la misma
    @Published var plantaTocada: String?      // la vista lo observa
 
    // iOS llama aquí cuando el usuario toca el aviso (con la app abierta o cerrada).
    func userNotificationCenter(_ center: UNUserNotificationCenter,
                                didReceive response: UNNotificationResponse) async {
        // userInfo es un diccionario cuyos valores pueden ser de cualquier tipo (`Any`):
        // hay que decir qué tipo esperas.
        let planta = response.notification.request.content.userInfo["planta"] as? String
        plantaTocada = planta   // la clase entera es del hilo principal: se cambia sin más
    }
}
 
struct PlantasView: View {
    @StateObject private var oyente = OyenteDeRiego.compartido   // la vista observa al oyente compartido
    var body: some View {
        if let planta = oyente.plantaTocada {
            Text("Has tocado el aviso del \(planta)")
        } else {
            Text("Ningún aviso tocado")
        }
    }
}
 
#Preview { PlantasView() }

import Foundation
import UserNotifications
 
/// Recoge el toque en una notificación y lo convierte en un enlace.
///
/// No navega: publica el enlace y la vista lo observa, para que el camino sea el
/// mismo que el de un enlace externo. Una sola forma de llegar a una pantalla.
///
/// `@MainActor`: la clase entera corre en el hilo principal. Sin esto, tocar el aviso
/// con la app en segundo plano o cerrada la cierra (ver la explicación de la lección).
@MainActor
final class DelegadoDeNotificaciones: NSObject, ObservableObject, UNUserNotificationCenterDelegate {
 
    /// Una sola instancia, para que la app y la vista hablen con la misma.
    static let compartido = DelegadoDeNotificaciones()
 
    /// El enlace que acaba de llegar; la vista lo lee y lo pone a nil.
    @Published var enlacePendiente: URL?
 
    /// iOS llama aquí cuando el usuario toca la notificación.
    func userNotificationCenter(
        _ center: UNUserNotificationCenter,
        didReceive response: UNNotificationResponse
    ) async {
        guard
            let texto = response.notification.request.content.userInfo["enlace"] as? String,
            let url = URL(string: texto)
        else { return }
        enlacePendiente = url   // la clase es del hilo principal: se publica sin más
    }
 
    /// Sin esto, una notificación que llega con la app abierta no se ve.
    /// Es el `willPresent` de Marcador, sin el `nonisolated` (ver la explicación de abajo).
    func userNotificationCenter(
        _ center: UNUserNotificationCenter,
        willPresent notification: UNNotification
    ) async -> UNNotificationPresentationOptions {
        [.banner, .sound]
    }
}

import UserNotifications

        // Va después de KoinIosKt.startKoinIos().
        // El delegado hay que ponerlo antes de que la app termine de arrancar,
        // o iOS descarta el toque que abrió la app.
        UNUserNotificationCenter.current().delegate = DelegadoDeNotificaciones.compartido

    // La vista observa al delegado: cuando publica un enlace, la vista se entera.
    @StateObject private var notificaciones = DelegadoDeNotificaciones.compartido

        // El toque en una notificación acaba en el mismo sitio que un enlace
        // externo: no hay dos caminos a la misma pantalla.
        .onChange(of: notificaciones.enlacePendiente) { _, url in
            guard let url else { return }
            abrir(url)
            notificaciones.enlacePendiente = nil   // ya se atendió
        }

private extension ContentView {
    func abrir(_ url: URL) {
        // `DestinationCompanion.shared` y no `Destination.companion`: una interfaz
        // sellada llega a Swift como protocolo, y un protocolo no tiene companion.
        guard let destino = DestinationCompanion.shared.parse(url: url.absoluteString) else { return }
        pestana = .lista
        if let detalle = destino as? DestinationDetalle {
            caminoLista = [detalle.pokemonId]
        } else {
            caminoLista = []
        }
    }
}

import SwiftUI
import Shared
import KMPNativeCoroutinesAsync
 
/// Las tres secciones de la app, como valores que `TabView` puede seleccionar.
// `Hashable` (visto en Marcador): SwiftUI puede comparar estos valores.
private enum Pestana: Hashable {
    case lista, favoritos, ajustes
}
 
struct ContentView: View {
 
    // Un camino de fichas abiertas por pestaña: cada pestaña lleva su pila.
    @State private var caminoLista: [Int32] = []
    @State private var caminoFavoritos: [Int32] = []
 
    @StateObject private var owner = IosViewModelStoreOwner()
    @State private var ajustes = Settings(tema: Tema.sistema, favoritosPorNumero: false)
    @State private var insignia: String? = nil   // nil: sin insignia en Favoritos
 
    // La pestaña visible. Tiene que ser estado porque un enlace
    // entrante la cambia: si llega una ficha estando en Favoritos, hay que
    // saltar a la Pokédex antes de apilar nada.
    @State private var pestana = Pestana.lista
 
    // Nuevo: la vista observa al delegado; cuando publica un enlace, se entera.
    @StateObject private var notificaciones = DelegadoDeNotificaciones.compartido
    // De la lección anterior: si la app está activa, en segundo plano o inactiva.
    @Environment(\.scenePhase) private var scenePhase
 
    var body: some View {
        TabView(selection: $pestana) {   // `selection` ata el TabView al estado
            PokemonListView(camino: $caminoLista)
                .tabItem { Label("Pokédex", systemImage: "square.grid.2x2") }
                .tag(Pestana.lista)       // el valor que representa esta pestaña
 
            FavoritesView(camino: $caminoFavoritos)
                .tabItem { Label("Favoritos", systemImage: "heart.fill") }
                .tag(Pestana.favoritos)
                .badge(insignia)   // con nil SwiftUI no pinta nada
 
            SettingsView()
                .tabItem { Label("Ajustes", systemImage: "gearshape") }
                .tag(Pestana.ajustes)
        }
        // El tema se aplica en la raíz: dentro de la pantalla de ajustes solo
        // pintaría esa pestaña.
        .preferredColorScheme(ajustes.tema.esquema)
        // Nuevo: el toque en una notificación acaba en el mismo sitio que un enlace externo.
        .onChange(of: notificaciones.enlacePendiente) { _, url in
            guard let url else { return }
            abrir(url)
            notificaciones.enlacePendiente = nil   // ya se atendió
        }
        // De la lección anterior: reponer los avisos cada vez que la app pasa a primer plano.
        .onChange(of: scenePhase, initial: true) { _, fase in
            guard fase == .active else { return }
            Task {
                if await RecordatorioDiario.estadoDelPermiso() == .concedido {
                    await RecordatorioDiario.programar()
                }
            }
        }
        // `.onOpenURL` cubre los dos casos, app cerrada y app abierta,
        // sin distinguirlos. En Android son dos sitios (`onCreate` y
        // `onNewIntent`), y olvidar el segundo hace que el enlace falle si la app ya estaba abierta.
        // Cambia: el cuerpo pasó a `abrir`, que usan los dos caminos.
        .onOpenURL { url in
            abrir(url)
        }
        .task {
            let vm = SettingsIosKt.settingsViewModel(owner: owner)
            ajustes = vm.settingsForIos
            do {
                for try await nuevo in asyncSequence(for: vm.settingsForIosFlow) {
                    ajustes = nuevo
                }
            } catch { }
        }
        // La insignia de Favoritos: otro lector del mismo repositorio de favoritos.
        .task {
            let favoritos = FavoritesIosKt.favoritesViewModel(owner: owner)
            insignia = favoritos.insigniaForIos
            do {
                for try await nuevo in asyncSequence(for: favoritos.insigniaForIosFlow) {
                    insignia = nuevo
                }
            } catch { }
        }
    }
}
 
// Nuevo: lo que antes hacía `.onOpenURL`, ahora compartido por los dos caminos.
private extension ContentView {
    func abrir(_ url: URL) {
        // La traducción vive en Kotlin; aquí solo se llama. Devuelve nil si
        // no entiende el enlace, y entonces no se hace nada.
        // `DestinationCompanion.shared` y no `Destination.companion`: una interfaz
        // sellada llega a Swift como protocolo, y un protocolo no tiene companion.
        guard let destino = DestinationCompanion.shared.parse(url: url.absoluteString) else { return }
        pestana = .lista   // antes de apilar, la pestaña de la Pokédex
        if let detalle = destino as? DestinationDetalle {   // ¿es una ficha? (`DestinationDetalle` es `Destination.Detalle` de Kotlin)
            caminoLista = [detalle.pokemonId]   // una ficha: el camino es solo ella
        } else {
            caminoLista = []                     // la lista: sin nada apilado
        }
    }
}
 
#Preview {
    ContentView()
}