How to properly declare a dependency on pure(no platform modules)

common-module1

jar in another

common-module2

? So far i'm getting NoClassDefFound in my 'common-module2-jvm', but IDE doesn't highlight imports as red and allows to navigate to them(

common-module1

).

IntelliJ/Android Studio seems to be having issues with types defined as `expect`/`actual`... My setup has my KMPP being pulled into my Android project via

includeBuild

, and then the IDE complains with stuff like

Wrong nth argument type. Found: 'Foo', required: 'Foo'

(where the method using

Foo

is in my common code, but

Foo

is defined in my JVM code via `expect`/`actual`)

Is this my correct understanding of how can you make multiple modules with just common code that depend on each other?

Now I'm making a call using

client.call {
            url("<https://192.168.2.233:4040/jokes/random>")
            method = HttpMethod.Get
        }

and it never completes - I should probably wait until it's out of alpha, right? 🙂

Is there working example of producing .framework file for IOS out of empty native module(only common code)?

Droidcon NYC app published to iOS app store! https://medium.com/@kpgalligan/kotlin-multiplatform-in-the-app-store-c3a50c24f93b

Silly questions somewhat related to KMPP: if I'm pulling in a KMPP build into an Android project using Composite Builds (

includeBuild

), is there a simple way to ignore all the ios/native/js platform modules? I only care about common/jvm/android ones, and there's a ton of irrelevant stuff taking up sidebar space in this project now 😞 Also, is it normal that

includeBuild

doesn't maintain the nesting of modules? I had the platform modules nested under the common ones in my KMPP, and now they've all been flattened 😞

Can I compile kotlin-multiplatform-native on widnows into a .framework file? I opened this project https://github.com/JetBrains/kotlin-mpp-example in my Windows IntellijIdea and tried to do so, but there is no

compileDebugIos_x64KotlinNative

task that is referenced in this gradle script https://github.com/JetBrains/kotlin-mpp-example/blob/master/greeting/ios/build.gradle. I'm not familiar with how ios build system works, do I need to open it from Xcode on Mac?

Hey friends! Does anyone know how IntelliJ/Android Studio is supposed to work when using Multiplatform projects as a Composite Build? The IDE is giving me a lot of errors with

actual

definitions saying that there's no corresponding `expect`ed declaration

Is there any effort/project to offer a common

Locale

class ?

Hello guys, I’m trying to share some code between Android and iOS apps and my final goal is to have a completely detached kotlin project in a different repository that could generate a

jar

for android and a

framework

for iOS. Is there a way to do that currently with kotlin multiplatform/native? (the sample projects are all very coupled)

Is there an example anywhere of how to run native tests on the ios simulator with the new multiplatform gradle plugin?

I'm trying to use

org.jetbrains.kotlin.multiplatform

and stumbling upon the following issue. Quoting sample repo:

A project dependency on another MPP project has the same semantics and is also resolved in a variant-aware way:

```

dependencies { implementation project(':my-mpp-lib') }

So I have `settings.gradle` mentioning

include(":a") include(":b")

Then in `a/build.gradle`:

plugins { id("org.jetbrains.kotlin.multiplatform") } kotlin { targets { fromPreset(presets.linuxX64, 'native') } ... }

and in `b/build.gradle`:

plugins { id("org.jetbrains.kotlin.multiplatform") } kotlin { targets { fromPreset(presets.linuxX64, 'native') } sourceSets { commonMain { dependencies { ... implementation project(':a') } } } }

When I try to run `./gradlew :b:compileKotlinNative`, I get the following error:

exception: java.lang.IllegalStateException: Could not find "a" in [$PROJ_DIR, $PROJ_DIR/a/build/classes/kotlin/native/main, $HOME/.konan/klib, $HOME/.konan/kotlin-native-linux-0.8.2/klib/common, $HOME/.konan/kotlin-native-linux-0.8.2/klib/platform/linux_x64]. ``` Looking into

$PROJ_DIR/a/build/classes/kotlin/native/main

I see a file named

a-native.klib

. So the question is, how can I make this work? Do I have to somehow override suffix of

klib

or dependency, or is it a bug and the plugin should do this itself?

FYI https://github.com/JetBrains/kotlin-mpp-example was updated to be able to build both iOS and Android application (although without MPP Gradle plugin yet)

Are JB planning to migrate the "back-end" part of the Kotlin Web IDE (project) from Java to Kotlin, and refactor the project to use the Kotlin multi-platform system (turn the project into a web stack with both the front-end and back-end written in Kotlin with shared business logic)?

Does

filterIsInstance

declared in common module works on interface type in js and/or native code?

@egorand I’m assuming you weren’t able to use dagger for the cross platform stuff, right?

i tried to add a multiplatform module to a set of existing ones on ktor-client-json this happens: https://asciinema.org/a/OrWy9wtmxzEAxfsSiVSCf0c45 all those lines of errors are just fine according to idea code is here: https://github.com/NikkyAI/ktor/tree/kotlinx-serialization-module/ktor-client/ktor-client-features/ktor-client-json/ktor-client-kotlinx-serialization i suspect this might be a multiplatform bug ? this contains jsut a single expected / actual and it seems like the compiler freaks out and errors on every single statement in one module

Is there an example of how I release a common mpp lib to maven?

Does

org.jetbrains.kotlin.multiplatform

support some way of globally passing

-Xuse-experimental=kotlin.Experimental

to compiler?

KN do business logic code, But is there any effort for KN UI libraries even it is just very basic like a button?

One more question on `org.jetbrains.kotlin.multiplatform`: Do I understand correctly that

*Test

source sets have some specific kind of dependency on

*Main

, not simple

dependsOn

? I'm trying to add

testFixtures

source set as follows:

commonMain { ... }
commonTestFixtures { dependsOn commonMain }
commonTest { dependsOn commonTestFixtures }

nativeMain { ... }
nativeTestFixtures { dependsOn nativeMain }
nativeTest { dependsOn nativeTestFixtures }

I'm getting internal compiler errors, and after commenting out types mentioned in them just for the sake of moving forward on build process, I got the following from linker:

llvm-lto: error: Linking globals named 'ktype:org.sample.InterfaceName': symbol multiply defined!

Apart from the error itself compiler reports source file names, where I clearly see duplications -- but I'm not sure if they are from common / platform modules or duplicated platform module. I guess I'm doing this wrong, but I'm not sure how to redo it properly --

testFixtures

definitely needs access to

main

as it is based on some types from there, and the sole purpose of it is to provide utilities for

test

source set.

With Kotlin 1.3 I'm seeing the following error with mpp:

The Feature "multi platform projects" is experimental and should be enabled explicitly

. How do I enable multi platform projects explicitly in the gradle file? The IDE is of no use here.

can I have multiple targets in the new MPP plugin share a source folder for their actuals? most specifically, a bunch of native variants

Hello everyone! I want to do a research about code sharing with kotlin between android/IOS for my company. If my goal is sharing all the code, except UI and platform dependent stuff but including DB and networking, should I look into kotlin-native or multiplatform? Is there any projects on github with something similar?

Working through the new gradle plugin and trying to apply it to a project. I haven't reached the part where I try to get the framework to function, but I'll be there soon. Any examples of multiplatform with the new gradle plugin and an iOS app?

can i specify a

project()

dependency from an old platform module to a new multiplatform and select which variant I want it to resolve? this will allow me to incrementally migrate rather than doing everything at once.