Hi, I have a question when I try to access ios library in builtin some libraries are missing like below.

SwiftUI.Image
platform.CoreGraphics.CGImage

is there any way to access them?

It seems like you cannot use kotlinx.coroutines.flow.MutableStateFlow in common code? Only platform-specific code?

does anyone have experience with Realm? I know there is an open ticket on realm-cocoa about supporting multiplatform projects somehow, how difficult would it be to write wrappers around realm-java and realm-cocoa for a kotlin multiplatform project, I'm stuck on how I would approach creating the Realm models... (currently I'm just handling the persistence outside of KMP, maybe this if fine for now until it's officially supported upstream)

This may be too broad a question (and of course I understand KMP is still in development) so I apologize up front but has anyone else noticed that debugging Android apps in a KMP project with IntelliJ sucks? Debugger often doesn't gather field values making it near useless. I have to resort to starting android studio nearly every time

Hi! I’m trying to create an archive of my iOS project to upload to AppStore but I get this error:

ld: bitcode bundle could not be generated because '/shared42/build/cocoapods/framework/shared42.framework/shared42(result.o)' was built without full bitcode. All object files and libraries for bitcode must be generated from Xcode Archive or Install build file '/shared42/build/cocoapods/framework/shared42.framework/shared42' for architecture arm64

I was using the

packForXcode

task way before (with embedding the .framework directly, working fine) but now I moved to cocoapods way and I get this error. How do we enable bitcode ? Thanks!

which repository do i need to make use of coroutines in 1.4 M2?

