lifecycle/com.hoc081098.solivagant.lifecycle/LifecycleRegistry

LifecycleRegistry

interface LifecycleRegistry : Lifecycle, Lifecycle.Observer(source)

Represents Lifecycle and Lifecycle.Observer at the same time. Can be used to manually control the Lifecycle.

Inheritors

LenientLifecycleRegistry

Properties

currentState

abstract val currentState: Lifecycle.State

currentStateFlow

abstract val currentStateFlow: StateFlow<Lifecycle.State>

eventFlow

val Lifecycle.eventFlow: Flow<Lifecycle.Event>

Creates a Flow of Events containing values dispatched by this Lifecycle.

Functions

currentStateAsState

@Composable

fun Lifecycle.currentStateAsState(): State<Lifecycle.State>

Collects values from the Lifecycle.currentStateFlow and represents its latest value via State. 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.

onStateChanged

abstract fun onStateChanged(event: Lifecycle.Event)

repeatOnLifecycle

suspend fun Lifecycle.repeatOnLifecycle(state: Lifecycle.State, block: suspend CoroutineScope.() -> Unit)

Runs the given block in a new coroutine when this Lifecycle is at least at state and suspends the execution until this Lifecycle is Lifecycle.State.DESTROYED.

abstract fun subscribe(observer: Lifecycle.Observer): Lifecycle.Cancellable

withCreated

inline suspend fun <R> Lifecycle.withCreated(crossinline block: () -> R): R

Run block with this Lifecycle in a Lifecycle.State of at least Lifecycle.State.CREATED and resume with the result. Throws the CancellationException if the lifecycle has reached Lifecycle.State.DESTROYED by the time of the call or before block is able to run.

withResumed

inline suspend fun <R> Lifecycle.withResumed(crossinline block: () -> R): R

Run block with this Lifecycle in a Lifecycle.State of at least Lifecycle.State.RESUMED and resume with the result. Throws the CancellationException if the lifecycle has reached Lifecycle.State.DESTROYED by the time of the call or before block is able to run.

withStarted

inline suspend fun <R> Lifecycle.withStarted(crossinline block: () -> R): R

Run block with this Lifecycle in a Lifecycle.State of at least Lifecycle.State.STARTED and resume with the result. Throws the CancellationException if the lifecycle has reached Lifecycle.State.DESTROYED by the time of the call or before block is able to run.

withStateAtLeast

inline suspend fun <R> Lifecycle.withStateAtLeast(state: Lifecycle.State, crossinline block: () -> R): R

Run block with this Lifecycle in a Lifecycle.State of at least state and resume with the result. Throws the CancellationException if the lifecycle has reached Lifecycle.State.DESTROYED by the time of the call or before block is able to run.