I know I can use Flow but this is a small side project and I'm trying to limit myself to familiar APIs.

Does anyone know if there any known issues in IntelliJ with adding dependencies on more than one multiplatform module? I have two local modules and IntelliJ seems to be only autocompleting only for the first one (featureA):

implementation project(':featureA')
implementation project(':featureB')

Stupid question: If I have a multiplatform project, and want to make the commonMain of that project to import another commonMain from another module. Is this not the correct way of doing that

implementation(project(":SharedGlobals"))

?

hello all, I’m trying to use sqldelight both on Android and iOS - but although everything is working fine on Android side, it seems when I attempt to generate the framework for iOS I’ve got a couple of errors on the generated db impl: example of generated insert method:

override fun insertItem(city_name: String, country: String?) {
        driver.execute(117,
                """INSERT OR FAIL INTO locationModel(city_name, country) VALUES (?1, ?2)""", 2) {
            bindString(1, city_name)
            bindString(2, country)
        }
        notifyQueries(database.locationModelQueries.selectAll)
    }

and error:

e: ...DbImpl.kt: (163, 23): Type mismatch: inferred type is MutableList<Query<*>> but Int was expected
e: ...DbImpl.kt: (163, 62): No value passed for parameter 'queryList'

and the .sq example that I’m trying to run is from a sample:

CREATE TABLE locationModel (
    id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
    city_name TEXT NOT NULL,
    country TEXT
);


insertItem:
INSERT OR FAIL INTO locationModel(city_name, country) VALUES (?, ?);


selectAll:
SELECT *
FROM locationModel;

deleteItem:
DELETE FROM locationModel WHERE city_name = ?;

any ideia what I might be doing wrong?

Any way to get Gradle to temporarily ignore one of the targeted platforms in Kotlin / MP ?

How can I configure a multiplatform JVM target to use a sibling JS target (maybe through the JsJar task?). My jvm target consists of a Ktor webserver which will serve some static JS generated by the JS target. I guess these could be separated into independent projects, but the JS target really only makes sense when served by the jvm target so I wanted to couple them together

hi! i was using the

kotlin-multiplatform

gradle plugin to compile a k/n app into iOS, android, and javascript. i just tried to update from

1.3.40

to

1.3.50

and my javascript build broke, since the

compileKotlinJs

and

compileTestKotlinJs

tasks stopped producing a

package.json

file. is there a way to get this file to be produced again? i can tell from the 1.3.50 release notes that the “structure and naming of generated artifacts” for JS has changed, but I can’t find these new artifacts anywhere

Should internal methods/constructors be testable from Test module? In one module it does not work anymore after upgrading to 1.3.50 for JVM and JS (But still does for Native). I get a lot of

Cannot access 'Class': it is internal in 'package.name'

.

"Supporting multiple dependent frameworks (see discussion above) is much more complicated so I can't provide any specific details on this."

Is that a first step towards better integration of KMPP with Xcode projects? https://twitter.com/gradle/status/1169920641559957505?s=09

Hi, buddies, I notice an note this,It says that we need use export method to export dependencies into framework, And do I need to do that when I use

implementation

in dependencies config? https://kotlinlang.org/docs/reference/building-mpp-with-gradle.html#building-final-native-binaries

My feeling is that custom source sets don’t really create separate compilation units under MPP, they just extend the default source sets but in the end get compiled into the same artifacts. Is this correct, or am I missing something?

Related to something I'm trying to do in a multiplatform project: https://kotlinlang.slack.com/archives/C7A1U5PTM/p1567976925031600

Can anyone link me a good or simple example of a multiplatform project that tests common code with common test sources on Android as an instrumented test?

I'm looking into possibility to have multipproject structure like on the picture:

I've run into an issue where incorrect metadata is produced. The target names seem to have been made lowercase which doesn't match the actual published artefacts. https://github.com/Dominaezzz/kgl/issues/12#issuecomment-529889369 . Can plugin users somehow manipulate the output of the

*.module

files?

i think i might know why my iOS source set is an ocean of red in the IDEA editor

Hello everyone, I’m writing a multiplatform library that use in android and ios applications. To work with the database I decided to use sqldeligh. When i add the driver database in androidMain I need to use ‘’import android.content.Context import com.squareup.sqldelight.android.AndroidSqliteDriver’’, code:

import android.content.Context
import com.squareup.sqldelight.android.AndroidSqliteDriver

lateinit var appContext: Context

actual fun createDb(): MobileDatabase {
    val driver = AndroidSqliteDriver(MobileDatabase.Schema, appContext, "mobileDatabase.db")
    return MobileDatabase(driver)
}

My question is how to drag classes from SDKs into multiplatform libraries. My build.gradle:

plugins {
    id 'org.jetbrains.kotlin.multiplatform' version '1.3.50'
    id 'kotlinx-serialization' version '1.3.50'
    id 'net.researchgate.release' version '2.6.0'
    id 'com.squareup.sqldelight' version '1.2.0'
    id 'com.android.library' version '3.5.0'
}
repositories {
    mavenLocal()
    google()
   mavenCentral()
}
group '***'
version = "$version"

