By looking at

mvikotlin:sample

application I had an assumption that tests are working on iOS as well. When cloning repository I found that tests are enabled only for android and js targets. What would it take to get the same tests running for iOS target as well?

Is there any sample for implementing Coroutine Dispatchers in IOS? Seeing the sample it appears the Dispatchers are not implemented:

import kotlinx.coroutines.CoroutineDispatcher

internal actual val mainDispatcher: CoroutineDispatcher get() = throw NotImplementedError()

internal actual val ioDispatcher: CoroutineDispatcher get() = throw NotImplementedError()

MVIKotlin 2.0.2 is released! • Published to Maven Central

Can external events be bound (binded?) to state or intent? So for instance, imagine you are subscribed to some sort of event over the network that should update your state.

On the Overview page for MVIKotlin docs, there's this line

A tiny abstraction over Rx is used instead.

Does this mean that MVIKotlin has a dependency on a Java-only library e.g. RxJava? Or does it mean MVIKotlin has a custom Reactive Extensions implementation of its own? Or something else?

Folks using MVIKotlin, how did you get started? And if you’re using MVIKotlin, do you also prefer to use Decompose?

Version

2.0.3

is released! • Updated Kotlin to 1.5.0 (#218) • Enabled IR mode for JavaScript (#205)

Hi @Arkadii Ivanov I have a trouble with lables on ios, when I publish Label on ios i have a crash

Does anyone have an opinion on the best desktop and web framework to use with mvi now that compose is out? I looked at kotlin/js and kotlin/webassembly as well. I am leaning towards trying out compose with mvi.

I want to explore the MVIKotlin android todo sample app. I tried opening the

todo-app-android

directory as an existing project in Android Studio. But I got a Gradle exception about a missing wrapper task. How should I do this? What's the correct way to import

todo-app-android

into Android Studio?

Hello everyone, how do you share resource loading between desktop and android when utilizing Decompose/MVI? To access resources on Android you need reference to resources, and to get resources you need some kind of context that you cannot seem to get in commonMain. Making a simple weather app, I have an expect/actual fun that loads imageBitmaps (from res/drawable on android, and resources/images on desktop), but for the android one I need to get access to resources from context but I cannot access context in the commonMain to pass it to the expect fun. And desktop doesn't seem to support Painter API so I have to use imageBitmaps. This seems like a common thing to share ( anything with images really), so there must be a way I am missing out on. (Architecture is the same as Jetbrains/ Todo Sample)

Question about asynchrony and Executor - When SuspendExecutor has called a suspend function, and is suspended, does that mean new incoming Intents are queued somehow until the executor is unsuspended? Or is a new instance of executor created to handle these intents?

Hello everyone! Could you please show me a sample project where Labels are used. I could not find a detailed explaination about it in the documentation (maybe I missed something in the samples). I am especially interested about how it should be consumed properly in iOS and with compose in Android. Any comment appreciated.

I am playing with mvikotlin an am trying to use the coroutines libraries with it - but it looks like

Store.states

and

MviView.events

use rx style Subjects (com.arkivanov.mvikotlin.rx.Disposable|Observer) - so just checking if i need mvikotlin-rx dependency for this? or am i missing something?

Not a library question per se, What is the best way to handle an external stream of events into an MVI. I have a player MVI that receives external trackChange events from a queue. Is a good structure just map these trackChange events to intents and bind them to the store? or use another way (Actions?)

hy folks, am trying to use Decompose and MVI libs, and have issue

cocoapods {
        summary = "Shared Module"
        homepage = "Link to the Shared Module homepage"
        ios.deploymentTarget = "14.1"
        frameworkName = "shared"
        podfile = project.file("../iosApp/Podfile")
    }
sourceSets {
sourceSets["iOSMain"].dependencies {
            implementation(Ktor.clientIos)
            implementation(MVIKotlin.kotlin)
            implementation(Decompose.decompose)
        }

sourceSets["commonMain"].dependencies {
            implementation(MVIKotlin.kotlin)
            implementation(Decompose.decompose)
        }
}

why i can't access class of MVI from ios project, like

ObservableValue, LifecycleRegistryKt

sample from https://github.com/JetBrains/compose-jb/tree/master/examples/todoapp

Hey Folks! Has anyone tried to use #realm with MVIKotlin? I'm using it because my app requires syncing of local and remote data and between users which is a very difficult problem that Realm seems to solve. The problem I've run into is that even adding the Realm drivers as a dependency seems to cause the build to fail. Here are some pieces of the stacktrace:

e: org.jetbrains.kotlin.util.KotlinFrontEndException: Front-end Internal error: Failed to analyze declaration Intent
File being compiled: (9,5) in .../store/CharacterListStore.kt
The root cause java.lang.AssertionError was thrown at: org.jetbrains.kotlin.resolve.lazy.descriptors.AbstractLazyMemberScope.getContributedClassifier(AbstractLazyMemberScope.kt:75)

...then....

Caused by: java.lang.AssertionError: Recursion detected on input: Intent under LockBasedStorageManager@33ccfc53 (TopDownAnalyzer for JVM)

...and later in the stacktrace I find:

at io.realm.compiler.IrUtilsKt.getHasRealmModelInterface(IrUtils.kt:90)
        at io.realm.compiler.RealmModelSyntheticCompanionExtension.getSyntheticCompanionObjectNameIfNeeded(RealmModelSyntheticCompanionExtension.kt:45)

And here is the "offending" code:

interface CharacterListStore : Store<Intent, State, Nothing> {
    sealed class Intent {
        data class Delete(val id: Long) : Intent()
        object Loaded : Intent()
    }

    data class State(
        val characters: List<Character> = emptyList(),
        val selectedCharacterId: Long? = null,
    )
}

Hey everyone, our team is considering using this library as a way to maximize code sharing. It is our understanding that with this library, we can share everything except the UI. What we really wanted to do is to share our ViewModel logic. From reading the docs, and inspecting the sample (keep in mind, we haven't studied MVI pattern before), one question popped off: • controller = createController(lifecycle.asMviLifecycle()) -- is this similar to doing viewModel by viewmodels()? What I mean by this question is: Is a Controller similar to a ViewModel in terms of lifecycle?

Has anyone experienced anything like this, i using

mvikotlin-extensions-coroutines

kotlin.IllegalStateException: There is no event loop. Use runBlocking { ... } to start one.
kfun:kotlin.Throwable#<init>(kotlin.String?){} + 95
kfun:kotlin.Exception#<init>(kotlin.String?){} + 93
kfun:kotlin.RuntimeException#<init>(kotlin.String?){} + 93
kfun:kotlin.IllegalStateException#<init>(kotlin.String?){} + 93
kfun:kotlinx.coroutines.takeEventLoop#internal + 532
kfun:kotlinx.coroutines.DefaultExecutor#dispatch(kotlin.coroutines.CoroutineContext;kotlinx.coroutines.Runnable){} + 204
kfun:kotlinx.coroutines.NativeMainDispatcher.dispatch#internal + 275
kfun:kotlinx.coroutines.internal#resumeCancellableWith__at__kotlin.coroutines.Continuation<0:0>(kotlin.Result<0:0>;kotlin.Function1<kotlin.Throwable,kotlin.Unit>?){0§<kotlin.Any?>} + 1275
kfun:kotlinx.coroutines.intrinsics#startCoroutineCancellable__at__kotlin.coroutines.SuspendFunction1<0:0,0:1>(0:0;kotlin.coroutines.Continuation<0:1>;kotlin.Function1<kotlin.Throwable,kotlin.Unit>?){0§<kotlin.Any?>;1§<kotlin.Any?>} + 671
kfun:kotlinx.coroutines.intrinsics#startCoroutineCancellable$default__at__kotlin.coroutines.SuspendFunction1<0:0,0:1>(0:0;kotlin.coroutines.Continuation<0:1>;kotlin.Function1<kotlin.Throwable,kotlin.Unit>?;kotlin.Int){0§<kotlin.Any?>;1§<kotlin.Any?>} + 370
kfun:kotlinx.coroutines.CoroutineStart#invoke(kotlin.coroutines.SuspendFunction1<0:0,0:1>;0:0;kotlin.coroutines.Continuation<0:1>){0§<kotlin.Any?>;1§<kotlin.Any?>} + 693
kfun:kotlinx.coroutines.AbstractCoroutine#start(kotlinx.coroutines.CoroutineStart;0:0;kotlin.coroutines.SuspendFunction1<0:0,1:0>){0§<kotlin.Any?>} + 162
kfun:kotlinx.coroutines#launch__at__kotlinx.coroutines.CoroutineScope(kotlin.coroutines.CoroutineContext;kotlinx.coroutines.CoroutineStart;kotlin.coroutines.SuspendFunction1<kotlinx.coroutines.CoroutineScope,kotlin.Unit>){}kotlinx.coroutines.Job + 666
kfun:kotlinx.coroutines#launch$default__at__kotlinx.coroutines.CoroutineScope(kotlin.coroutines.CoroutineContext?;kotlinx.coroutines.CoroutineStart?;kotlin.coroutines.SuspendFunction1<kotlinx.coroutines.CoroutineScope,kotlin.Unit>;kotlin.Int){}kotlinx.coroutines.Job + 697
kfun:com.arkivanov.mvikotlin.extensions.coroutines.SuspendExecutor#handleAction(1:1){} + 364
kfun:com.arkivanov.mvikotlin.main.store.DefaultStore.<init>$lambda-0#internal + 281
kfun:com.arkivanov.mvikotlin.main.store.DefaultStore.$<init>$lambda-0$FUNCTION_REFERENCE$1.invoke#internal + 97
kfun:com.arkivanov.mvikotlin.main.store.DefaultStore.$<init>$lambda-0$FUNCTION_REFERENCE$1.$<bridge-UNNN>invoke(-1:0){}#internal + 97
kfun:com.arkivanov.mvikotlin.core.store.SimpleBootstrapper#invoke(){} + 686
kfun:com.arkivanov.mvikotlin.main.store.DefaultStore#<init>(1:3;com.arkivanov.mvikotlin.core.store.Bootstrapper<1:1>?;kotlin.Function0<com.arkivanov.mvikotlin.core.store.Executor<1:0,1:1,1:3,1:2,1:4>>;com.arkivanov.mvikotlin.core.store.Reducer<1:3,1:2>){} + 1682
kfun:com.arkivanov.mvikotlin.main.store.DefaultStoreFactory#create(kotlin.String?;0:3;com.arkivanov.mvikotlin.core.store.Bootstrapper<0:1>?;kotlin.Function0<com.arkivanov.mvikotlin.core.store.Executor<0:0,0:1,0:3,0:2,0:4>>;com.arkivanov.mvikotlin.core.store.Reducer<0:3,0:2>){0§<kotlin.Any>;1§<kotlin.Any>;2§<kotlin.Any>;3§<kotlin.Any>;4§<kotlin.Any>}com.arkivanov.mvikotlin.core.store.Store<0:0,0:3,0:4> + 476

Hello Arkadii, thanks for creating Decompose and MVIKotlin! I'm exited to try it out for a new KMM/Compose/SwiftUI project and have been impressed by the documentation so far (on github.io). The thing that actually helped me the most was your submission for the Android Dev Compose challenge ( https://github.com/arkivanov/android-dev-challenge-compose-1 ), it made it much easier to make sense of how all parts come together.

How do you guys handle storing persistant user data with the MVI/ Decompose approach? Eg storing user id persistently (something like shared preferences for Android)

hello everyone, first of all sorry to bother you with this rather basic, general MVI question 🙈 i just started my first "MVI project" and try to learn by reading sources from example apps like the todo-app and try to use the frameworks that are used/mentioned there. (thx a lot @Arkadii Ivanov for all your nice work, btw!) but i somehow do not understand how MVI is meant to work... i mean, compose ui needs state change for recompose. but at the same time, time consuming intents/actions should be done off the UI thread. and the new state is returned when the intent is finished, right (circulation/one direction)? so does that mean that the UI won't change (e.g. toggle switch) until the new state was returned from the server/db?

While learning MVIKotlin (and Decompose) I've been making demo projects that might be useful for others as well: https://github.com/falcon4ever/KMM-demos - Based on the guide on MVIKotlin and the todoapp in the jetbrains repo. I have tried to keep things as 'simple' as possible

Hello everyone! I'm preparing the next major release -

3.0.0

, and I have a question/concern. You may noticed,

SuspendExecutor

has its

executeIntent

and

executeAction

methods defined as

suspend

. The base class

SuspendExecutor

accepts

mainContext

, which is usually

Dispatchers.Main

. Both methods are automatically called from inside

launch

, which has one important effect. The execution is always scheduled, and so is not synchronous. This may have some unwanted or unpredictable behaviours. The

SuspendBootstrapper

is affected as well. I have an idea - to go the same way as

ViewModel

and its

viewModelScope

. We can make all methods non-

suspend

, add

val scope: CoroutineScope

to the

SuspendExecutor

class, and let inheritors decide whether they need to switch context or not. The usage will be as on the screenshot (diff change in the sample

TodoListStoreFactory

). Please let me know what do you think. Maybe I'm missing something?

I'm trying out the time travel feature (super cool!) with the Todo app (from the compose-jb repo), it will only work on the active component/screen right? It's not replaying the navigation from the user input? e.g.: in the demo video I typed some stuff on the main screen, then go into the edit screen edit the entry and return back to the main screen. When replaying, it seems like the app state is manipulated correctly even though the Ui stays on the TodoMainUi

Hello folks. Thanks for creating Decompose and MVIKotlin. Are they ready to be used in production?

Arkadii, How can I test a Store? Are there a simple sample about that?

Hello again. I am facing a trouble to create a Store

fun create(): PopularMoviesStore =
    object : PopularMoviesStore,
        Store<Intent, State, Nothing> by storeFactory.create(
            name = "PopularMoviesStore",
            initialState = State(),
            executorFactory = ::ExecutorImpl,
            reducer = ReducerImpl
        ) {}

But in ::ExecutorImpl there is a type mismatch.

Required:
PopularMoviesStore.Intent
Found:
PopularMoviesStoreFactory.Result

Can anyone help me?

Hello folks. I'm not able to map Valeu<T> from Value<State> to Value<Model> using coroutines on Component. Can anyone help me?