Gradle plugin generates Swift-friendly APIs from a native framework. Converts sealed classes/interfaces to Swift enums, supports platform class extensions, and allows custom generator creation based on metadata.
This plugin was deprecated. Please use https://skie.touchlab.co
KSwift it's gradle plugin for generation Swift-friendly API for Kotlin/Native framework.
KSwift give you API for adding your own generator based on KLib metadata information.
ProcessorFeatureroot build.gradle
buildscript {
repositories {
mavenCentral()
google()
gradlePluginPortal()
}
dependencies {
classpath("dev.icerock.moko:kswift-gradle-plugin:0.7.0")
}
}
project where framework compiles build.gradle
plugins {
id("dev.icerock.moko.kswift")
}
settings.gradle
pluginManagement {
repositories {
google()
gradlePluginPortal()
mavenCentral()
}
}
project where framework compiles build.gradle
plugins {
id("dev.icerock.moko.kswift") version "0.7.0"
}
root build.gradle
allprojects {
repositories {
mavenCentral()
}
}
project build.gradle
dependencies {
commonMainApi("dev.icerock.moko:kswift-runtime:0.7.0") // if you want use annotations
}
The Swift code generated from this plugin is not automatically included in the shared framework you might have.
You have 2 options to use it in your iOS project:
You can directly import the generated file in your Xcode project like it's a file you have written on your own.
To do so:
After you have added the moko-kswift plugin to your shared module and synced your project, a new Gradle task should appear with name kSwiftXXXXXPodspec where XXXXX is the name of your shared module (so your task might be named kSwiftsharedPodspec).
Enable feature in project build.gradle:
kotlin:
kswift {
install(dev.icerock.moko.kswift.plugin.feature.SealedToSwiftEnumFeature)
}
groovy:
kswift {
install(dev.icerock.moko.kswift.plugin.feature.SealedToSwiftEnumFeature.factory)
}
That's all - after this setup all sealed classes and sealed interfaces will be parsed by plugin and plugin will generate Swift enums for this classes.
For example if you have in your kotlin code:
sealed interface UIState<out T> {
object Loading : UIState<Nothing>
object Empty : UIState<Nothing>
data class Data<T>(val value: T) : UIState<T>
data class ( throwable: Throwable) : UIState<>
}
Then plugin will generate source code:
For each generated entry in comment generated selector - value of this selector can be used for
filter. By default all entries generated. But if generated code invalid (please report issue in this
case) you can disable generation of this particular entry:
kotlin:
kswift {
install(dev.icerock.moko.kswift.plugin.feature.SealedToSwiftEnumFeature) {
filter = excludeFilter("ClassContext/moko-kswift.sample:mpp-library-pods/com/icerockdev/library/UIState")
}
}
groovy:
kswift {
install(dev.icerock.moko.kswift.plugin.feature.SealedToSwiftEnumFeature.factory) {
it.filter = it.excludeFilter("ClassContext/moko-kswift.sample:mpp-library-pods/com/icerockdev/library/UIState")
}
}
As alternative you can use includeFilter to explicit setup each required for generation entries:
kotlin:
kswift {
install(dev.icerock.moko.kswift.plugin.feature.SealedToSwiftEnumFeature) {
filter = includeFilter("ClassContext/moko-kswift.sample:mpp-library-pods/com/icerockdev/library/UIState")
}
}
groovy:
kswift {
install(dev.icerock.moko.kswift.plugin.feature.SealedToSwiftEnumFeature.factory) {
it.filter = it.includeFilter("ClassContext/moko-kswift.sample:mpp-library-pods/com/icerockdev/library/UIState")
}
}
Enable feature in project build.gradle:
kotlin:
kswift {
install(dev.icerock.moko.kswift.plugin.feature.PlatformExtensionFunctionsFeature)
}
groovy:
kswift {
install(dev.icerock.moko.kswift.plugin.feature.PlatformExtensionFunctionsFeature.factory)
}
That's all - after this setup all extension functions for classes from platform.* package will be
correct swift code.
For example if you have in your kotlin code:
class CFlow<T>(private val stateFlow: StateFlow<T>) : StateFlow<T> by stateFlow
fun UILabel.bindText(coroutineScope: CoroutineScope, flow: CFlow<String>) {
val label = this
coroutineScope.launch {
label.text = flow.value
flow.collect { label.text = it }
}
}
Then plugin will generate source code:
public extension UIKit.UILabel {
/**
* selector: PackageFunctionContext/moko-kswift.sample:mpp-library/com.icerockdev.library/Class(name=platform/UIKit/UILabel)/bindText/coroutineScope:Class(name=kotlinx/coroutines/CoroutineScope),flow:Class(name=com/icerockdev/library/CFlow)<Class(name=kotlin/String)> */
public func bindText(coroutineScope: CoroutineScope, : <>) {
.bindText(, coroutineScope: coroutineScope, flow: flow)
}
}
Selector from comment can be used for filters as in first example.
Enable feature in project build.gradle:
kotlin:
kswift {
install(dev.icerock.moko.kswift.plugin.feature.DataClassCopyFeature)
}
groovy:
kswift {
install(dev.icerock.moko.kswift.plugin.feature.DataClassCopyFeature.factory)
}
With this feature for data class like this:
data class DataClass(
val stringValue: String,
val optionalStringValue: String?,
val intValue: Int,
val optionalIntValue: Int?,
val booleanValue: Boolean,
val optionalBooleanValue: Boolean?
)
Will be generated swift code that can be used like this:
let newObj = dataClass.copy(
stringValue: {"aNewValue"},
intValue: {1},
booleanValue: {true}
)
First create buildSrc, if you don't. build.gradle will contains:
plugins {
id("org.jetbrains.kotlin.jvm") version "1.6.10"
}
repositories {
mavenCentral()
google()
gradlePluginPortal()
maven("https://jitpack.io")
}
dependencies {
implementation("com.android.tools.build:gradle:7.0.0")
implementation("org.jetbrains.kotlin:kotlin-gradle-plugin:1.5.21")
implementation("dev.icerock.moko:kswift-gradle-plugin:0.7.0")
}
Then in buildSrc/src/main/kotlin create MyKSwiftGenerator:
in this example will be generated swift extension for each class in kotlin module. You can select
required Context to got required info from klib metadata.
last step - enable feature in gradle:
kotlin:
kswift {
install(MyKSwiftGenerator)
}
groovy:
kswift {
install(MyKSwiftGenerator.factory)
}
kotlin:
kswift {
iosDeploymentTarget.set("11.0")
}
groovy:
kswift {
iosDeploymentTarget = "11.0"
}
Swift source code generates in same directory where compiles Kotlin/Native framework. In common case
it directory
build/bin/{iosArm64 || iosX64}/{debugFramework || releaseFramework}/{frameworkName}Swift.
Kotlin/Native cocoapods plugin (and also mobile-multiplatform cocoapods plugin by IceRock) will move
this sources into fixed directory - build/cocoapods/framework/{frameworkName}Swift.
kswift {
excludeLibrary("{libraryName}")
}
kswift {
includeLibrary("{libraryName1}")
includeLibrary("{libraryName2}")
}
More examples can be found in the sample directory.
Clone project and just open it. Gradle plugin attached to sample by gradle composite build, so you will see changes at each gradle build.
# clone repo
git clone git@github.com:icerockdev/moko-kswift.git
cd moko-kswift
# generate podspec files for cocopods intergration. with integration will be generated swift files for cocoapod
./gradlew kSwiftmpp_library_podsPodspec
./gradlew kSwiftMultiPlatformLibraryPodspec
# go to ios dir
cd sample/ios-app
# install pods
pod install
# now we can open xcworkspace and build ios project
open ios-app.xcworkspace
# or run xcodebuild
xcodebuild -scheme ios-app -workspace ios-app.xcworkspace -destination
xcodebuild -scheme pods-test -workspace ios-app.xcworkspace -destination
All development (both new features and bug fixes) is performed in develop branch. This
way master sources always contain sources of the most recently released version. Please send PRs
with bug fixes to develop branch. Fixes to documentation in markdown files are an exception to
this rule. They are updated directly in master.
The develop branch is pushed to master during release.
More detailed guide for contributers see in contributing guide.
Copyright 2021 IceRock MAG Inc
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance the License.
You may obtain a copy of the License at
http:
Unless applicable law agreed to writing, software
distributed under the License distributed an BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express implied.
See the License the specific language governing permissions
limitations under the License.
Run the task doing ./gradlew kSwiftsharedPodspec from the root of your project.
This will generate a new podspec file, XXXXXSwift.podspec, where XXXXX is still the name of your shared module (so e.g. sharedSwift.podspec)
Now edit the Podfile inside the iOS project adding this line
pod 'sharedSwift', :path => '../shared'
just after the one already there for the already available shared module
pod 'shared', :path => '../shared'
Now run pod install from the iosApp folder so the new framework is linked to your project.
Whenever you need a Swift file generated from moko-kswift just import the generated module (e.g. import sharedSwift) and you are good to go!
/**
* selector: ClassContext/moko-kswift.sample:mpp-library-pods/com/icerockdev/library/UIState */
public enum UIStateKs<T : AnyObject> {
case loading
case empty
case data(UIStateData<T>)
case error(UIStateError)
public init(_ obj: UIState) {
if obj is shared.UIStateLoading {
self = .loading
} else if obj is shared.UIStateEmpty {
self = .empty
} else if let obj = obj as? shared.UIStateData<T> {
self = .data(obj)
} else if let obj = obj as? shared.UIStateError {
self = .error(obj)
} else {
fatalError("UIStateKs not syncronized with UIState class")
}
}
}
import dev.icerock.moko.kswift.plugin.context.ClassContext
import dev.icerock.moko.kswift.plugin.feature.ProcessorContext
import dev.icerock.moko.kswift.plugin.feature.ProcessorFeature
import dev.icerock.moko.kswift.plugin.feature.BaseConfig
import dev.icerock.moko.kswift.plugin.feature.Filter
import io.outfoxx.swiftpoet.DeclaredTypeName
import io.outfoxx.swiftpoet.ExtensionSpec
import io.outfoxx.swiftpoet.FileSpec
import kotlin.reflect.KClass
class MyKSwiftGenerator(
override val featureContext: KClass<ClassContext>,
override val filter: Filter<ClassContext>
) : ProcessorFeature<ClassContext>() {
override fun doProcess(featureContext: ClassContext, processorContext: ProcessorContext) {
val fileSpec: FileSpec.Builder = processorContext.fileSpecBuilder
val frameworkName: String = processorContext.framework.baseName
val classSimpleName = featureContext.clazz.name.substringAfterLast('/')
fileSpec.addExtension(
ExtensionSpec
.builder(
DeclaredTypeName.typeName("$frameworkName.$classSimpleName")
)
.build()
)
}
class Config : BaseConfig<ClassContext> {
override var filter: Filter<ClassContext> = Filter.Exclude(emptySet())
}
companion object : Factory<ClassContext, MyKSwiftGenerator, Config> {
override fun create(block: Config.() -> Unit): MyKSwiftGenerator {
val config = Config().apply(block)
return MyKSwiftGenerator(featureContext, config.filter)
}
override val featureContext: KClass<ClassContext> = ClassContext::class
override val factory = Companion
}
}
Surfaced from shared tags and platforms — no rankings paid for.