apply plugin: "com.squareup.sqldelight"

sqldelight {
    MobileDatabase{
        packageName = "***"
        sourceFolders = ["sqldelight"]
        schemaOutputDirectory = file("src/main/sqldelight/migrations")
    }

}

apply plugin: 'maven-publish'

kotlin {
    def coroutine_version = "1.3.0"
    def ktor_version = "1.2.4"
    def serializer_version = "0.12.0"
    def sqldelight_version = "1.2.0"

    sourceSets {
        commonMain {
            dependencies {
                api 'org.jetbrains.kotlin:kotlin-stdlib-common'
                implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core-common:$coroutine_version"
                implementation "org.jetbrains.kotlinx:kotlinx-serialization-runtime-common:$serializer_version"
                implementation "io.ktor:ktor-client-core:$ktor_version"
                implementation "io.ktor:ktor-client-logging:$ktor_version"
                implementation "com.squareup.sqldelight:runtime:$sqldelight_version"
            }
        }
        androidMain {
            dependencies {
                api 'org.jetbrains.kotlin:kotlin-stdlib'
                implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:$coroutine_version"
                implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:$coroutine_version"
                implementation "org.jetbrains.kotlinx:kotlinx-serialization-runtime:$serializer_version"
                implementation "io.ktor:ktor-client-android:$ktor_version"
                implementation "io.ktor:ktor-client-logging-jvm:$ktor_version"
                implementation "com.squareup.sqldelight:android-driver:$sqldelight_version"
            }
        }
        jsMain {
            dependencies {
                api "org.jetbrains.kotlinx:kotlinx-coroutines-core-js:$coroutine_version"
                implementation "org.jetbrains.kotlinx:kotlinx-serialization-runtime-js:$serializer_version"
                implementation "io.ktor:ktor-client-js:$ktor_version"
                implementation "io.ktor:ktor-client-logging-js:$ktor_version"
            }

        }
        iosMain {
            dependencies {
                api "org.jetbrains.kotlinx:kotlinx-coroutines-core-native:$coroutine_version"
                implementation "org.jetbrains.kotlinx:kotlinx-serialization-runtime-native:$serializer_version"
                implementation "io.ktor:ktor-client-ios:$ktor_version"
                implementation "io.ktor:ktor-client-logging-native:$ktor_version"
                implementation "com.squareup.sqldelight:ios-driver:$sqldelight_version"
            }

        }
    }

    }}

I will be very grateful for any ideas

In Gradle, how can I determine if a particular target is disabled in a multiplatform project? For example, if I'm compiling on Windows, iOS targets won't be available. So I want to detect and avoid configuring an iOS-specific task that calls xcrun in this situation.

Hello, compilation is failing and I have no clues why. How can I debug this ?

You can disable the DFG phase with

kotlin {
    macosX64('macos') {
        compilations.all {
            kotlinOptions {
                freeCompilerArgs += "-Xdisable-phases=Devirtualization,BuildDFG"
            }
        }
    }
}

(I had a problem too in an earlier version) To debug you could try the steps I described in another issue I had before: https://github.com/JetBrains/kotlin-native/issues/2864#issuecomment-504641546

Hi all! How I can use LinkedHashMap from IOS?

I can't define actual typealas for JVM's AtomicReference: commonMain:

expect class AtomicReference<T>(value: T)

jvmMain:

actual typealias AtomicReference<T> = java.util.concurrent.atomic.AtomicReference<T>

In Kotlin docs it's stated as possible. Is it so by design?

Hey guys, there's a way to not use source set multiplatform style, instead use gradle module style? I'm creating a project that target JVM backend, and JS e JVM clients of the REST from backend , and I want to have a common code between the clients, but not with the backend, but, the backend and the clients has some shared code. The problem is that the kotlin common doesn't have a gradle plugin, someone can help? In the commonMain of the client and backend

implementation(project(":shared"))

But I don't know what Gradle plugin I use in the shared module because exist js and jvm plugins but doesn't exist Common

Trying to build kotlin llibrary project LibC that depends on other LibB. MPP, only common code in both projects. Got exception, when trying to build LibC: - Variant 'jvm-api' capability com.company:libb:1.0.2: (full stacktrace in thread)

I’m trying to find an example how to to set up maven publishing for MPP. The offical docs has bits and pieces but it’d like to see the whole setup.

Can I take a multiplatform project with only a jvm target, and change it to a jvm project with 2 jvm sourcesets?

I've got a multiplatform library, published the normal maven-publish way, but consumers of the library can't see the sources. The sources are published properly, but even attaching the sources manually doesn't work, the IDE just hangs on "Attaching..." Any ideas how to troubleshoot this?

Hey guys, is there any equivalent of

@TestOnly

or

@VisibleForTesting

annotations for K/Mp out there?