Kontinuity
2.0.1indexedFacilitates seamless integration of coroutines and `Flow` with Swift by generating wrapper classes, enabling efficient coroutine management and customizable coroutine scopes.
2
Stars
—
Used by
dependents
—
Health
/ 100
Kontinuity
Effortless use of Kotlin Multiplatform coroutines in Swift, including suspend functions and
Flow<T> returning members.
Installation
Kontinuity includes both a core Kotlin library, a Kotlin Symbol Processor, and various Swift Package Manager packages, depending on how you want to consume the generated code. Please make sure to use the same versions of each individual part.
Kotlin (Gradle)
In your Kotlin Multiplatform module, add the following to your build.gradle.kts file:
plugins {
id("com.google.devtools.ksp")
}
kotlin {
sourceSets {
val commonMain by getting {
dependencies {
implementation("io.mockative:kontinuity-core:2.0.1")
}
}
}
}
dependencies {
add("kspIos", "io.mockative:kontinuity-processor:2.0.1")
}
Swift (Swift Package Manager)
The Swift libraries are available using Swift Package Manager (SPM), by adding the following to your Package.swift file, or in your Xcode Project's Package Dependencies.
dependencies: [
.package(url: "https://github.com/mockative/Kontinuity.git", from: "<version>")
]
Usage
For each Kotlin class or interface annotated with @Kontinuity, a wrapper class is generated,
referred to as the "Kontinuity Wrapper".
Given a Kotlin interface like the following:
package com.app.sample.tasks
@Kontinuity
interface TaskService {
val tasks: StateFlow<List<Task>>
suspend fun createTask(task: Task)
fun close()
}
A Kontinuity Wrapper will be generated:
package com.app.sample.tasks
// The Kontinuity Wrapper class takes the prefix 'K' by default
open class KTaskService(private val wrapped: TaskService) {
// Coroutine members have their names transformed with the 'K' suffix by default
tasksK: KontinuityStateFlow<Task>
() = wrapped.toKontinuityStateFlow()
: KontinuitySuspend<> =
kontinuitySuspend { wrapped.refresh() }
=
wrapped.close()
}
Swift
The generated Kontinuity Wrapper can be used in Swift through KontinuityCore and KontinuityCombine.
import KontinuityCore
import KontinuityCombine
val kotlinTaskService: TaskService
val taskService = (wrapped: kotlinTaskService)
val tasks getValue(of: taskService.tasksK)
val subscription createPublisher(for: taskService.tasksK)
.sink { completion } receiveValue: { tasks
()
}
val subscription createFuture(for: taskService.refreshK())
.sink { completion
()
} receiveValue: { unit }
Name Transformations
Kontinuity Wrapper classes have their names transformed from the type they're wrapping, by prefixing
the class with K. Coroutine members of Kontinuity Wrapper classes also have their names
transformed, in order to prevent the Kotlin compiler from suffixing it with _ when compiling for
iOS/Darwin, which it does to prevent member signature clashes when interfaces are used.
See Configuration - Name Transformations for more information in how to configure Kontinuity.
Coroutine Scope
By default, Kontinuity launches all coroutines in a scope using Dispatchers.Main.immediate. You
can override this behaviour by annotating a top-level property with @KontinuityScope. This
annotation can both be applied to the entire source set (by specifying default = true), or to the
@Kontinuity annotated types within a single source file:
// Specifies the coroutine scope used to launch Kontinuity coroutines of types within this source
// set(s), unless otherwise overwritten by a file-level @KontinuityScope.
@SharedImmutable
@KontinuityScope(default = true)
internal val defaultKontinuityScope = CoroutineScope(Dispatchers.Default + SuperviserJob())
// Specifies the coroutine scope used to launch Kontinuity coroutines of types within this file.
@SharedImmutable
@KontinuityScope
internal val taskServiceScope = CoroutineScope(Dispatchers.Unconfined + SuperviserJob())
interface TaskService {
// Coroutines launches within this type (and other types in this file) are launched in the
// `taskServiceScope`.
}
Roadmap
Credits
Kontinuity is heavily inspired by rickclephas/KMP-NativeCoroutines, and is essentially a Kotlin Symbol Processor version of that Kotlin Compiler Plugin, born out of a desire to have similar features while maintaining compatibility with KSP.