For 2, I'm not sure what you're trying to do.

I’m experimenting with a project structure where a Ktor app uses two multi-platform modules (JVM . When I include only one module, it works fine, but when I include the second one, I get ClasssNotFoundException errors. I created a reproducible example at https://github.com/egoossens/testmulti What am I missing? Thanks!

I have in my multiplatform project both

common

and

common-client

. I added

common-native

and I wanted to add

common-client-native

. The other one works if i make it as expected by both common modules:

dependencies {
    expectedBy project(':common')
    expectedBy project(':common-client')
}

But I would prefer to reuse declarations from

common-native

like in other platforms:

dependencies {
    compile project(':common-native')
    expectedBy project(':common-client')
}

This gives me the following error:

Could not find method compile() for arguments [project ':common-native'] on object of type org.gradle.api.internal.artifacts.dsl.dependencies.DefaultDependencyHandler.

Similarly

compileKonan

.

Has anyone had trouble with type aliasing java annotations with values? I tried to find some examples in the kotlin library but couldn't find any. For instance I have have in common an annotation such as

expect annotation class NodeEntity(val label: String = "")

and on the jvm target

actual typealias NodeEntity = org.neo4j.ogm.annotation.NodeEntity

. The annotation I want to type alias has one field definition of

String label() default "";

. I am getting

Parameter 'label' has conflicting values in the expected and actual annotation

.

I did it manually by adding gradle build files to a bigger project. You have to use :``` apply plugin: 'kotlin-platform-android' ```

Hey all, do you use any web frameworks with Kotlin? I have been developing my own with the idea of having abstracted ViewControllers, Routing, etc in a multi-platform way. Basically Everything is cross-platform except for the views. Would anyone be interested in this? I didn't originally plan on open sourcing it since I figured it would be to custom tailored to my own requirements. Also I figured most ppl use either React or Angular, which I am not a fan of and my approach might be to much like an iOS/Android app for web developers.

One of the pain points I have with the Mutli-platform expect/actual API, is insuring a consistent modality of the classes. For example I have

expect class View

and in JS I set the view to be

HTMLElement

(an abstract class) and on Android I need it to be

FrameLayout

(a plain class)

i'm not sure that's a good use of it. you would actual/expect adapters to the native platform UI but not the actual native UI types themselves

Work in progress, external reflection plugin for Kotlin multiplatform - https://github.com/UnknownJoe796/kotlinx-reflect-plugin Depends on implementations in https://github.com/UnknownJoe796/kotlinx

Hi guys, i currently attempt to work on a multiplatform HTTP Client for Kotlin. JS and Java works for the moment but perhaps not in the most optimized way. Any people interessed to help me on this ?

Another question: Is there a multi-platform UI framework project for kotlin ?

Have encountered a strange issue when building a JAR for a Common lib via Gradle. Every time the JAR is created it only contains the manifest file.

Publishing the library fails with this error: Unable to find method 'kotlin.reflect.jvm.internal.KClassImpl.getMembers(Lkotlin/reflect/jvm/internal/impl/resolve/scopes/MemberScope;ZZZ)Lkotlin/sequences/Sequence;'.

Hi. Got stuck a bit with the terminology (common-platform-regular modules). I currently have two modules in my project: server and client (web). Server is written in kotlin and being built like a regular kotlin jvm application. Client is written in javascript and being build with webpack using node.js gradle plugin. Now I'd like to share some models and validation logic between client and server. I need a "common module" for this. I have no platform specific stuff there. So are my original modules platform or regular? What kind of dependencies should be there? Building a common module probably should produce some JS code to be used in client, but I can't see corresponding gradle tasks after applying platform-common plugin (only compile to JVM is available). What am I missing here?

When I create a new multi-platform module in the IDEA, it just creates an empty module. I am using Gradle as my build system. UPDATE: If I add the module manually to my settings.gradle file then add a new multi-platform module, it then assembles the previous module but not the one that was just added.

Name overrides are one thing, and you could provide a generic

@TargetName

annotation for that. I'm referring more to also exposing things like @JvmField, @JvmStatic, @JvmOverloads, etc. Why do those belong in common code?

Just published the Droidcon NYC app, which is Android/iOS multiplatform. There's quite a bit of duct tape in there, but it works: https://twitter.com/kpgalligan/status/1025379360910573574

Been incrementally updating my multiplatform-settings library, and I just pushed a new version https://twitter.com/RussHWolf/status/1025897215787769856

Hi. I'm reading code of the kotlinconf-app and can't understand one thing. The web client module contains this:

afterEvaluate {
    copyKotlinJs.dependsOn copyDependenciesKotlinJs
}

But I can't find where does task

copyDependenciesKotlinJs

come from? Seems my project has the plugins applied, but there is no such task.

Actually, the example is based on kotlin 1.2.0.. And also I found kotlin-frontend-plugin that has kotlin-plugin 1.1.61 as a dependency. Seems everything is quite old. Is there some newer approach to simplify the configuration of my js modules? To hide dependency management and node installation? Kotlin-frontend-plugin seems to be the thing, but too outdated.

would it be possible to add Flutter as a multiplatform target via dart’s native extensions? https://www.dartlang.org/articles/dart-vm/native-extensions

I rather hope that there will be a Flutter/React like API based on a Kotlin DSL that is cross platform. That it is also possible to mix it with native UI elements which is not possible in Flutter. It should be possible to create one based on Yoga on native and Android (https://yogalayout.com which is also used by React Native) and with CSS on web.

multiplatform always sounds like a good (especially to PHBs that think they can cut down on work and developers), but actual implementation is full of potholes and surprises...usually tooling is much weaker than apps done in native platform tools and you end up getting slowed down a lot...or you have these weird inconsistencies that make it really write once, test everywhere, fiddle on each platform to get it to work, add workarounds on each platform, etc. This has happened time and time again...Java, Xamarin, R/N, etc.... I take any new attempt w/ a big grain of salt 😉

I think if we had a K/N, K/JS sample interoping that would be nice. Anyone? 😄

A lot of the tricky stuff in K/N is, imho, thread related, which isn't an issue for you now anyway. I haven't quite convinced clients to bite yet, but there really are a few critical missing pieces, at least for mobile. Coming soon.

Touche, maybe the time I'm spending on filing JS tickets (and asking stupid questions) would be better spent on getting Native working and filing tickets and asking questions there 😛

I'm also speaking next week in Virginia next week and haven't started the slides.

The worst possible strategy is waiting for “JB folks to figure it out” and then “I’ll see if I like it”

Has anyone successfully used Gradle's composite builds to include KMPPs in an Android project? I'm trying to avoid needing a private maven repo to publish my artifacts for the time being and just using

git submodule

so I can keep developing while we figure out private repo options. The IDE doesn't maintain the nesting of my projects in my KMPP and complains that `actual`s in my JS/JVM platform projects don't have corresponding `actual`s (they do), and that they can't use certain methods because they're

internal

to the

common

module...