Handing finishing coroutine executor

[serhiynovos]

Is the any correct way to get know about finishing coroutine executor.

For example, we have a some form and Save button. When user clicks Save button, we send intent to save this form on server side. Executor handles the intent and makes API call to server. After success response user is navigated to another page, on error user see error message.

[serhiynovos]

I tried to implement in using callbacks

My Store

private object ReducerImpl : Reducer<WelcomeStore.State, Msg> {
        override fun WelcomeStore.State.reduce(msg: Msg): WelcomeStore.State = when (msg) {
            is Msg.ServerUrl -> copy(serverUrl = msg.url)
            is Msg.Loading -> copy(loading = msg.loading)
        }
}

sealed interface Msg {
        class ServerUrl(val url: String) : Msg
        class Loading(val loading: Boolean): Msg
 }

sealed interface Intent {
        data class UpdateServerUrl(val url: String) : Intent
        data class ValidateServerUrl(val onSuccess: () -> Unit) : Intent
}

@Parcelize
 data class State(
        val serverUrl: String,
        val serverValid: Boolean = true,
        val serverOldVersion: Boolean = false,
        val loading: Boolean = false
    ) : Parcelable

class ExecutorImpl :
        CoroutineExecutor<WelcomeStore.Intent, Nothing, WelcomeStore.State, Msg, Nothing>() {
        override fun executeIntent(
            intent: WelcomeStore.Intent,
            getState: () -> WelcomeStore.State
        ) {
            when (intent) {
                is WelcomeStore.Intent.UpdateServerUrl -> dispatch(Msg.ServerUrl(intent.url))
                is WelcomeStore.Intent.ValidateServerUrl -> validateServerUrl(intent.onSuccess)
            }
        }

        private fun validateServerUrl(onSuccess: () -> Unit) {
            scope.launch {
                dispatch(Msg.Loading(true))
                delay(1000)
                dispatch(Msg.Loading(false))
                onSuccess.invoke()
            }
        }
    }

Method from my component using Decompose library

override fun onNextClicked() {
        with(state.value) {
            if (serverUrl.isEmpty()) {
                return
            }


            if (!serverUrl.startsWith("http")) {
                updateServerUrl("https://${serverUrl}")
            }
        }

        store.accept(WelcomeStore.Intent.ValidateServerUrl {
            onServerValid()
        })
    }

[arkivanov]

You can publish a Label from the Executor. Then you can observe labels somewhere and perform navigation. See https://arkivanov.github.io/MVIKotlin/store.html

[serhiynovos]

@arkivanov Thanks you.

So in my store interface I added sealed class Label

sealed class Label {
        object Success: Label()
        data class Error(val message: String): Label()
}

To executor method added label publishing

private fun validateServerUrl() {
            scope.launch {
                dispatch(Msg.Loading(true))
                delay(1000) // Emulate IO operation
                dispatch(Msg.Loading(false))
                **publish(WelcomeStore.Label.Success)**
            }
}

and handled in Decompose component

private val scope = coroutineScope(mainContext + SupervisorJob())

init {
        scope.launch {
            store.labels.collect {
                when (it) {
                    is WelcomeStore.Label.Success -> onServerValid()
                    is WelcomeStore.Label.Error -> {
                        // TODO: Handle error
                    }
                }
            }
        }
}

[arkivanov]

Yep, looks valid!