What Testing libraries/ frameworks is everyone using?

Hey. Are the any best practices of porting an existing jvm library (that you do not own) to mpp? Should you: 1. Fork the jvm lib repo and split the code into jvm/common modules. Code your own platform-specific implementation in other platform (e.g. js) for code that could not be extracted to common. 2. Create a new mpp project. Depend on the jvm lib in the jvm module and wrap all of the jvm-specific lib functions/classes in your own wrapper functions/classes. Extract jvm lib common code to common module. Code your own platform-specific implementation in other platform (e.g. js). 3. Create a new mpp project. Depend on the jvm lib in the jvm module and wrap all of the functions/classes in your own wrapper functions/classes. This way common module will only contain code with

expect

keywords. Code your own platform-specific implementation /copy paste common implementation from jvm lib in other platform (e.g. js). I feel like option 1 is the cleanest, option 3 should allow for easiest updates whenever original jvm lib is updated and option 2 is the most balanced. What do you think?

does anyone know how i can debug code that is written with kotlin on ios? when i run the code i cant seem to watch any variables, i get them as ObjcHeader or ObjcObject and i cant know the contents of them. Does anyone know how to fix it? if it is fixable?

In KMM when I want to save data in sqldelight database on iOS, a KotlinException will be thrown while on Android it is Ok. How can I fix it?

Does anyone know of a multiplatform LRU Cache implementation?

Edit: message was not related to multiplatform, removed to reduce visual clutter.

Can anyone help me understand how can we handle asynchronous network calls with ktor http client like adding loader and when it is either success or error then hide it and load appropriate data, with promises and observables it could be done through success or error callback but how can we achieve the same with ktor http client?

I hope anyone from JB is here, as I've got a question. Are there any plans on supporting metadata-only libraries? The idea is to publish only commonMain output without any kotlin targets declared and being able to use it in any consumer project with arbitrary target set. Such artifact could only depend on other metadata-only libraries. EDIT: It'd be ideal to also allow dependencies on libraries with expect-actual for ALL kotlin targets (meaning metadata artifact from such dependencies covers all bases too, although I understand that this would be much harder to maintain) If not, it'd be nice to have an "exhaustive" gradle dsl target shortcut that registers all targets for the lib project.

How to fix "Test events were not received" in AS canary 14 for common module tests. I'm runnng it as Gradle run configuration.

Is there an easy way to catch Java exceptions in multiplatform? I want to catch a specific

<http://javax.net|javax.net>.ssl.SSLPeerUnverifiedException

but I am only able to

