Hi, if we consider Component as a ViewModel, what is the recommended approach to have a viewModelScope inside component to launch coroutines?

You can create a scope and attach it to the lifecycle. See the docs - https://arkivanov.github.io/Decompose/component/scopes/

Thanks for the reply. How can my components act as ViewModels? (must be destroyed when the screen is closed and retained across configuration changes in Android ) If I use instancekeeper, it survives across configuration changes but won’t be destroyed on screen close.

You should use InstanceKeeper, instances stored there should be destroying when the hosting component is destroyed permanently

Well, in my case hosting component is my root component.

Which platform are you talking about?

Android

On Android it should be destroyed when the hosting activity or fragment is destroyed

I meant it’s fine across configuration changes. But the component will not be destroyed when the screen closes (when back pressed.)

This should work exactly like this. Could you please show the code how you integrate the root component?

Let me clarify. My App is Compose Multiplatform, so the component should also be destroyed when composable screen is destroyed. How can I achieve this?

This is not true. The root component is tied to the activity lifecycle and its ViewModelStore

Yeah, I understand this.

So the root component is only destroyed when the hosting activity/fragment itself is destroyed.

That’s why I’m asking the approach to act my component as viewModel

Component itself never acts as ViewModel, but its InstanceKeeper does.

This is my RootComponent

class NoteRootComponent(
    componentContext: ComponentContext,
) : ComponentContext by componentContext, KoinComponent {

    private val navigation = StackNavigation<Config>()

    private val _stack = childStack(
        source = navigation,
        initialConfiguration = Config.List,
        handleBackButton = true,
        childFactory = ::createChild
    )

    val stack: Value<ChildStack<*, Child>> = _stack

    private fun createChild(config: Config, componentContext: ComponentContext): Child {
        return when (config) {
            is Config.List -> Child.List(noteList(componentContext))
            is Config.Details -> Child.Details(noteDetail(config))
        }
    }

    private fun noteList(componentContext: ComponentContext) =
        NoteListViewModelComponent(componentContext, noteDataSource = get()) {
            navigation.push(Config.Details(it))
        }

    private fun noteDetail(config: Config.Details): NoteDetailViewModelComponent {
        return instanceKeeper.getOrCreate {
            NoteDetailViewModelComponent(
                Dispatchers.Main, noteDataSource = get(),
                noteId = config.id
            ) {
                navigation.pop()
            }
        }
    }

    sealed class Child {
        class List(val component: NoteListViewModelComponent) : Child()
        class Details(val component: NoteDetailViewModelComponent) : Child()
    }

    private sealed class Config : Parcelable {
        @Parcelize
        object List : Config()

        @Parcelize
        data class Details(val id: Long?) : Config()
    }
}

You are using component factories incorrectly

Actually, use case is, I want shared ViewModel across Android and iOS.

Let's clarify on the terminology in Decompose (by design). A component - is an entity similar to Fragment. It is never retained. InstanceKeeper - is an entity similar to ViewModelStore. InstanceKeeper.Instance - is similar to ViewModel.

As my current approach is wrong, what would be the correct one for my use case?

I think just share your root component! Use InstanceKeeper internally in every component where you need to retain instances over configuration changes on Android.

I was checking exactly this. Let’s see. Thank you for your time.

No problem at all! The idea is to use InstanceKeeper inside the child component. Don't place the component itself into InstanceKeeper.