Coroutines, Flow and Concurrency in Shared Code

// sharedLogic/build.gradle.kts
plugins {
    alias(libs.plugins.kotlinMultiplatform)
    alias(libs.plugins.androidKotlinMultiplatformLibrary) // com.android.kotlin.multiplatform.library
}

kotlin {
    androidLibrary {
        namespace = "com.example.trailmate.shared"
        compileSdk = 37
        minSdk = 26
    }
    iosArm64()
    iosSimulatorArm64()
    jvm("desktop")
    wasmJs { browser() }

    sourceSets {
        commonMain.dependencies {
            implementation(libs.kotlinx.coroutines.core)
        }
        commonTest.dependencies {
            implementation(kotlin("test"))
            implementation(libs.kotlinx.coroutines.test)
            implementation(libs.turbine)
        }
        // Dispatchers.Main on desktop needs a UI-toolkit-specific artifact (see below).
        val desktopMain by getting {
            dependencies {
                implementation(libs.kotlinx.coroutines.swing)
            }
        }
    }
}

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

import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import com.example.trailmate.domain.Trail
import com.example.trailmate.domain.TrailRepository
import kotlinx.coroutines.CancellationException
import kotlinx.coroutines.Job
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.flow.asStateFlow
import kotlinx.coroutines.flow.update
import kotlinx.coroutines.launch

sealed interface TrailListUiState {
    data object Loading : TrailListUiState
    data class Success(val trails: List<Trail>) : TrailListUiState
    data class Error(val message: String) : TrailListUiState
}

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

    private val _uiState = MutableStateFlow<TrailListUiState>(TrailListUiState.Loading)
    val uiState: StateFlow<TrailListUiState> = _uiState.asStateFlow()

    private var refreshJob: Job? = null

    init {
        refresh()
    }

    fun refresh(region: String? = null) {
        refreshJob?.cancel() // only one refresh at a time; the previous one is cancelled
        refreshJob = viewModelScope.launch {
            _uiState.update { TrailListUiState.Loading }
            try {
                val trails = repository.refreshTrails(region) // suspend; main-safe
                _uiState.update { TrailListUiState.Success(trails) }
            } catch (e: CancellationException) {
                throw e // never swallow cancellation
            } catch (e: Exception) {
                _uiState.update { TrailListUiState.Error(e.message ?: "Unknown error") }
            }
        }
    }
}

// iosApp/iosApp/TrailListView.swift
import SwiftUI
import SharedLogic

@MainActor
final class TrailListObserver: ObservableObject {
    @Published private(set) var state: TrailListUiState = TrailListUiStateLoading()
    private let viewModel: TrailListViewModel
    private var task: Task<Void, Never>?

    init(viewModel: TrailListViewModel) {
        self.viewModel = viewModel
    }

    func start() {
        task = Task { [weak self] in
            guard let self else { return }
            // SKIE: StateFlow<T> is exposed as a SkieSwiftStateFlow<T> AsyncSequence.
            for await newState in self.viewModel.uiState {
                self.state = newState
            }
        }
    }

    func stop() {
        task?.cancel() // cancels the underlying Flow collection in Kotlin
    }
}

struct TrailListView: View {
    @StateObject private var observer: TrailListObserver

    init(viewModel: TrailListViewModel) {
        _observer = StateObject(wrappedValue: TrailListObserver(viewModel: viewModel))
    }

    var body: some View {
        content
            .task { observer.start() }
            .onDisappear { observer.stop() }
    }

    @ViewBuilder
    private var content: some View {
        switch onEnum(of: observer.state) { // SKIE: exhaustive switch over a sealed interface
        case .loading: ProgressView()
        case .success(let success): List(success.trails, id: \.id) { Text($0.name) }
        case .error(let error): Text(error.message)
        }
    }
}

// sharedLogic/src/iosMain/kotlin/com/example/trailmate/location/IosLocationProvider.kt
package com.example.trailmate.location

import kotlinx.cinterop.ExperimentalForeignApi
import kotlinx.cinterop.useContents
import kotlinx.coroutines.channels.awaitClose
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.callbackFlow
import platform.CoreLocation.CLLocation
import platform.CoreLocation.CLLocationManager
import platform.CoreLocation.CLLocationManagerDelegateProtocol
import platform.Foundation.NSError
import platform.darwin.NSObject

@OptIn(ExperimentalForeignApi::class)
class IosLocationProvider : LocationProvider {

    override fun locations(): Flow<GeoPoint> = callbackFlow {
        val manager = CLLocationManager()
        val delegate = object : NSObject(), CLLocationManagerDelegateProtocol {
            override fun locationManager(manager: CLLocationManager, didUpdateLocations: List<*>) {
                val last = didUpdateLocations.lastOrNull() as? CLLocation ?: return
                last.coordinate.useContents { trySend(GeoPoint(latitude, longitude)) }
            }

            override fun locationManager(manager: CLLocationManager, didFailWithError: NSError) {
                close(IllegalStateException(didFailWithError.localizedDescription))
            }
        }
        manager.delegate = delegate
        manager.startUpdatingLocation()
        awaitClose {
            manager.stopUpdatingLocation()
            manager.delegate = null // the manager holds its delegate weakly: keep `delegate` referenced above
        }
    }
}

// sharedLogic/src/commonMain/kotlin/com/example/trailmate/data/RequestCounter.kt
package com.example.trailmate.data

import kotlin.concurrent.atomics.AtomicInt
import kotlin.concurrent.atomics.ExperimentalAtomicApi
import kotlin.concurrent.atomics.incrementAndFetch

/** Counts in-flight network requests so the UI can show a global spinner. */
@OptIn(ExperimentalAtomicApi::class)
class RequestCounter {
    private val inFlight = AtomicInt(0)

    fun begin(): Int = inFlight.incrementAndFetch()
    fun end(): Int = inFlight.addAndFetch(-1)
    fun current(): Int = inFlight.load()
}