commonMain.dev.datlag.tooling.decompose.lifecycle.CollectAsStateWithLifecycle.kt Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of tooling-decompose-jvm Show documentation
Show all versions of tooling-decompose-jvm Show documentation
Kotlin multiplatform tooling library.
package dev.datlag.tooling.decompose.lifecycle
/*
* Copyright 2021 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/*
* Ported collectAsStateWithLifecycle to Essenty Lifecycle
*/
import androidx.compose.runtime.Composable
import androidx.compose.runtime.State
import androidx.compose.runtime.produceState
import com.arkivanov.essenty.lifecycle.Lifecycle
import com.arkivanov.essenty.lifecycle.LifecycleOwner
import dev.datlag.tooling.async.collectSafe
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.withContext
import kotlin.coroutines.CoroutineContext
import kotlin.coroutines.EmptyCoroutineContext
/**
* Collects values from this [StateFlow] and represents its latest value via [State] in a
* lifecycle-aware manner.
*
* The [StateFlow.value] is used as an initial value. Every time there would be new value posted
* into the [StateFlow] the returned [State] will be updated causing recomposition of every
* [State.value] usage whenever the [lifecycleOwner]'s lifecycle is at least [minActiveState].
*
* This [StateFlow] is collected every time the [lifecycleOwner]'s lifecycle reaches the
* [minActiveState] Lifecycle state. The collection stops when the [lifecycleOwner]'s lifecycle
* falls below [minActiveState].
*
* @sample androidx.lifecycle.compose.samples.StateFlowCollectAsStateWithLifecycle
*
* Warning: [Lifecycle.State.INITIALIZED] is not allowed in this API. Passing it as a
* parameter will throw an [IllegalArgumentException].
*
* @param lifecycleOwner [LifecycleOwner] whose `lifecycle` is used to restart collecting `this`
* flow.
* @param minActiveState [Lifecycle.State] in which the upstream flow gets collected. The
* collection will stop if the lifecycle falls below that state, and will restart if it's in that
* state again.
* @param context [CoroutineContext] to use for collecting.
*/
@Composable
fun StateFlow.collectAsStateWithLifecycle(
lifecycleOwner: LifecycleOwner = LocalLifecycleOwner.current,
minActiveState: Lifecycle.State = Lifecycle.State.STARTED,
context: CoroutineContext = EmptyCoroutineContext
): State = collectAsStateWithLifecycle(
initialValue = this.value,
lifecycle = lifecycleOwner.lifecycle,
minActiveState = minActiveState,
context = context
)
/**
* Collects values from this [StateFlow] and represents its latest value via [State] in a
* lifecycle-aware manner.
*
* The [StateFlow.value] is used as an initial value. Every time there would be new value posted
* into the [StateFlow] the returned [State] will be updated causing recomposition of every
* [State.value] usage whenever the [lifecycle] is at least [minActiveState].
*
* This [StateFlow] is collected every time [lifecycle] reaches the [minActiveState] Lifecycle
* state. The collection stops when [lifecycle] falls below [minActiveState].
*
* @sample androidx.lifecycle.compose.samples.StateFlowCollectAsStateWithLifecycle
*
* Warning: [Lifecycle.State.INITIALIZED] is not allowed in this API. Passing it as a
* parameter will throw an [IllegalArgumentException].
*
* @param lifecycle [Lifecycle] used to restart collecting `this` flow.
* @param minActiveState [Lifecycle.State] in which the upstream flow gets collected. The
* collection will stop if the lifecycle falls below that state, and will restart if it's in that
* state again.
* @param context [CoroutineContext] to use for collecting.
*/
@Composable
fun StateFlow.collectAsStateWithLifecycle(
lifecycle: Lifecycle,
minActiveState: Lifecycle.State = Lifecycle.State.STARTED,
context: CoroutineContext = EmptyCoroutineContext
): State = collectAsStateWithLifecycle(
initialValue = this.value,
lifecycle = lifecycle,
minActiveState = minActiveState,
context = context
)
/**
* Collects values from this [Flow] and represents its latest value via [State] in a
* lifecycle-aware manner.
*
* Every time there would be new value posted into the [Flow] the returned [State] will be updated
* causing recomposition of every [State.value] usage whenever the [lifecycleOwner]'s lifecycle is
* at least [minActiveState].
*
* This [Flow] is collected every time the [lifecycleOwner]'s lifecycle reaches the [minActiveState]
* Lifecycle state. The collection stops when the [lifecycleOwner]'s lifecycle falls below
* [minActiveState].
*
* @sample androidx.lifecycle.compose.samples.FlowCollectAsStateWithLifecycle
*
* Warning: [Lifecycle.State.INITIALIZED] is not allowed in this API. Passing it as a
* parameter will throw an [IllegalArgumentException].
*
* @param initialValue The initial value given to the returned [State.value].
* @param lifecycleOwner [LifecycleOwner] whose `lifecycle` is used to restart collecting `this`
* flow.
* @param minActiveState [Lifecycle.State] in which the upstream flow gets collected. The
* collection will stop if the lifecycle falls below that state, and will restart if it's in that
* state again.
* @param context [CoroutineContext] to use for collecting.
*/
@Composable
fun Flow.collectAsStateWithLifecycle(
initialValue: T,
lifecycleOwner: LifecycleOwner = LocalLifecycleOwner.current,
minActiveState: Lifecycle.State = Lifecycle.State.STARTED,
context: CoroutineContext = EmptyCoroutineContext
): State = collectAsStateWithLifecycle(
initialValue = initialValue,
lifecycle = lifecycleOwner.lifecycle,
minActiveState = minActiveState,
context = context
)
/**
* Collects values from this [Flow] and represents its latest value via [State] in a
* lifecycle-aware manner.
*
* Every time there would be new value posted into the [Flow] the returned [State] will be updated
* causing recomposition of every [State.value] usage whenever the [lifecycle] is at
* least [minActiveState].
*
* This [Flow] is collected every time [lifecycle] reaches the [minActiveState] Lifecycle
* state. The collection stops when [lifecycle] falls below [minActiveState].
*
* @sample androidx.lifecycle.compose.samples.FlowCollectAsStateWithLifecycle
*
* Warning: [Lifecycle.State.INITIALIZED] is not allowed in this API. Passing it as a
* parameter will throw an [IllegalArgumentException].
*
* @param initialValue The initial value given to the returned [State.value].
* @param lifecycle [Lifecycle] used to restart collecting `this` flow.
* @param minActiveState [Lifecycle.State] in which the upstream flow gets collected. The
* collection will stop if the lifecycle falls below that state, and will restart if it's in that
* state again.
* @param context [CoroutineContext] to use for collecting.
*/
@Composable
fun Flow.collectAsStateWithLifecycle(
initialValue: T,
lifecycle: Lifecycle,
minActiveState: Lifecycle.State = Lifecycle.State.STARTED,
context: CoroutineContext = EmptyCoroutineContext
): State {
return produceState(initialValue, this, lifecycle, minActiveState, context) {
lifecycle.repeatOnLifecycle(minActiveState) {
if (context == EmptyCoroutineContext) {
[email protected] { [email protected] = it }
} else withContext(context) {
[email protected] { [email protected] = it }
}
}
}
}
/**
* Collects values from this [Flow] and represents its latest value via [State] in a
* lifecycle-aware manner.
*
* Every time there would be new value posted into the [Flow] the returned [State] will be updated
* causing recomposition of every [State.value] usage whenever the [lifecycle] is at
* least [minActiveState].
*
* This [Flow] is collected every time [lifecycle] reaches the [minActiveState] Lifecycle
* state. The collection stops when [lifecycle] falls below [minActiveState].
*
* @sample androidx.lifecycle.compose.samples.FlowCollectAsStateWithLifecycle
*
* Warning: [Lifecycle.State.INITIALIZED] is not allowed in this API. Passing it as a
* parameter will throw an [IllegalArgumentException].
*
* @param initialValue The initial value given to the returned [State.value].
* @param lifecycle [Lifecycle] used to restart collecting `this` flow.
* @param minActiveState [Lifecycle.State] in which the upstream flow gets collected. The
* collection will stop if the lifecycle falls below that state, and will restart if it's in that
* state again.
* @param context [CoroutineContext] to use for collecting.
*/
@Composable
fun StateFlow.collectAsStateWithLifecycle(
initialValue: T,
lifecycle: Lifecycle,
minActiveState: Lifecycle.State = Lifecycle.State.STARTED,
context: CoroutineContext = EmptyCoroutineContext
): State {
return produceState(initialValue, this, lifecycle, minActiveState, context) {
lifecycle.repeatOnLifecycle(minActiveState) {
if (context == EmptyCoroutineContext) {
[email protected] { [email protected] = it }
} else withContext(context) {
[email protected] { [email protected] = it }
}
}
}
} © 2015 - 2025 Weber Informatics LLC | Privacy Policy