Hi, I am trying to write a composable function where I need to perform few suspend action based on l...

# compose-ios

[ankur2037]

Hi, I am trying to write a composable function where I need to perform few suspend action based on lifecycle of composable. In android world, I was able to achieve this with help of LocalLifecycleOwner as follow. Any suggestion how I can write same code for Kmm-compose since LocalLifecycleOwner is not available.

@Composable
fun MyLifecycleComposable() {
    val lifecycleOwner = rememberUpdatedState(LocalLifecycleOwner.current)
    val coroutineScope = rememberCoroutineScope()
    DisposableEffect(key1 = true) {
        val observer = LifecycleEventObserver { _, event ->
            when (event) {
                Lifecycle.Event.ON_STOP -> {
                    coroutineScope.launch {
                        // perform some action
                    }
                }
                Lifecycle.Event.ON_START -> {
                    coroutineScope.launch {
                        // perform some action
                    }
                }
                else -> Unit
            }
        }
        val lifecycle = lifecycleOwner.value.lifecycle
        lifecycle.addObserver(observer)
        onDispose {
            coroutineScope.cancel()
            lifecycle.removeObserver(observer)
        }
    }
}

[Dima Avdeev]

Hi, You can use LaunchedEffect:

LaunchedEffect(Unit) {
    // Here are passed a CoroutineScope as this context
    launch {
        // Here you can call suspend functions
        delay(100)
    }
}

[Dima Avdeev]

Also, you can extract logic outside of Composable functions and pass external state to it as an argument,
And manage CoroutineScope outside of Compose view hierarchy:

@Composable
fun MyView(externalStateFlow: StateFlow<String>) {
    val state = externalStateFlow.collectAsState()
    Text(state.value)
}

[ankur2037]

Thanks. Let me try first suggestion as second might not be useful. To give more context, I am trying to open & close my DataSource from start and stop which looks like follow.

interface DataSource {
    suspend fun open(): Boolean
    suspend fun close(): Boolean
}

[Vlad]

Or, for example, how do we pause a video/audio/camera playback when the app minimized (ON_STOP from android)?

[Dima Avdeev]

val dataSource: DataSource // get somewhere or put as an argument
    val coroutineScope: CoroutineScope = rememberCoroutineScope()
    DisposableEffect(dataSource) {
        coroutineScope.launch {
            dataSource.open()
        }
        onDispose {
            dataSource.close()
        }
    }

[Vlad]

But if we minimize the app onDispose will not be called? Will it?

[Dima Avdeev]

Interesting, need to check it

[Vlad]

Nope, it will not. That is the whole point of the question

[Dima Avdeev]

Ok, I understand

[Vlad]

Seems like there is no way to pause playbacks in compose mp when we minimize apps

[Dima Avdeev]

No properly handle app stopping (app on background), I think - we need to lift this logic outside of Compose

[Arkadii Ivanov]

I think you will need a navigation library for this case. So that you could handle minimized app case, or when the screen is closed, etc.

[Dima Avdeev]

And make it platform dependent

[Vlad]

I mean, and how a navigation library gonna implement that to provide for us?:)

[Vlad]

Maybe we are currently trying to implement PR for a navigation library to support the case

[Arkadii Ivanov]

E.g. Decompose provides lifecycle awareness. Other libraries might too.

[Vlad]

I saw this talk at the compose mp github, but no progress:
https://github.com/JetBrains/compose-multiplatform/issues/2915

[Arkadii Ivanov]

From my point of view, adding lifecycle awareness is a pretty complex task. It's not enough to just add Lifecycle and bind it to Activity/Window/etc. I think this leads to creating a full-featured navigation solution.

[Arkadii Ivanov]

That's why it may take a while to design and implement

[Landry Norris]

I would argue that lifecycle management is out of scope for a UI library like Compose. I'd rather the Compose API were kept leaner and lifecycle/navigation be handled by another library, be that something like decompose or even Compose navigation (which shares a name with Compose UI, but is and should be a different artifact).

[Pablichjenkov]

💯 agree it shouldn't be part of the compose API but a separate utility.

[ankur2037]

I too feel launch effect along with decompose should be good enough for most of the cases (including my use-case mentioned in the question) and Fragments/Navigation lifecycle level support can be kept out. But it might be opposite to the thinking behind LocalLifecycleOwner support for Android-compose.

[Arkadii Ivanov]

If Decompose feels cumbersome, one could use Decompose-Router. This library provides Compose-based API and has LocalComponentContext, which implements LifecycleOwner, BackHandlerOwner, etc.

[Vlad]

I mean, they announced that they literally added the whole topic yesterday.
https://developer.android.com/jetpack/androidx/releases/lifecycle#2.7.0-alpha01
I am not sure how do we know if that announce only for Jetpack compose or MP compose?

[Arkadii Ivanov]

I believe that's only for Android

[Vlad]

Me too, but is kinda weird so you can't tell without digging into sources right?

[Arkadii Ivanov]

I think everything in Jetpack is either JVM or Android. Unless explicitly announced, like with DataStore, Collections, etc.

[Arkadii Ivanov]

https://developer.android.com/kotlin/multiplatform

[Vlad]

I heard on the compose IOS-alpha presentation talk from JB that jetpack compose team will be adding new stuff into common if they can

[Pablichjenkov]

Yeah the lifecycle stuff is a separate package. It would be nice if they make it multiplatform but so far it is Android only.
The problem I see, conceptually is that a component lifecycle isn't necessarily the Activity lifecycle. The component lifecycle is more related to its state in its parent component. Eg, shown, hidden, partially shown etc. Googles lifecycle library refers to the plain Activity lifecycle and in most cases we need that but also the component lifecycle relative to its parent too. Googles lifecycle package can't do anything here because this is more of a navigation library problem.

[Pablichjenkov]

For that they would have to make jetpack navigation multiplatform too. Might be in their schedule already

[ankur2037]

Hi, has anyone figured out any straight forward approch to achieve this ?

[Vlad]

Not yet. I still have the task for that in my backlog, but I am delaying and doing other stuff

[Vlad]

In blind hope that blessed community resolved everything for me 😄

[Pablichjenkov]

As indicated above, you have to use one of existing navigation libraries that handles platform lifecycle.
The other alternative is handling it yourself. But it would depend on your architecture.
I have done similar stuff but the work is really tied to my project architecture, which most likely is a bit different from yours.