Consuming Coroutines and Flow from Swift and SwiftUI

// sharedLogic/build.gradle.kts
plugins {
    alias(libs.plugins.kotlinMultiplatform)
    alias(libs.plugins.ksp)
    alias(libs.plugins.kmpNativeCoroutines) // com.rickclephas.kmp.nativecoroutines
}

kotlin {
    iosArm64()
    iosSimulatorArm64()

    sourceSets {
        all {
            // @ObjCName, used by the generated declarations, is still an experimental annotation.
            languageSettings.optIn("kotlin.experimental.ExperimentalObjCName")
        }
        commonMain.dependencies {
            implementation(libs.kotlinx.coroutines.core)
        }
    }
}

// sharedLogic/src/commonMain/kotlin/com/example/trailmate/presentation/TrailListViewModel.kt
package com.example.trailmate.presentation

import androidx.lifecycle.ViewModel
import com.example.trailmate.domain.TrailRepository
import com.rickclephas.kmp.nativecoroutines.NativeCoroutines
import com.rickclephas.kmp.nativecoroutines.NativeCoroutinesState
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.flow.asStateFlow

class TrailListViewModel(
    private val repository: TrailRepository,
) : ViewModel() {

    private val _uiState = MutableStateFlow<TrailListUiState>(TrailListUiState.Loading)

    // StateFlow: generates uiStateValue (current value) plus a collectable uiState.
    @NativeCoroutinesState
    val uiState: StateFlow<TrailListUiState> = _uiState.asStateFlow()

    // suspend function: generates toggleFavorite that returns a cancellable "native" handle.
    @NativeCoroutines
    suspend fun toggleFavorite(trailId: String): Boolean = repository.toggleFavorite(trailId)

    // Plain Flow property: use @NativeCoroutines (shared and cold flows).
    @NativeCoroutines
    val favoriteCount = repository.observeFavoriteCount()
}

// iosApp/iosApp/Features/TrailList/NativeCoroutinesExamples.swift
import Shared
import KMPNativeCoroutinesAsync

// One-shot call -> async throws. Cancelling the Swift Task cancels the Kotlin coroutine.
func toggle(viewModel: TrailListViewModel, id: String) async throws -> Bool {
    try await asyncFunction(for: viewModel.toggleFavorite(trailId: id))
}

// Flow -> AsyncSequence. Leaving the loop (or cancelling the Task) cancels the collection.
func observe(viewModel: TrailListViewModel) async {
    do {
        let sequence = asyncSequence(for: viewModel.uiState)
        for try await state in sequence {
            print("Received \(state)")
        }
    } catch {
        print("Flow failed: \(error)")
    }
}

// Flow -> Combine publisher: createPublisher(for: viewModel.uiState), see the adapters below.

// Current StateFlow value, synchronously.
func currentState(viewModel: TrailListViewModel) -> TrailListUiState {
    viewModel.uiStateValue
}

// sharedLogic/build.gradle.kts
plugins {
    alias(libs.plugins.kotlinMultiplatform)
    alias(libs.plugins.skie) // co.touchlab.skie, version 0.10.15
}

kotlin {
    listOf(iosArm64(), iosSimulatorArm64()).forEach { target ->
        target.binaries.framework {
            baseName = "Shared"
            isStatic = true
        }
    }
}

// iosApp/iosApp/Features/TrailList/SkieExamples.swift
import Shared // SKIE-enhanced framework

// suspend -> native async throws, with Bool instead of KotlinBoolean.
func toggle(viewModel: TrailListViewModel, id: String) async throws -> Bool {
    try await viewModel.toggleFavorite(trailId: id)
}

// StateFlow -> SkieSwiftStateFlow<TrailListUiState>: an AsyncSequence with a synchronous .value.
func observe(viewModel: TrailListViewModel) async {
    let initial: TrailListUiState = viewModel.uiState.value
    print("Initial \(initial)")

    // for-await ends when the Task is cancelled, which cancels the Kotlin collection.
    for await state in viewModel.uiState {
        print("Received \(state)")
    }
}

// Sealed interface -> exhaustive switch via SKIE's onEnum(of:).
func describe(state: TrailListUiState) -> String {
    switch onEnum(of: state) {
    case .loading:
        return "Loading"
    case .success(let success):
        return "\(success.trails.count) trails"
    case .error(let error):
        return error.message
    }
}

// iosApp/iosApp/Features/TrailList/TrailListModel.swift
import Observation
import Shared

@MainActor
@Observable
final class TrailListModel {
    // The shared Kotlin ViewModel; owning it keeps its viewModelScope alive.
    private let viewModel: TrailListViewModel

    private(set) var uiState: TrailListUiState

    init(viewModel: TrailListViewModel) {
        self.viewModel = viewModel
        self.uiState = viewModel.uiState.value // initial value, synchronously
    }

    /// Runs until the surrounding Task is cancelled.
    func observe() async {
        // With KMP-NativeCoroutines this line becomes:
        //   for try await state in asyncSequence(for: viewModel.uiState) { ... }
        for await state in viewModel.uiState {
            uiState = state
        }
    }

    func refresh() {
        viewModel.refresh()
    }

    func toggleFavorite(id: String) async {
        _ = try? await viewModel.toggleFavorite(trailId: id)
    }
}

// iosApp/iosApp/Features/TrailList/TrailListView.swift
import SwiftUI
import Shared

struct TrailListView: View {
    @State private var model: TrailListModel

    init(viewModel: TrailListViewModel) {
        _model = State(initialValue: TrailListModel(viewModel: viewModel))
    }

    var body: some View {
        content
            .navigationTitle("Trails")
            .refreshable { model.refresh() }
            // Starts when the view appears and is cancelled automatically when it disappears.
            .task { await model.observe() }
    }

    @ViewBuilder
    private var content: some View {
        switch onEnum(of: model.uiState) {
        case .loading:
            ProgressView()
        case .success(let success):
            List(success.trails, id: \.id) { trail in
                Text(trail.name)
            }
        case .error(let error):
            ContentUnavailableView(error.message, systemImage: "exclamationmark.triangle")
        }
    }
}