Hello, do we have something equivalent to the JVM classes java.net.URL and java.net.URLDecoder in common multiplatform code?

UPD: (not KotlinxSerializer) io.ktor.client.features.json.serializer unresolved after update to 1.3.40

Unresolved reference: serializer

What changed?

is any configuration required to enable JS test runner in a multiplatform project on 1.3.40? I’m looking into

build/reports/tests/allTests

after running

check

and I can only see tests executed on

jvm

and

macosX64

How can I change the name of the framework created with the cocoapods plugin. Is it as simple as editing the podspec?

I’m having trouble updating Multiplatform Settings to 1.3.40. Seems to be an issue with the way I have tests in a separate module, which isn’t agreeing with something in the new JS defaults. Here’s a demo project that reproduces the issue based on the new project template: https://github.com/russhwolf/OneThreeForty. Clone project, run

./gradlew clean build check

, and observe the output

Execution failed for task ':kotlinNpmResolve'.
> Cannot add a configuration with name 'OneThreeForty-lib-npm' as a configuration with that name already exists.

If I create instance of Kotlin Class in Swift Code and have strong reference to it, I can see this instance in memory graph. I expected if I set null to reference, instance will be disposed. Unfortunately I see this instance in memory. Why GC doesn’t clear memory?

I have networking callbacks with the following signature:

fun someAPIRequest(input: String, callback: (SomeModel?, SomeError?) -> Unit) {
   ....
}

From what I read, Kotlin Native interoperability to iOS is Kotlin => Objective-C => Swift, correct? To change that into a Result type I’d implement something like:

sealed class  SomeResult<T, E> {
    data class Success<T, E>(val value: T): SomeResult<T, E>()
    data class Failure<T, E>(val value: E): SomeResult<T, E>()
}

fun someAPIRequest(input: String, callback: (SomeResult<SomeModel, SomeError>) -> Unit) {
   ....
}

But then, I’d have to typecast in Swift, correct? I wouldn’t be able to leverage the Swift Result type because it’s a language feature right?

Hi guys, I'm trying to build an app with mpp using also kotlin/js. I'm getting this weird error, anyone ever had this issue?

I just spent a few days converting my teams Android project that was using the

kotlin-platform-x

gradle plugins to use the

multiplatform

plugin. I'm now getting the following error in my builds. Does anyone have any recommendations? I'm a bit stuck now:

> Task :app:lintVitalInternalRelease FAILED

FAILURE: Build failed with an exception.

* What went wrong:
Execution failed for task ':app:lintVitalInternalRelease'.
> Configuration with name 'compileClasspath' not found.

Is it possible to disable on of the default compilations? Eg.

iosTest

?

anyone know mpp (android & ios) library with datetime and timezones? analog of klock

Is it possible to have normal module and multiplatform module in the same gradle project?

Using the

multiplatform

plugin, if I have test sourcesets dependOn other sourcesets, I can't access the

internal

code of those source sets. I have a sourceSet that is generated code, so I separate it, and those tests that depend on the generated code, and the common code can't access the internal code of the common source set. My configuration is inside the thread.

Hey, thanks to @snrostov my https://github.com/sdeleuze/spring-kotlin-fullstack is now using the new MP Gradle plugin but I have to say I am puzzled by the dependency structure that seems rather not conventional and harder to understand that previous one. For the JS module, we have currently:

kotlin {
    target {
        browser()

        sourceSets {
            main {
                dependencies {
                    implementation(kotlin("stdlib-js"))
                    implementation(project(":shared"))
                }
            }
        }
    }
}

Why not:

kotlin {
    target {
        browser()
    }
}
dependencies {
        implementation(kotlin("stdlib-js"))
        implementation(project(":shared"))
    }

For the common module, we have this pretty confusing build:

kotlin {
    jvm()
    js {
        browser()
        nodejs()
    }

    sourceSets {
        commonMain {
            dependencies {
                implementation(kotlin("stdlib-common"))
            }
        }
        commonTest {
            dependencies {
                implementation(kotlin("test-common"))
                implementation(kotlin("test-annotations-common"))
            }
        }
        getByName("jvmMain").apply {
            dependencies {
                implementation(kotlin("stdlib-jdk8"))
            }
        }
        getByName("jvmTest").apply {
            dependencies {
                implementation(kotlin("test"))
                implementation(kotlin("test-junit"))
            }
        }
        getByName("jsMain").apply {
            dependencies {
                implementation(kotlin("stdlib-js"))
            }
        }
        getByName("jsTest").apply {
            dependencies {
                implementation(kotlin("test-js"))
            }
        }
    }
}

Is it the expected final format we are going to use? cc @gaetan

This message was deleted.

Really want to support a project with both an Android and Desktop Java source-set

