The Lifecycle library offers built-in APIs that let you integrate with Jetpack
[Compose](https://developer.android.com/jetpack/compose). Key APIs include the following:

- Flows for the current `Lifecycle.State`.
- `LifecycleEffects` that lets you run a block based on a specific `Lifecycle.Event`.

These integrations provide convenient hooks to manage Lifecycles within the
Compose hierarchy. This document outlines how you can use them in your app.
| **Note:** The APIs described in this document were introduced in Lifecycle version 2.7.0.

## Collect lifecycle state with flows

Lifecycle exposes a `currentStateFlow` property that provides the current
`Lifecycle.State` as a Kotlin `StateFlow`. You can collect this `Flow` as
`State`. This allows your app to read changes in the Lifecycle during
composition.  

    val lifecycleOwner = LocalLifecycleOwner.current
    val stateFlow = lifecycleOwner.lifecycle.currentStateFlow
    ...
    val currentLifecycleState by stateFlow.collectAsState()

The preceding example is accessible using the `lifecycle-common` module. The
`currentStateAsState()` method is available in the `lifecycle-runtime-compose`
module, which lets you conveniently read the current Lifecycle state with a
single line. The following example demonstrates this:  

    val lifecycleOwner = LocalLifecycleOwner.current
    val currentLifecycleState = lifecycleOwner.lifecycle.currentStateAsState()

## Run code on lifecycle events

There are also `LifecycleEffects` that let you run a block when a particular
`Lifecycle.Event` occurs.  

    LifecycleEventEffect(Lifecycle.Event.ON_START) {
      // do something here
    }

| **Warning:** You cannot use this to listen for `Lifecycle.Event.ON_DESTROY` since composition ends before this signal is sent.

In addition to the `LifecycleEventEffect`, you can also use
`LifecycleStartEffect` and `LifecycleResumeEffect`. These APIs are tied to
specific events. They also offer an additional block within their primary block
that helps clean up any code that the event might have kicked off.

### LifecycleStartEffect

The `LifecycleStartEffect` is similar to the `LifecycleEffect`, but it runs only
on `Lifecycle.Event.ON_START` events. It also accepts keys that work like other
Compose keys. When the key changes, it triggers the block to run again.

When there is a `Lifecycle.Event.ON_STOP` event or the effect exits composition,
it executes a `onStopOrDispose` block. This allows for the clean up of any work
that was part of the starting block.  

    LifecycleStartEffect {
      // ON_START code is executed here

      onStopOrDispose {
        // do any needed clean up here
      }
    }

| **Note:** The `onStopOrDispose` block is always required and if it is not needed, you should use the `LifecycleEffect`, passing in the `Lifecycle.Event.ON_START` event instead.

### LifecycleResumeEffect

The `LifecycleResumeEffect` works in the same way as the
`LifecycleStartedEffect`, but it executes on the `Lifecycle.Event.ON_RESUME`
event instead. It also provides an `onPauseOrDispose` block that performs the
clean up.  

    LifecycleResumeEffect {
      // ON_RESUME code is executed here

      onPauseOrDispose {
        // do any needed clean up here
      }
    }