How to run a full stack web app in continuous mode ?

Hi folks! I want to share how we are invoking Gradle from our Xcode project when building our iOS app. We only build the configuration (Release/Debug/simulator/device) actually requested by Xcode. We also generate a dependencies file (Makefile style

.d

-file) which Xcode uses to determine whether Gradle needs to be run at all. Xcode will discover changes to

.kt

files (which we edit in Android Studio, they aren't part of the Xcode project), changes to the Gradle files, etc and only then rebuild the framework. It works nicely so far. Would be great to get some feedback on the approach. https://gist.github.com/ntherning/dafd5979bdfb660bbf516066ca056931

Anyone having issues declaring

coreLibraryDesugaring

inside

androidMain

dependencies? It seems that this function does not exist for the

multiplatform

plugin

Does anyone have any idea if Kotlin will ever support having these kind of dependencies? With the current Kotlin version, we end up with redundant classes because module are being built separately.

What's the best IDE to use on a Mac to be able to open a KMM project and edit both Swift code and Kotlin/Native? I've tried using Appcode with the K/N plugin but it dosen't really seem to understand my project. It ignores the top-level gradle file. If I use the Xcode workspace to open the project, and I can't seem to import my existing shared library code.

I’m trying to make the Cocoapods plugin working with iOS app (Tried official and Touchlab fork). I’ve enabled the plugin and generated my podspec file (also fix the path of the script because my setup is a bit different). It does create the “dummy” framework in

shared/build/cocoapods/framework/shared.framework

Back to the ios folder, I’m doing

pod install

and it does install everything. When I hit build, it fails with error like

could not build module shared

. When inspecting the imported shared.framwork, I see it’s still have the

dummy.h

so makes me think the sync didn’t worked. Where can I get more info about that

before_compile

script which calls task

gradlew shared:syncFramework

? Also, I did try to manually call the

./gradle shared:syncFramework

task but it fails with

Task syncFramework not found in project shared

. Why? Did checkout Touchlab’s KampKit and can compile without any issue… when comparing what they did, it’s pretty much the same. I’m clearly missing something but can’t point exactly what… Anyone with some hint? Thanks!

trying to generate .js file so it can be used like other .js files in HTML but getting this error.

Could not create an instance of type org.jetbrains.kotlin.gradle.targets.js.subtargets.KotlinBrowserJs.
> Failed to apply plugin [class 'org.gradle.language.base.plugins.LifecycleBasePlugin']
   > Cannot add task 'clean' as a task with that name already exists.

Here is the common code Gradle for js source.

js {
        moduleName = "EmtCore"
        binaries.executable()
        browser {
            webpackTask {
                outputFileName = "$moduleName.js"
            }
            runTask {
                outputFileName = "$moduleName.js"
            }
        }
    }

can anyone guide how to generate .js file

I’m testing Android Studio KMM plugin (0.1.3-release-54-Studio4.1). When I add a cinterop dependency to the iOS shared code, debugging a unit test no longer works. It seems gradle waits on

:shared:iosTest

forever. Has anyone experience this before?

Is t here a way to use

runBlockingTest

of [TestCoroutineScope](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-test/kotlinx.coroutines.test/-test-coroutine-scope/) for native tests?

Hi, everyone. I need some advice for this architecture sample I shared the sample previously. but I added some improvement. Sample supports • To share VIewModel Android, Ios both • To share Navigation stack by Android, Ios both • To use ‘function’ way to draw on Compose, SwiftUi both as able to share Navigation. View side code got simpler just drawing UI and deliver user action to viewModel. dependency between each Screen is removed. just ViewModel interact between viewModels. I’m wondering if this is fine approach. Android

fun SampleScreen(val model: SampleViewModel) {
    Screen(model) {
        Column {
            Text("greeting : ${+model.greeting}")
            Text("reply result : ${+model.replyResult}")
            Button("Reply") { model.onClick() }
        }
    }
}

Ios • code looks similar though if ui is complicated, code also not be similar.

func SampleScreen(_ model: ApiSingleViewModel) -> some View {
    Screen(model) {
        Column {
            Text("current value : \(+model.greeting ?? "")")
            Text("reply result : \(+model.replyResult ?? "")")
            Button("Reply") { model.onClick() }
        }
    }
}

Common

class SampleViewModel(val api: SampleApi = serviceLocator.sampleApi) : BaseViewModel() {

    //[add] is for ios to watch each Flow, DataFlow will be migrated to SharedFlow
    val greeting by add { DataFlow<String>() }
    val replyResult by add { DataFlow<String>() }

    override fun onInitialized() {
        //initStatus handle error and loading ui, also retry on error
        greeting.load(initStatus) {
            api.getGreeting("Hyun", "Programmer")
        }
    }

    fun onClick() {
        //initStatus hide ui on loading, error.
        //status doesn't hide ui but show loading, error ui
        replyResult.load(status) {
            api.reply("Thanks")
            navigate(SomeOtherViewModel()) // you can navigate this way.
        }
    }
}

Hi all, using the Android Studio MMP template in Android Studio the with the new iOS architecture with Kotlin 1.4 it produces a module with supported platforms -

Selected Target platforms: Native (ios_arm64), Native (ios_x64)

but when manually creating a module in IntelliJ there is no way to create a module with multiple targets? There’s a

Target Platform: Multiplatform

but this does not allow the use of the iOS platform libraries. Should I just scrap my existing project and use the new Template, or is there something I’m missing?

does anyone have suggestions for learning more about the native ios memory model and object subgraph freezing? I have read through the kotlin docs on it but still feel a bit confused

I’m unable to add a

common

dependency to my project because gradle is trying to find an artifact named

file-macosx64

whereas the actual name is

file-macosX64

(lowercase vs uppercase

X

) This is probably a general gradle question, but is there a way to help gradle find the correct artifact?

Please let me know the minimum iOS os version that support kotlin multiplatform

Hi All, Since Kotlin 1.4, the automatic translation of suspend methods is making our iOS API fail with ambiguous methods. That is because we've defined an interface with a suspend method, for use in Kotlin, and 2 special overloads with callback/completions for Jvm(Android) and iOS. The suspend method and iOS specific method are marked with

@JvmSynthetic

to hide them from the JVM API. I am now wondering if there is similar annotation to make methods hidden from the iOS (Objective-C) API, so I can hide the suspend method, effectively disabling the automatic conversion.

is there a multiplatform package format that can be used as a dependency in other multiplatform projects?

given a Kotlin enum

MyEnum

, on Kotlin, it is possible to retrieve the list of all enum values with

MyEnum.values()

what about in Swift?

.values()

doesn’t seem defined in the

MyEnum

object in Swift

what about package variables? is it possible to retrieve them from Swift? for example, this is declared inside a file in commonMain:

package com.project.shared.valuedefs

val myList = listOf("A","B","C")

can I access it from Swift and how?

Anyone have a github repo for a kmm plugin project with additional javascript target? Keep breaking my library when I try to add the js target, just a simple example if it is possible would be much appreciated

anyone know of repos to look at using multithreading coroutines with multiplatform?

hey! looks like last mention of default implementations for expect declarations was over a year ago in this channel. Anyone here know of updates regarding it? https://youtrack.jetbrains.com/issue/KT-20427

is there a way to quiet the compiler if you are creating multiplatform classes, but dont want to implement it on one platform (for instance you want android/ios, but not a js implentation)

When enabling HMPP and using the

ios()

shortcut, I'm noticing that commonizer does not add the optional methods on protocols. For example UITableviewDataSource has 11 methods, but the commonizer is only creating variants that only have the 2 required methods of that protocol. These 11 methods exist on both iosX64 and iosArm64, so figured the commonized versions should also have all the methods. Is this by design or is this a bug?

🎊 https://blog.jetbrains.com/kotlin/2020/10/kotlinx-coroutines-1-4-0-introducing-stateflow-and-sharedflow/

is there a plan to support android + jvm targets at the same time - noticed this in the kotlin mp docs

We don't currently support sharing a source set for these combinations:

    Several JVM targets
    JVM + Android targets
    Several JS targets

Hello! I’m writing a library for KMM, and I would need to have: commonMain/…/RxUtils.kt:

expect class Observable<T>

androidMain/…/RxUtils.kt:

actual typealias Observable<T> = io.reactivex.rxjava3.core.Observable<T>

…but:

Hi. Not sure if multiplatform channel is the right place and even not sure if that is possible. So, I am generating Kotlin response/request data classes used by Ktor. I'd like to keep them separate from common module. Created another module and included

api(project(":generatedapi"))

it as a dependency to common module. It compiles and builds successfully but when I publish the project as a library, those generated classes are not included so clients which are using multiplatform library cannot access them. Does anybody tried to achive something similar like this or maybe know a way how to expose dependency classes to clients? Thanks.

Kotlin/native is unable to find a carthage framework linked through cinterop when running tests. I’m able to use them fine from kotlin/native. Can someone please check? I’ve been banging my head for a while.

e: /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/ld invocation reported errors

The /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/ld command returned non-zero exit code: 1.
output:
ld: framework not found ObjectiveGit

> Task :shared:linkDebugTestMacos FAILED

build.gradle

fromPreset(presets.macosX64, "macos") {
  compilations.main {
    cinterops {
      objectivegit {
        defFile "src/nativeInterop/cinterop/objectivegit.def"
        compilerOpts "-F$projectDir/Carthage/Build/Mac/"
      }
    }
  }
}

objectivegit.def

depends = Foundation
package = libgit2.ObjectiveGit
language = Objective-C
modules = ObjectiveGit

compilerOpts = -framework ObjectiveGit
linkerOpts = -framework ObjectiveGit

i have a

suspend fun

in my kotlin shared code but I have been unable to see it in swift. It shows up in the objective-c framework but for whatever reason Xcode doesn't see it when i am writing swift. any ideas? I am using kotlin 1.4.10