Hi, for some reason I cannot resolve a dependency in the common sourceSet in mpp module. More specifically it is a ktor-core dependency. Here is the build.gradle file -

plugins {
    id "com.android.library"
    id 'org.jetbrains.kotlin.multiplatform'
}

repositories {
    mavenCentral()
}

android {
    compileSdkVersion(28)
    buildToolsVersion = "28.0.3"
    defaultConfig {
        minSdkVersion(16)
        targetSdkVersion(28)
    }
}

kotlin {
    android()
    js {
        browser {

        }
    }

    sourceSets {
        commonMain {
            dependencies {
                implementation kotlin('stdlib-common')
                implementation "io.ktor:ktor-client-core:$ktorVersion"
            }
        }
        androidMain {
            dependencies {
                implementation kotlin('stdlib')
            }
        }
        jsMain {
            dependencies {
                implementation kotlin('stdlib-js')
            }
        }
    }
}

Here is the root build.gradle -

// Top-level build file where you can add configuration options common to all sub-projects/modules.
buildscript {
    ext.kotlin_version = '1.3.61'

    repositories {
        google()
        mavenCentral()
        jcenter()
    }

    dependencies {
        classpath 'com.android.tools.build:gradle:3.5.3'
        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
        // NOTE: Do not place your application dependencies here; they belong
        // in the individual module build.gradle files
    }
}

allprojects {
    repositories {
        google()
        jcenter()
    }
}

ext {
    ktorVersion = "1.3.0-rc"
}

Error is -

> Task :shared:compileDebugKotlinAndroid FAILED
e: /Users/fabhotels/Development/testmpp/shared/src/commonMain/kotlin/common.kt: (1, 23): Unresolved reference: HttpClient
e: /Users/fabhotels/Development/testmpp/shared/src/commonMain/kotlin/common.kt: (3, 18): Unresolved reference: HttpClient

The sample project is available here - https://github.com/Protino/testmpp/tree/sample/ktor

Does Kotlin Multiplatform have a way to share code between multiple Platform modules (eg linuxX64, linuxARMV7) where the OS (eg Linux) is the same?

Hi there, any hint how to call an

object

from iOS side? Let's say I have in commonMain a

object Foo

How can i call

Foo

from iOS side? If I try to use Foo directly I actually somehow access the Type, but not the singleton instance. Any idea?

How can a Kotlin/JS gradle subproject depend on a Kotlin/Multiplatform subproject ? In my case I have the following gradle project structure:

client/               <= Kotlin/JS subproject
 |- build.gradle.kts  <= What should I put here to allow client to depend on :shared ?
server/               <= Kotlin/JVM subproject
 |- build.gradle.kts  <= What should I put here to allow server to depend on :shared ?
shared/               <= Kotlin/Multiplatform subproject
 |- build.gradle.kts

I tried to put this but it didn't work:

dependencies {
    implementation(project(":shared"))
}

I’m trying to run the tests for my

js

target but I keep getting

:module:jsTest NO-SOURCE

. My tests are in

module/src/jsTest/kotlin

Is it possible to share common code between native targets with CInterop working?

* What went wrong:
A problem occurred evaluating settings 'sample-kt-sharedlib'.
> Could not find method enableFeaturePreview() for arguments [GRADLE_METADATA] on settings 'sample-kt-sharedlib' of type org.gradle.initialization.DefaultSettings.

Any suggested solution to this? Im trying to upload a multiplatform lib to bintray. Thanks! B-)

Are there any technical limitations for not allowing named arguments to members of expected classes?

Hey guys, we are using Kotlin to build a native Android app, and we are planning to also build an native iOS app. We have a lot of business logic written in Kotlin right now, and its nicely layered, so seperated from the Android framework. I've read about Kotlin Multiplatform and its option to share common logic between different platforms, although after reading more, I'm not sure if our usecase is supported by Kotlin multiplatform. My question and usecase is: is it possible to have a 3 seperate repo setup: core (written in Kotlin), android-app (written in Kotlin) and ios-app (written in Swift). android-app and ios-app both use the core project. So that means that the Core module/repo doesn't know anything about the android/ios project.

Is there a way to run common tests on the JVM using IntelliJ IDEA, ideally with the run icon next to the test? Every time I run a test, it’s running on the JVM but using Gradle. It doesn’t matter than I’ve told the IDEA to not use Gradle for that 😕

Is there any multiplatform Kotlin drawing or game engine library out there ? 🙂

How do i share the same sourceSet between targets? i have common sourceSet with expect declarations and then another sourceSet with actual declarations which I want to compile to two different targets.

Are there any known issues in dealing with a multiplatform project and publishing with resolved versions? I use a version resolution strategy, and when I publish to Maven, am getting errors that versions aren’t included. I’m trying to follow the instructions here: https://docs.gradle.org/6.0.1/userguide/publishing_maven.html#publishing_maven:resolved_dependencies but they don’t seem to work correctly with the multiplatform publications (the versions aren’t included and the metadata build won’t publish at all)