catch(e: <http://io.ktor.utils.io|io.ktor.utils.io>.errors.IOException){...}

and nothing more specific than that. Any ideas?

is there a way to store translations in common module?

Hi all! I’m trying to build a local annotation processor for my kotlin multiplatform module, and I’ve faced a couple of problems. 1. Cache looks not working at all in KMP common code. When I update annotation params or remove it, it doesn’t gets regenerated - actually I get old params in the

process

function. Only removing

build/tmp/kapt3

helps. If I use same annotation in my android target, this works fine. 2. In both cases (multiplatform/android modules) generated classes are not recognized by the AS - they are marked as

Unresolved reference

. But the build goes fine. My setup:

annotations/build.gradle.kts

plugins {
    kotlin("multiplatform")
    id("com.android.library")
}

kotlin {
    android()
    jvm()
    ios()
}

annotationProcessor/build.gradle.kts

plugins {
    kotlin("multiplatform")
}

kotlin {
    jvm()
    sourceSets {
        val jvmMain by getting {
            dependencies {
                implementation("com.squareup:kotlinpoet:1.8.0")
                implementation(project(":annotations"))
            }
        }
    }
}

src/jvmMain/resources/META-INF/services/javax.annotation.processing.Processor

file contains my processor

shared/build.gradke.kts

plugins {
    kotlin("multiplatform")
    kotlin("native.cocoapods")
    id("com.android.library")
    kotlin("kapt")
}

kapt {
    useBuildCache = false // even this didn't helped with the cash problem
}

kotlin {
    android()
    ios()
    cocoapods {
        this.frameworkName = "shared"
        summary = "shared"
        homepage = "-"
        license = "-"
    }
    sourceSets {
        val commonMain by getting {
            dependencies {
                implementation(project(":modules:annotations"))
                configurations["kapt"].dependencies.add(project(":modules:annotationProcessor"))
            }
        }
    }
}

Have anyone faced any of these?

How do we execute code on a background thread in IOS using kotlin multiplatform?

Issue with running tests on KMM with coroutines-test. Included “org.jetbrains.kotlinx:kotlinx-coroutines-test:1.4.2-native-mt” in common tests. Gradle - gradle-6.8.2-bin.zip AS - Canary 9 Android gradle plugin version - 7.0.0-alpha09 Error in 🧵

anyone have experience with multiplatform livedata/observable packages? I built an app with moko mvvm and built out the android app with live data but apparently it doesnt work with swiftui

Anyone have experience with using Mapbox with Kotlin Multiplatform?

In the D-KMP sample landing page, I have added the instructions to write your own D-KMP app. You can build very quickly an app using: KMP, JetpackCompose and SwiftUI. Give it a go, and provide your feedback. We only grow by sharing! The main characteristics of the D-KMP Architecture: • it fully shares the ViewModel (and the DataLayer) • coroutine scopes are cancelled/reinitialized automatically, based on the current active screens and the app lifecycle (using LifecycleOwner on Android and the SwiftUI lifecycle on iOS) • it implements the MVI pattern and the unidirectional data flow • it implements the CQRS pattern, by providing 2 types of functions to the UI layer: Events and StateProviders • it uses Kotlin's StateFlow to trigger UI layer recompositions https://github.com/dbaroncelli/D-KMP-sample

Hello everyone, I’m trying to run my KMM application (the android part) with Pixel 3 XL API 27 on my windows OS laptop , the build is successful but I can’t find the app in the emulator. Please has anyone encountered this before? If yes, please how was it fixed?

Hey everyone, is there any developer with Kotlin Multiplatform Mobile in Australia? 🇦🇺 I'd be keen to connect and share experiences! 👋 🙂

Hi all, fairly new to KM, doing some GraphQL which requires an authorization header. The token is an ID token, basic JWT, nothing too fancy. Now, having trouble getting everything all initialized. We're going old-school and not using Koin or any DI, just making a top-level Kotlin object for the GraphQL apolloClient. I'll throw code in the thread.

How can I collect a flow in swift using KMM?

Doing KMM with Compose on Android. Android Studio doesn't handle multiplatform well -- tests in shared code don't run properly, or resolve references. But IDEA Ultimate doesn't have a version of the Android Studio plugin needed for Compose. Anyone else having this issue and managed to work around it somehow?

Hey all, quick question about

kotlin.Result

usage in KMP. trying to use it as a return type by using this in my

:shared

KMP module's build file

kotlin {
    targets.all {
        compilations.all {
            kotlinOptions {
                freeCompilerArgs = freeCompilerArgs + "-Xallow-result-return-type"
            }
        }
    }

    // other source sets and targets here...
}

I can build and run my apps just fine but the IDE is still highlighting that Result cannot be used as a return type. Anyone know if this is an IDE issue or I just didn't configure the build file correctly?

how do you set

sourceCompatibility = 8
targetCompatibility = 8

if you use

jvm { withJava() }

?

What is this Unknown82 configuration? Every time I open the dropdown the number increases (like Unknown72, Unknown77, Unknown82)

How is the testing handled with the linuxArm32Hfp target on a Linux host alongside other Linux targets? Only binaries can be run on the linuxX64 target which covers Unit testing but the same can't be done with the linuxArm32Hfp target on a Linux X64 host, yet Gradle test tasks exist for the target 🤔.

Is there a particular reason why

Closeable

interface and use extension is not in the common stdlib?

I'm trying to setup common configuration between all of my modules (which all have the multiplatform plugin applied) in the root

build.gradle.kts

but I can't figure out how to do that. Any help?

allprojects {
  repositories {
    google()
    mavenCentral()
    maven("<https://maven.pkg.jetbrains.space/public/p/compose/dev>")
    maven("<https://s01.oss.sonatype.org/content/repositories/snapshots>")
  }

  // trying to do something like the following
  kotlin.sourceSets.all {
    languageSettings.useExperimentalAnnotation("kotlin.RequiresOptIn")
  }
}

Is it possible to build stuff for androidTV and wearOS with kotlin multiplatform?