LifecycleRegistry

Artifact: androidx.lifecycle:lifecycle-runtime

Added in 2.0.0

Kotlin |Java

Cmn

open class LifecycleRegistry : Lifecycle

kotlin.Any
↳	androidx.lifecycle.Lifecycle
	↳	androidx.lifecycle.LifecycleRegistry

A Lifecycle implementation that manages multiple LifecycleObservers.

Commonly used by UI containers (like Activities or Fragments on Android) to manage component lifecycles. Can be used directly to implement custom LifecycleOwner components.

Summary

Public companion functions
`LifecycleRegistry`	`@VisibleForTesting createUnsafe(owner: LifecycleOwner)` Creates a new `LifecycleRegistry` for the given `LifecycleOwner` without main-thread enforcement.	Cmn

Public constructors
`LifecycleRegistry(provider: LifecycleOwner)` Creates a new `LifecycleRegistry` for the given `provider`.	Cmn

Public functions
`open Unit`	`@MainThread addObserver(observer: LifecycleObserver)` Adds a `LifecycleObserver` that will be notified when the `LifecycleOwner` changes state.	Cmn
`open Unit`	`handleLifecycleEvent(event: Lifecycle.Event)` Sets the current `State` and notifies the `LifecycleObserver`s.	Cmn
`open Unit`	`@MainThread markState(state: Lifecycle.State)` This function is deprecated. Override [currentState].	Cmn
`open Unit`	`@MainThread removeObserver(observer: LifecycleObserver)` Removes the given `observer` from the list of registered `LifecycleObserver`s.	Cmn

Public properties
`open Lifecycle.State`	`currentState` The current `State` of the `Lifecycle`.	Cmn
`open StateFlow<Lifecycle.State>`	`currentStateFlow` Returns a `StateFlow` where the `StateFlow.value` represents the current `State` of this `Lifecycle`.	Cmn
`open Int`	`observerCount` The number of registered `LifecycleObserver`s.	Cmn

Public companion functions

createUnsafe

Cmn

Added in 2.6.0

@VisibleForTesting
fun createUnsafe(owner: LifecycleOwner): LifecycleRegistry

Creates a new LifecycleRegistry for the given LifecycleOwner without main-thread enforcement.

Note: LifecycleRegistry is not thread-safe. Multiple threads accessing it must synchronize externally. Useful for JVM testing where a main thread dispatcher is absent.

Public constructors

LifecycleRegistry

Cmn

Added in 2.0.0

LifecycleRegistry(provider: LifecycleOwner)

Creates a new LifecycleRegistry for the given provider.

You should usually create this inside your LifecycleOwner class's constructor and hold onto the same instance.

Parameters
`provider: LifecycleOwner`	The owner `LifecycleOwner`

Public functions

addObserver

Cmn

Added in 2.0.0

@MainThread
open fun addObserver(observer: LifecycleObserver): Unit

Adds a LifecycleObserver that will be notified when the LifecycleOwner changes state.

The given observer will be brought to the current State of the LifecycleOwner. For example, if the LifecycleOwner is in Lifecycle.State.STARTED, the given observer receives Lifecycle.Event.ON_CREATE and Lifecycle.Event.ON_STARTs.

Parameters
`observer: LifecycleObserver`	The `LifecycleObserver` to notify.

Throws
`IllegalStateException`	if no event exists to move up from the observer's initial state.
`IllegalStateException`	if main-thread enforcement is enabled and called on a thread other than the main thread.

handleLifecycleEvent

Cmn

Added in 2.0.0

open fun handleLifecycleEvent(event: Lifecycle.Event): Unit

Sets the current State and notifies the LifecycleObservers.

No-ops if the target state of the event matches currentState.

Parameters
`event: Lifecycle.Event`	The `Event` to process.

Throws
`IllegalStateException`	if main-thread enforcement is enabled and called on a thread other than the main thread.

markState

Cmn

Added in 2.0.0

Deprecated in 2.1.0

@MainThread
open fun markState(state: Lifecycle.State): Unit

Moves the Lifecycle to the given state and dispatches necessary events to the observers.

Parameters
`state: Lifecycle.State`	new state

removeObserver

Cmn

Added in 2.0.0

@MainThread
open fun removeObserver(observer: LifecycleObserver): Unit

Removes the given observer from the list of registered LifecycleObservers.

Parameters
`observer: LifecycleObserver`	The `LifecycleObserver` to remove.

Throws
`IllegalStateException`	if main-thread enforcement is enabled and called on a thread other than the main thread.

Public properties

currentState

Cmn

Added in 2.0.0

open var currentState: Lifecycle.State

The current State of the Lifecycle.

Transitions the Lifecycle to the given target State and dispatches the corresponding Events to any registered LifecycleObservers.

Throws
`IllegalStateException`	if main-thread enforcement is enabled and called on a thread other than the main thread.

currentStateFlow

Cmn

open val currentStateFlow: StateFlow<Lifecycle.State>

Returns a StateFlow where the StateFlow.value represents the current State of this Lifecycle.

observerCount

Cmn

Added in 2.0.0

open val observerCount: Int

The number of registered LifecycleObservers.

Throws
`IllegalStateException`	if main-thread enforcement is enabled and called on a thread other than the main thread.