Just digging through https://github.com/JetBrains/kotlinconf-app for the first time. Looking at build.gradle.kts in the common module, it makes sense that the source set defined as iosMain maps to the iosMain package, mobileMain maps to the mobileMain package, and commonMain maps to the commonMain package. Which packages do the jvmMain and androidMain sourcesets map to? I see there is one remaining package called 'main' and it has an AndroidManifest.xml file, so I presume the 'main' package maps to the androidMain sourceset. I am searching to see if these sourceset mappings are by convention or defined in code. They appear to be by convention, but the convention seems inconsistent and the androidMain sourceset appears greyed out.

Cannot find multiplatform arithmetic operations similar to Java's https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Math.html#addExact(long,long) Think it would be great to have arithmetic overflow handling for kotlin multiplatform.

Hello there, I am curious is it possible to make annotation processor for Kotlin Multiplatform at the moment? I found this https://stackoverflow.com/questions/52757881/how-to-write-annotation-processors-for-kotlin-native with the response on October, 2018, but maybe things have changed since then

Are there any fixes for mutliplatform resource loading problem yet?

If I have a Java class that defines a getter like

getFoo()

, which gets translated to the

val

foo

in Kotlin, is there a way to write an expect class that captures that? If I do:

expect class F {
   val foo: Int
}

Kotlin (1.3.61) complains that the matching class in Java (via

actual typealias F = MyJavaClass

) doesn't have that property. Is there some kind of annotation I need to use in my

expect class

to make this work (so that when

val foo

matches up with the Java getter)?

This message was deleted.

has anyone managed to get mockk working for their common tests?

What’s the best practice for directory structure within modules? In Java world, packages are king and reverse domain. What should the directory structures be within commonMain, iosMain and androidMain?

I have one Gradle project which includes two sub projects:

lib

and

sample

. The library uses some dependencies (ktor for instance). They all are declared as

implementation

dependencies. My sample should simply use the

lib

as a dependency. For this i added

commonMainImplementation(project(":lib"))

But if I run my

jvm

sample (which has a

main

method) I get:

java.lang.NoClassDefFoundError: io/ktor/client/HttpClientJvmKt

Which is strange because I do not share the

HttpClient

as a API. It is declared as

internal

and therefore it should not be shared with other libraries... To my question: Is this setup possible? How should it work then? How do I have to declare my lib dependency in the sample?

I’m trying to add a simple unit test to my project. I added:

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

And then in

commonTest/kotlin/

directory I have this file:

class Test {

    @Test
    fun foo() {
        assertEquals(1,2,"Test failed")
    }
}

I run it

./gradlew :common:test

and I get errors like:

> Task :common:compileDebugUnitTestKotlinAndroid FAILED
e: .../common/src/commonTest/kotlin/Test.kt: (1, 20): Unresolved reference: Test
e: .../common/src/commonTest/kotlin/Test.kt: (2, 20): Unresolved reference: assertEquals
e: .../common/src/commonTest/kotlin/Test.kt: (6, 5): 'Test' is not an annotation class
e: .../common/src/commonTest/kotlin/Test.kt: (8, 9): Unresolved reference: assertEquals

Not sure what is going on.

hope none of y'all are using supernatural-fs for iOS. it's completely broken. https://github.com/suparngp/kotlin-multiplatform-projects/issues/63

is there any way to specify that one source set depends on another (i.e., iosArm64Main depends on iosMain), but add a dependency to iosMain that is not included in iosArm64Main?

Hey all, we're trying to implement a common Map class that uses thread confinement for synchronization. We've settled on either using Mutex or a custom implementation of the Actor pattern. Are there any significant advantages or disadvantages to either of these approaches?

Not sure if this was obvious, but while running common tests from the IDE is a hit-or-miss, I recently found out that IDEA offers a way to run custom gradle tasks that can be used as a stop-gap. Very useful for debugging with breakpoints:

I’m getting an error when uploading a multiplatform project to jcenter:

Cannot upload checksum for module-maven-metadata.xml. Remote repository doesn't support sha-512

Does anyone know how to fix this?

Started the year by writing an article about multiplatform. Do check them out if you can. Comments and suggestions are very much appreciated. https://dev.to/kuuurt/maximizing-code-sharing-between-android-and-ios-with-kotlin-multiplatform-54h8?fbclid=IwAR3MVHQv-7Ub_zI5TCkYJNoYA7YYig06xQ66P1rk_iuN9q_aOllO17-UlBw

I have a multiplatform project targetting android, ios, js and jvm. I need a way to spawn a simple thread and be able to call

sleep

method or its equivalent. Coroutines are multiplatform but do they support jvm target? https://github.com/Kotlin/kotlinx.coroutines#multiplatform I see android, js and native here but no jvm.