Strange errors with sqldelight> Case: 1. Create new multiplatform (Android/IOS) project. 2. Add sqldelight: create folder, add plugin to gradle:

buildscript {
    repositories {
        google()
        mavenCentral()
    }
    dependencies {
        classpath 'com.squareup.sqldelight:gradle-plugin:1.1.3'
    }
}
...
apply plugin: 'com.squareup.sqldelight'
sqldelight {
    MyDatabase {
        packageName = "ru.mybase.database"
        sourceFolders = ["sqldelight"]
    }
}
...
kotlin {
...
SourceSets {
        commonMain {
            dependencies {
                implementation kotlin('stdlib-common')
                implementation "com.squareup.sqldelight:runtime-metadata:1.1.3"
            }
        }
...

All compiled and worked. 3. Add kotlinx serialization:

buildscript {
...
    dependencies {
        --> classpath "org.jetbrains.kotlin:kotlin-serialization:1.3.40"
        classpath 'com.squareup.sqldelight:gradle-plugin:1.1.3'
    }
}
...
apply plugin: 'kotlinx-serialization'
...
implementation "org.jetbrains.kotlinx:kotlinx-serialization-runtime-common:0.11.1"
...

And we have error:

Unable to resolve dependency for ':app@debug/compileClasspath': Could not resolve com.squareup.sqldelight:runtime-jvm:1.1.3.

After removing serialization plugin the error remains. Tested with enableFeaturePreview("GRADLE_METADATA") and without.

Any chance there will be a 1.3.0-M1 update for Kotlin 1.3.40? Can’t deploy some libraries until that’s available.

Perhaps like this?

presets.withType<KotlinNativeTargetPreset>().forEach { preset ->
    targetFromPreset(preset)  {
        val main by compilations.getting {
            dependencies {
                api("org.jetbrains.kotlinx:kotlinx-coroutines-core-native:1.2.2")
            }
        }
    }
}

can anyone point me to any example of a gradle kotlin multiplatform project that has a subproject? Even if nobody can give me a specific answer about scala, I am pretty sure I can make it work as a subproject but I don't know how to make the jvm compile task include the subproject properly

I have all my tests in

commonTest

. Is it possible to choose just one target to run the tests?

Uh… maybe it’s been fixed with the test runner updates in 1.3.40?

Hello, does someone have an example of a Multiplatform project that runs common unit tests on its Android library target? Since

1.3.40

to just compile I had to add the following in the root level dependencies block:

testImplementation "org.jetbrains.kotlin:kotlin-test:$kotlin_version"
    testImplementation "org.jetbrains.kotlin:kotlin-test-junit:$kotlin_version"

Running the gradle task

build

, which runs the tasks

testDebugUnitTest

fails:

> Task :testDebugUnitTest FAILED

com.mu51k.core.util.EmailUtilsTests > emailsAreInvalid FAILED
    java.lang.NullPointerException at EmailUtilsTests.kt:20

com.mu51k.core.util.EmailUtilsTests > emailsAreValid FAILED
    java.lang.NullPointerException at EmailUtilsTests.kt:12

2 tests completed, 2 failed

The NPE seems weird, as the code looks like that:

assertTrue { "<mailto:glfala@fefr.com|glfala@fefr.com>".emailValid() }

And

emailValid()

on Android is the following:

actual fun String.emailValid(): Boolean = Patterns.EMAIL_ADDRESS.matcher(this).matches()

Any idea?

This message was deleted.

Hi everyone! I’m a native Android Engineer in London and very new to the multi platform landscape. I am currently thinking how possible it is to scale apps with this approach. Most talks I’ve seen focus on a single shared module. Does anyone know if it possible to have multiple shared modules vs a potential shared monolith?

Hey, can I build a . Framework containing both architectures for the emulator and the iPhone?

Just to clarify, I understand DI well enough, but I wouldn’t know how to provide, say, the equivalent of a Dagger module that injects library objects with platform implementations. I wonder if I’m overthinking it, or if anyone could point me to an example of a good way to achieve this goal.

I have a multiplatform project with kotlin js and I need to use kotlin 1.3.31. Right now intellij idea creates a configuration which uses kotlin 1.3.40 and some stuff which are not available before this version. I am talking about these: 1)

kotlin{
  ...
   js {
    browser {
    }
  }
}

2)

jvmBackendJar {
    dependsOn(jsBrowserWebpack)
    from(new File(jsBrowserWebpack.entry.name, jsBrowserWebpack.outputPath))
}

how can I replicate these tasks without kotlin 1.3.40? Can someone share an older mpp config with js? Thanks 🙂

Anyone know any good projects or blogs on successfully setting up unit tests on (MPP) iOS and Android?