I have some questions for the JB team with regards to gradle and metadata. On the native side, as far as I know, to publish gradle dependencies we need to use the metadata feature. This is problematic because it is new and not yet stable, so different versions of gradle (and by extension metadata) are incompatible. The concrete manifestation of this is that most examples and as far as I know all JB libraries are published with 4.7. Android gradle 3.3 needs 4.10, which has a breaking version of metadata. It seems that the native side is continuing with the metadata approach (here: https://github.com/JetBrains/kotlin-native/commit/f68f7028b10ce6f8cd195faaee2c78fd8432ddf1), but that that isn't a universal plan (here: https://github.com/Kotlin/kotlinx.coroutines/issues/564#issuecomment-427885994). The ability to publish dependencies in a predictable way is critical for adoption, so I'm wondering about plans in the near term (continued in thread...)

Gradle 5.0 was just released too FYI

is it possible to publish multiplatform libraries (for example, one that compiles to JS and Native) to mavenLocal ?

Is it possible to generate javadocs pages from multiplatform projects (using

kotlin-multiplatform

plugin) using Dokka?

I have a project targeting JVM and Native where I want to “expect” a File and then typealias the actual but I am beginning to think this might not be possible. How might I accomplish my goal of using the name “File” in both common and JVM code?

Kotlin/JVM has

@Throws

. Does Kotlin/JS have something like that?

Are there any good tutorials on multiplatform, specifically for native mobile? I'm sort of really deep in the weeds on it, and am trying to bring some of the team up to speed and realizing how much needs to be explained.

more specifically, is there a way to get the current system time, such as in

System.getCurrentTimeMillis()

?

2nd question of the day... I know I can use ktor as a client for Android and iOS, but what about other native platforms? Maybe have an interface

Api

in

common

, an implementation of it based on Ktor in

mobileCommon

and something else for windows?

Hey guys, I'm having a bit with issue with adding a kotlinJs module to my project, mostly due to gradle not being able to find dependencies

Hi Friends, new here. I'm an Android dev and I am looking to make some cross platform code work on both iOS and Android. My company has some straight business logic (no platform API's needed) duplicated on both platforms. I took a look at docs and am a bit confused on the different types of projects I need to use (apple framework, dynamic library, etc) as I don't need any UI or platform specific resources. I've tried out the mpp-ios-android sample and it appears that I can debug the native android code in Android Studio but cannot debug the generated iOS framework from xcode. I'm not sure if it's my unfamiliarity with iOS frameworks, I need a different IDE, I'm generating the wrong type of iOS framework from kotlin native (do I need a dynamic library), or its just not possible to debug the generated code? Based on the searching I've done on this thread I'm reading that debugging might not be supported yet? Thank you

I have pushed the initial code for the KFile project, my attempt to provide a library that provides a canonical Kotlin file class for JVM and Native platforms. https://github.com/pajato/KFile

I'm trying out a kotlinjs module in a multiplatform project, but am running into

Module not found: Error: Can't resolve 'common' in (...)

even though it is properly defined in gradle. Any idea why would this happen?

Hello guys, I read mpp sample in this url and follow it https://kotlinlang.org/docs/tutorials/native/mpp-ios-android.html. But how can I build ios framework to support both arm32 and arm64 in single build?

Is there a workaround for https://youtrack.jetbrains.com/issue/KT-27535 ? I know there are some libraries out there publishing Android aar artifacts.

I'm looking at the tutorials for mpp (https://kotlinlang.org/docs/tutorials/native/mpp-ios-android.html) and see that it says KN comes with some pre-imported frameworks to use for iOS. Is there a way to access Android specific resources in this example? It seems that all of the examples I've seen require Android code to be in a separate module like in multiplatform-settings.

actual fun platformName(): String {
  return "Android"
}

import platform.UIKit.UIDevice

actual fun platformName(): String {
  return UIDevice.currentDevice.systemName() +
         " " +
         UIDevice.currentDevice.systemVersion
}

all i want to do is use a kotlin multiplatform lib on an xcode project. in the tutorial here https://kotlinlang.org/docs/tutorials/multiplatform-library.html they mention “Now check it with the command ./gradlew publishToMavenLocal and you should see a successful build. That’s it, our library is now successfully published and any Kotlin project can depend on it, whether it is another common library, JVM, JS, or Native application.” Can you use a maven dependency on an xcode project? Sorry for noob questions 🙂

Guys, I'm trying to generate a iOS framework to be used by Xcode, but when I build, the project stops recognizing coroutines. I created the task defined here https://kotlinlang.org/docs/tutorials/native/mpp-ios-android.html#tuning-the-gradle-build-script and my

common/build.gradle

file is :

apply plugin: 'kotlin-multiplatform'

kotlin {
    targets {
        fromPreset(presets.jvm, 'jvm')
        final def iOSTarget = System.getenv('SDK_NAME')?.startsWith("iphoneos") \
                              ? presets.iosArm64 : presets.iosX64

        fromPreset(iOSTarget, 'iOS') {
            compilations.main.outputKinds('FRAMEWORK')
        }
    }

    sourceSets {
        commonMain {
            dependencies {
                implementation 'org.jetbrains.kotlin:kotlin-stdlib-common'
                implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core-common:$coroutines_version"
            }
        }

        jvmMain {
            dependencies {
                implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
                implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:$coroutines_version"
            }
        }

        iOSMain {
            dependencies {
                implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core-native:$coroutines_version"
            }
        }
    }
}

Is JetBrains actively working on kotlin2js?

@Test
fun shouldMatchPath() {
    assertEquals(true, true)
}

This common test (in commonTest source set) fails on Kotlin multiplatform 1.3.11. It doesn't run in JVM, and it fails in the linux source set.

Is there any way to actually see the output of native-run tests? No results for linux appear in my build directory, only for jvm

📣 multiplatform library sample with testing and publishing (unofficial) https://github.com/orangy/multiplatform-lib It runs tests for jvm, js & native and can publish it to bintray and likely to maven central (didn’t try it myself). Hope it helps you set up your project for testing & distribution. Feel free to ask questions in a thread.

I recall threads have problems with ios, but also coroutines weren't working that great (some month ago)

Is there a way to make a common

posix

source set that has access to

platform.posix

, which both

macos

and

linux

depend on? Or do I just have to copy-paste everything between the two source sets. Edit: Seems like it's possible, but IntelliJ doesn't seem to like it.

I'm having issues resolving this (

implementation 'org.jetbrains.kotlinx:kotlinx-io:0.1.2-multiplatform-dev-4'

) dependency on the common source set but the jvm and native variants resolve just fine. Is that valid or is it called something else?

Can you have an inline class that wraps a different (private) type on each platform?

If I’ve encountered an issue where test result HTML is not being generated for the linux target in a multiplatform project, should I report it as an issue on Kotlin’s issue tracker, or on Kotlin/Native’s issue tracker?

KClass::isOpen

is marked as being available in Common: https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.reflect/-k-class/is-open.html However, when trying to use it in a common test, it fails to compile in (at least) JS and Native. Any clues why? JS:

Unsupported [This reflection API is not supported yet in JavaScript]

Native:

error: unresolved reference: isOpen

Should this work?

message has been deleted