sourceSets {
		val commonMain by getting {
			dependencies {
				implementation(kotlin("stdlib-common"))

				val coroutinesVersion = "1.3.7-1.4-M2"
				api("org.jetbrains.kotlinx:kotlinx-coroutines-core:$coroutinesVersion")
			}
		}

> Could not find org.jetbrains.kotlinx:kotlinx-coroutines-core-common:1.3.7-1.4-M2.
     Searched in the following locations:
       - <https://jcenter.bintray.com/org/jetbrains/kotlinx/kotlinx-coroutines-core-common/1.3.7-1.4-M2/kotlinx-coroutines-core-common-1.3.7-1.4-M2.pom>
       - <https://repo.maven.apache.org/maven2/org/jetbrains/kotlinx/kotlinx-coroutines-core-common/1.3.7-1.4-M2/kotlinx-coroutines-core-common-1.3.7-1.4-M2.pom>
       - <https://dl.bintray.com/kotlin/kotlin-eap/org/jetbrains/kotlinx/kotlinx-coroutines-core-common/1.3.7-1.4-M2/kotlinx-coroutines-core-common-1.3.7-1.4-M2.pom>
       - <https://kotlin.bintray.com/kotlinx/org/jetbrains/kotlinx/kotlinx-coroutines-core-common/1.3.7-1.4-M2/kotlinx-coroutines-core-common-1.3.7-1.4-M2.pom>
     Required by:

Does anyone know what gradle command I should be running to run tests from "commonTest"? I'm using

Kotlin.test.Test

annotations and when I try to right click and run from Intellij it generates this test command which looks wrong

cleanIosTest iosTest --tests "tests.MyTest.test

, I've tried changing the command to just

test --tests "tests.MyTest.test

to no avail

Breakpoints seem to have stopped working on IntelliJ when running my code on Android. Has anyone else experienced this lately?

Building my shared folder (./gradlew shared:build) hangs (gradle does not progress anymore) when I build on mac. Gradle is doing iosTest

can you fork assert4k, bump kotlin and push it to maven under your name?

Is anyone working with files in their multiplatform project?

Is it possible to use Android databinding with kotlin multiplatform? I'm able to enable databinding in the module

build.gradle

:

dataBinding {
        enabled = true
    }

But since i have custom binding adapters i also need

kotlin-kapt

plugin. As soon as i add it i get a build error:

C:\x\app\build\generated\source\kapt\release\androidx\databinding\library\baseAdapters\BR.java:3: error: package javax.annotation does not exist
import javax.annotation.Generated;


C:\x\app\build\generated\source\kapt\release\y\databinding\FragmentLoginBindingImpl.java:8: error: package javax.annotation does not exist
@javax.annotation.Generated("Android Data Binding")

Perhaps i need to enable the

kotlin-kapt

plugin only for the android target (since it seems to have a dependency on javax.annotation) - How can i do this?

Anyone managed to use android databinding with binding to

StateFlow

or

MutableStateFlow

properties? I've created custom binding adapters before, but i cannot get it to work properly with StateFlows

Hello, World! I have a very simple and small Kotlin/JVM project that uses a SQLite database, currently via JDBC. I'd like to "port" it to full Native (targeting MacOS only for now would be enough). I was wondering if anybody had any general advices and/or pointers about where to start 🙂 Thanks!

Hi Anyone tried to typealias an `expect`ed class? Looks like I can do it for the JVM but not for JS. The aim is to provide a “platform native” output for some functions so they can be used from Java/Js My common code

expect class Wrapper<T: Any?>

Working Kotlin for JVM code

actual typealias Wrapper<T> = CompletableFuture<T>

Not working Kotlin for JS code

actual typealias Wrapper<T> = Promise<T>

Compiler claims that

Aliased class should not have type parameters with declaration-site variance

Any clue?

Hey there new here! I’ve been working on a project I’m planning to open source but I want to use a multiplatform build so the library is consumable from: kotlin, java, and js (typescript). common -> top level functions and extensions on abstract classes let’s say jvm -> a class or two that use that abstract class js -> a class or two that use that abstract class Before I split the code up this way, do I need to re-export all of the top level functions in common to the other two targets or do they come for free?

I just created a kotlin multiplatform library for android, ios and Javascript which uses the Ktor client for all networking. These are my dependencies for the javascript library

// MPP - JS & common dependencies

    sourceSets["commonMain"].dependencies {
        implementation(kotlin("stdlib-common", Versions.KOTLIN))
        implementation(Deps.Ktor.COMMON_CORE)
        implementation(Deps.Ktor.COMMON_JSON)
        implementation(Deps.Coroutines.COMMON)
        implementation(Deps.MP_SETTINGS)
        implementation(Deps.Ktor.COMMON_SERIALIZER)
        implementation(Deps.Serialization.COMMON)
        implementation(Deps.Stately.COMMON)
        implementation(Deps.Stately.CONCURRENCY)
    }    

    sourceSets["jsMain"].dependencies {
        implementation((kotlin("stdlib-js", Versions.KOTLIN)))
        implementation(Deps.Ktor.JS_CORE)
        implementation(Deps.Ktor.JS_JSON)
        implementation(Deps.Coroutines.JS)
        implementation(Deps.Ktor.JS_SERIALIZER)
        implementation(Deps.Serialization.JS)
    }

My goal is to write the repository layer as a library for the three platforms which can use it to request proprietary data, similar to Firebase Realtime database. But when I import the JS library into the Jetbrains starter React app my javascript binary is 27MiB for dev and 1MiB for prod distributions. Should I expect ktor & coroutines JS libraries to be that heavy for a JS library? Or am I doing something wrong?

For iOS, anyone know a resource for how to define CPointers? Im trying to do something like this:

val view: UITextField
view.addTarget(target = view, action = ::onTextChanged, forControlEvents = UIControlEventEditingChanged)

But its not allowed because Required: COpaguePointer? Found: KFunction0 Apparently theres an

toCPointer()

function? I cant seem to import it, so im unsure how its to be used

Hi, I have started a new project with KMP. I already tested one successfully, but the architecture wasn't good enought for me. Concretly, I would like to call that easily on iOS:

// UseCase

suspend fun run(params: LoginModel): Token = authenticationRepo.auth(params)

It's easy on Android but on iOS I'm struggling.. I used to create a Protocol and a view that is the copy of the android version, but I have to work with event and callbacks. Is there an "easy way" to do the same android call that on iOS :

@UiThread

fun authenticateAsync(loginModel: LoginModel): Deferred<Token> {

return viewModelScope.async {

authenticationTokenUseCase.run(loginModel)

}

}

Ok this has been quite painful and I'm floundering and could use some help. I have a multiplatform project and i want to use the shadowjar plugin to package up a jvm jar for deployment to aws. I had this working no sweat when using just the jvm kotlin plugin but using the multiplatform plugin makes the shadowjar task disappear from gradle and I can't figure out how to set it up right. There's half a dozen answers on stack overflow that purport to have an answer and none of them seem to even use valid syntax in the build.gradle.kts file anymore. Is there not an easier way to get an uberjar in a multiplatform project?

Hello, I have a project setup as such in which jvm1 and jvm2 and different targets:

src
* commonMain
* commonTest
* jvm1Main
* jvm2Main
* jvm2Test

I want it so that running

check

or

build

would run

jvm2Test

and

commonTest

so I setup my `build.gradle`:

kotlin {
    jvm('jvm1')
    jvm('jvm2')

    sourceSets {
        commonMain { dependencies { ... } }

        commonTest {
            dependencies {
                implementation kotlin('test-annotations-common')
            }
        }

        jvm1Main {
            dependsOn commonMain

            dependencies { ... }
        }

        jvm2Main {
            dependsOn commonMain

            dependencies { ... }
        }

        jvm2Test {
            dependsOn commonTest

            dependencies {
                implementation kotlin('test')
                implementation kotlin('test-junit')
            }
        }
    }
}

However, running

./gradlew build

tries to compile

commonTest

through both

jvm1Test

and

jvm2Test

, and fails since

jvm1Test

doesn't have any test dependencies. Is there a way to disable

jvm1Test

or decouple it from

commonTest

?

I'm getting these kind of errors:

Cannot access built-in declaration '...'. Ensure that you have a dependency on the Kotlin standard library

I'm confused as to why it can't find the stdlib?

Hi everyone! Could someone tell me if it is possible to access properties from

gradle.properties

in common code? If not, how can I set an environment variable and read it on common code? Thanks in advance

Hello, World! I'm having trouble finding the correct syntax to declare an

expect

class and reflecting the constructors of the

actual

one. Here's what I'm trying to do: common:

expect class File(path: String) {
    constructor(path: File, name: String)

    fun isDirectory(): Boolean
}

jvm:

actual class File actual constructor(path: String): java.io.File(path) {
    actual constructor(path: File, name: String)
}

This results in

Primary constructor call expected

Any idea about this error

Could not determine the dependencies of task ':[projectname]:compileDebugAidl'.
> Could not resolve all task dependencies for configuration ':[projectname]:debugCompileClasspath'.
   > Could not resolve project :[shared-library-name].
     Required by:
         project :[projectname]
Cannot choose between the following variants of project :[shared-library-name]:
          - androidApiElements
          - androidCompile
          - androidCompileOnly
          - androidDefault
          - androidRuntime
          - androidRuntimeElements
          - androidTestCompile
          - androidTestRuntime
          - iosRuntimeOnly
          - jvmApiElements
          - jvmCompile
          - jvmCompileOnly
          - jvmDefault
          - jvmRuntime
          - jvmRuntimeElements
          - jvmTestCompile
          - jvmTestRuntime

me again... any ideas why

import kotlinx.coroutines.Job

is unknown in my common code, even when I have this dependency:

implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:$versionsCoroutine")

?

Hello! I'm trying to do the following: 1. Create a kotlin lib 2. Generate the

.d.ts

files (I don't use the generated javascript code!) 3. Create a typescript script which uses the

.d.ts

4. Compile to javascript 5. Run in the GraalVM The end result I'm looking for like a binding for my kotlin classes to be called from typescript. I'm using latest kotlin version 1.4-M3. Disclaimer I'm not expert in typescript (nor kotlin), but I could do everything, however: 1. The generated typescript definition file doesn't

export

module, so I cannot import in my typescript script 2. I added the export keyword to fix it 3. Now I can import the definition and use it, however in order to execute in GraaVM what I need is to import java types from javascript by using the

Java.type

call instead of

require

Now I would like to know if there's a way to modify the kotlin generator so that I could achieve transpilation from such imported types to javascript and be callable by GraalVM out of the box. Some guidance on this topic would nice and I believe at least the

export

of the module should be part of the core kotlin generator.

hello i have a multiplatform module that has coroutines as a dependency, when it tries to do

linkDebugTestIos

i get this error

e: Could not find "atomicfu-cinterop-interop"

I have added this as a dependency to the native source set

"org.jetbrains.kotlinx:atomicfu-native:0.14.3"

but it sill has the same error. Can anyone help me figure this out?

Hello, My client doesn't print logs when I make requests through my Android app. Any help would be appreciated. I only get to see:

I/System.out: [OkHttp] sendRequest>>

The code is as follows:

private val client by lazy {
        HttpClient {
            install(JsonFeature) {
                serializer = KotlinxSerializer(
                    Json(
                        JsonConfiguration(
                            isLenient = true,
                            ignoreUnknownKeys = true
                        )
                    )
                )
            }
            install(Logging) {
                logger = Logger.DEFAULT
                level = LogLevel.ALL
            }
        }
    }