Hi. Using gradle, how publish the jsJar of a project to a maven repository?

Is is possible to get some build version number or so from the gradle build file within the js or common part, like BuildConfig in Android?

Hi, guys? Is there any KMP library for file operating like create file/ delete file/ open file inputstream? If no, then may there KMP library for Desktop only(support MacOSX&Linux&Windows)？

I’m trying to build for macos and I keep seeing this issue in one of my modules

e: Compilation failed: Built-in class kotlin.Any is not found

Any ideas? My other module builds fine and has no issues, so I can’t figure out what could possibly be wrong.

I'm having some issues with classes not being packaged into the aar output of my project with submodules. I have a submodule import with

commonMain {
            dependencies {
                implementation project(':common-mp')

Within this project, is an expected class and actual definition for android. When I assemble outputs using :mainModule:assemble, the jar within the aar does not contain the source files from the common-mp project. I've tried 'api' instead of 'implementation', but that doesn't work. Am I missing something obvious?

Is reflection handled differently between Android and iOS with Kotlin Multiplatform? Accessing the any member val from KClass returns "Unresolved reference: <name>" when building the iOS variant, but doesn't complain for the Android variant. I've tried also adding the reflect dependency in case.

Odd situation I had with some Kotlin 1.3.72 multiplatform code earlier: - Usage of

MonoClock

compiles in both common and JVM - Usage of

Monotonic

(imported directly from

TimeSource

) compiles in both common and JVM - Usage of

TimeSource.Monotonic

compiles in common, but fails in JVM All three scenarios were regarded as acceptable by the IntelliJ Kotlin plugin (version 1.4-M3), but the last one failed to compile regardless.

are there any plans to allow kotlinx.serialization to only serialize / deserialize certain fields? Jackson has something like

@JsonIgnoreProperties

, maybe a @JsonInclude and @JsonExclude would be nice or something more generic that allows field filtering when serializing / deserializing

Are there any ways or planed ways to add platforms (

actual

declarations) for an external library's common code? E.g. have your common module depend on the library's common, and implement it's

expect

definitions in your own platform module.

How does one setup custom sourceSet publishing? I have js and wasm sourceSets that both depend on browser sourceSet which depends on common sourceSet (also used by jvm). I want all 4 source sets published, but maven-publish ignores browser sourceSet with default settings

I’m trying to create a mpp project targeting the jvm for ktor and android. Where should I put the ktor gradle things like this ?

group = "some.group.id"
version = "0.2.0"

application {
    mainClassName = "io.ktor.server.netty.EngineMain"
}

tasks.withType<ShadowJar> {
    archiveBaseName.set("some.group.id")
    archiveClassifier.set("")
    archiveVersion.set("")
}

Should I have a specific

build.gradle.kts

under

backendMain

(source set for my ktor backend) ?

Is it possible to configure KMP library targeting jvm, js, and native to publish sources and kdoc so that the users would get same hints in IDEA as they do for JVM?

Has anyone experienced this weird behaviour when publishing KMP lib to bintray via maven-publish - along with the version you;re publishing, there are few "empty" versions created as well, one for each platform named not with semVer, but with artifact name... e.g. 1.0.0 vs my-lib-wasm32

Hey, I would like to add a .txt file to my multiplatform (android & ios) library/framework to read some data from. Is there a way to add this file as an ios resource? I know that for android I can just add it to res/raw and it will work, but I'm kinda lost at ios side.

I have a multi-platform multi-module project. Is there any way to allow other modules of the same project to see each other’s

internal

declarations?

Hello everyone. I’ve searched through the threads here and I know I’m not the first person to ask this, but I’m still struggling so I’m hoping to get some help. I’m currently trying to combine two shared kotlin mpp modules that use the cocoapods plugin into one framework. I just got the cocoapods sample working in the

JetBrains/kotlin-native

project using the

kotlin-native-xcode-11-4-workaround

library. I modified the

kotlin-library

project to have two modules, both of which are using the cocoapods plugin. I saw this thread where @Kris Wong found a project that uses a third module to aggregate things using the

packForXCode

task pattern, and I’ve tried to do basically the same thing but haven’t been successful getting that to work. I’ve also played with creating a fatFramework in a third module but I’m not sure I’m doing it correctly. I feel like from everything that I’ve read, this might be the best way to go. Has anyone aggregated two or more modules with cocoapods frameworks for ios targets? Would having a module that creates a fatFramework from other modules be a way to go? Should I be using the

export

function to export the module and the module dependecies in my ‘aggregate’ module, and then create the fatFramework? The project I’d like get to eventually would have a bunch of shared modules, some using cocoapod frameworks, some not, so I’m trying to find a good way to keep expanding on this. Thanks.

Hi everyone, is there any sample project repository that demonstrate all latest language feature, setup and perhaps use network and persistency library ? And maybe with kotlin coroutine

native-mt

Hi everyone, quick question, does anyone know when Kotlin Multiplatform is expected to be promoted from "experimental" to a more "stable" release?

Im trying to set up a JVM target to run unit tests in. I have the following gradle setup:

commonTest {
            dependencies {
                implementation(kotlin('test-common'))
                implementation(kotlin('test-annotations-common'))
            }
        }
        jvmTest {
            def mockk_version = "1.10.0"
            dependencies {
                dependsOn(commonTest)
                implementation kotlin('test')
                implementation kotlin('test-junit')
                implementation "org.jetbrains.kotlinx:kotlinx-serialization-runtime:$kotlin_serialization_version"
                implementation "org.jetbrains.kotlinx:kotlinx-coroutines-test:$coroutines_version"
                implementation "io.mockk:mockk:${mockk_version}"
                implementation "io.ktor:ktor-client-serialization-jvm:$ktor_version"
                implementation "io.ktor:ktor-client-json-jvm:$ktor_version"
            }
        }

However i think there's something funky going on with org.jetbrains.kotlinx:kotlinx-serialization even though supposedly it supports the JVM target - Every model i have which is annotated with

@Serializable

gives the following error:

error: incompatible types: Serializable cannot be converted to Annotation @java.io.Serializable()

I’m targeting android, ios, and backend (jvm/ktor) in my project. I’m sharing models for all those targets but I want to share the code for the api client only between android and ios. Is there a way to tell gradle to not care about missing dependencies for

ktor-client

under my

sourceSets["backendMain"].dependencies

?

Has there been indication yet on whether

native-mt

version of kotlinx coroutines will be made available that works with Kotlin 1.4? (doesn't look at least like there's one corresponding to -rc release)

Hello, What do you think, if an application is currently being developed for only one platform, does it make sense to use a cross-platform architecture anyway? or will it be superfluous?

I have a

jvmTest

sourceset that i use to run unit tests. I can run individual test-classes or individual test-methods from IntelliJ, and

gradlew jvmTest

also works correctly but when i try to "Run all tests..." for jvmTest i get an error: "No tests were found". What gives? Gradle:

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

Started testing with newly available

1.3.8-native-mt-1.4.0-rc

version of kotlinx coroutines. Looking good so far on Android and iOS but now on macOS I'm seeing following (when building in XCode)....has anyone else come across this?

Undefined symbols for architecture x86_64:
  "__kernelrpc_mach_port_destroy_trap", referenced from:
      _platform_darwin__kernelrpc_mach_port_destroy_trap_wrapper850 in common(result.o)
     (maybe you meant: knifunptr_platform_darwin883__kernelrpc_mach_port_destroy_trap, _platform_darwin__kernelrpc_mach_port_destroy_trap_wrapper850 )

I have a project in Android Studio with androidApp, iosApp modules and three additional multiplatform modules. The original build.gradle.kts files were generated from the new project wizard from 1.4-M3. Lets call the three multiplatform modules mp1, mp2, and mp3 (not their real names :-)). If I make a valid unit test class names FooTest in the test directory of mp1 and attempt to debug it, Android Studio issues a gradle task "mp1:assemble", waits for that to build, then runs the debugger, The debugger then fails to start with a NoClassDefFound exception because FooTest is not compiled yet. If I then go to the gradle window, force run gradle task ":mp1:compileDebugUnitTestSources", it correctly builds the unit test, and the debugger then starts successfully. This is my first multi platform project. Do others see this behavior regarding debugging of unit tests? Whatever gradle build task is issued when debugging a unit test, seems like it should somehow tell gradle to ensure the compileDebugUnitTestSources is run. I've been working around this for a few days and still catch myself forgetting to manually run compileDebugUnitTestSources after a test source change, and then debbugging against mismatched source.

When I want to create a multiplatform library In 1.4-rc I must specify at least one target. I would like to be able to create a library that only has common code. And any projects that includes this library should be able to use that code in any target. Using IR as a target it seems like this should be possible as any target should be able to use ir code. Anyone know if you can do this and how to do it?

Just fyi that I've released a new Kotlin Multiplatform sample (BikeShare) based on Kotlin 1.4.0-rc and related dependencies https://twitter.com/joreilly/status/1289281453457514498?s=20

Hello, I'm encountering this issue when trying to publish the kotlinMultiplatform publication of a library (using Kotlin 1.3.72):

Execution failed for task ':modules:collections:allMetadataJar'.
> Cannot expand ZIP '/home/runner/work/Splitties/Splitties/modules/collections/build/classes/kotlin/metadata/nativeMain/collections_nativeMain.klib' as it does not exist.

Here's the Gradle scan: https://gradle.com/s/prbmyqsufsl4y And here's the GitHub Actions run: https://github.com/LouisCAD/Splitties/runs/934757382#step:4:1 What could be the root cause?

Hi, was curious if anyone had any luck building projects with Xcode 12 beta - I have a project with Cocopods integration that builds fine under Xcode 11.x, but on Xcode 12 beta, the same project fails with:

REPO_ROOT="$PODS_TARGET_SRCROOT"

                "$REPO_ROOT/../gradlew" -p "$REPO_ROOT" :common:syncFramework                     -Pkotlin.native.cocoapods.target=$KOTLIN_TARGET                     -Pkotlin.native.cocoapods.configuration=$CONFIGURATION                     -Pkotlin.native.cocoapods.cflags="$OTHER_CFLAGS"                     -Pkotlin.native.cocoapods.paths.headers="$HEADER_SEARCH_PATHS"                     -Pkotlin.native.cocoapods.paths.frameworks="$FRAMEWORK_SEARCH_PATHS"

Error: Could not find or load main class org.gradle.wrapper.GradleWrapperMain

Caused by: java.lang.ClassNotFoundException: org.gradle.wrapper.GradleWrapperMain

Tried manually replacing

REPO_ROOT

with the correct folder there but didn’t help. Don’t think it’s cocoapods related because before cocopoads, I had the manual connection way first and that was also failing with the same issue only on Xcode 12 beta.