A modern programming language that makes developers happier.

kotlinlang

Hey :wave:  Im a student whos new to kotlin multiplatform. I am builing a KMM app and was wondering if anyone has used any projects that allow for shared view models in KMM

just use flow instead of livedata and make your viewmodel just a simple class handling the flow logic.

example:

```class LoginViewModel(
    private val login: Login = Login()
) {

    private val _state = MutableStateFlow&lt;ComponentState&gt;(ComponentState.Idle)
    val state = _state.asStateFlow()

    private val _effects: Channel&lt;LoginEffect&gt; = Channel()
    val effects = _effects.receiveAsFlow()

    fun sendLogin(email: String, password: String) {
        MainScope().launch {
            _state.emit(login(LoginCredentials(email, password, "password"))))
        }
    }
}```

for compose you just need the `state.asState()` … for swift you need to create a `watch()` method and pass a  simple lambda to listen flow changes

and the watch method could use combine to update the view’s data automatically?

if you decide to use compose and swift ui .. you can split logic in state and effects.. state just hold the current component state and effects dispatch events to be handle (show toast / route to screen/ etc) .. effects is everything that cannot be a screen/component state.. everything that “happens”

you can write an extension inside your swift project to transform flow events in combine streams

oh wow thats awesome! I was _hoping_ that there was a way to keep the combine/flow code in kmm

but this is still super helpful and likely the approach I will take! Thanks so much!

my current problem is: state in my kotlin module is a sealed class (i need to describe state and hold a value for loaded state).. in android it’s perfect.. but in swift the better solution is to use a enum (enum can hold values) .. so in my ios project i create a extension to translate my state into swift enums.

if you find a solution to translate flows in combine streams or a way to transform flow output in swiftui binding using property wrapper.. send to me plx.

today i use the example of kotlin conf app and use a watch methods like it:

```fun &lt;T&gt; Flow&lt;T&gt;.watch(block: (T) -&gt; Unit): Closeable {
    val scope = MainScope()
    onEach {
        block(it)
    }.launchIn(scope)

    return object : Closeable {
        override fun close() {
            try {
                scope.cancel()
            } catch (e: Exception) {}
        }
    }
}```

I _looooove_ enums in swift -  theyre awesome but I can see how that issue would be a pain

I will definitely reply back here once ive got more context if im able to help you out :slightly_smiling_face:

I think the kotlin compiler should evolve in future to transform sealed classes into enums.. makes more sense in my mind.

yeah that would be ideal. I feel like a more likely solution would be a kmm dependency that can convert the sealed class into enums in the ios lib so  you dont need to know the sealed class existed in the ios app