IssueTracker

Background

The current Android architecture guidance recommends collecting flows in the UI in a lifecycle-aware manner. This allows the app to save expensive resources when not needed, for example, when the app is in the background.

Keeping expensive resources (e.g. Firabase queries, location or network updates, etc.) alive when not needed could impact the performance of the app and user's device.

To make it easier for developers to comply with the recommended best practices, APIs that do this should be added to the Lifecycle library.

Limitations with StateFlow

Ideally, there should exist APIs for both Flow and StateFlow types. The latter is important since most flows consumed in Compose code will be of that type. If a helper function for StateFlow doesn't exist, the UI (Compose code) would need to give those new functions an initial value (same as with Compose's produceState or Flow's stateIn operator). That violates layering responsibilities since deciding the initial value belongs to the ViewModel/state holder, not the UI.

However, as stated in the refdocs, the StateFlow interface is not stable for inheritance in 3rd party libraries, which makes it a tough call to create extensions functions on the type even though only the current value would be used.

Proposed implementation #1

The collectAsStateWithLifecycle composable function is added to a new lifecycle-runtime-compose artifact.

@Composable
fun <T> Flow<T>.collectAsStateWithLifecycle(
    initialValue: T,
    lifecycle: Lifecycle = LocalLifecycleOwner.current.lifecycle,
    minActiveState: Lifecycle.State = Lifecycle.State.STARTED
): State<T> {
    val currentValue = remember(this) { initialValue }
    return produceState(
        key1 = currentValue, key2 = lifecycle, key3 = minActiveState,
        initialValue = currentValue
    ) {
        lifecycle.repeatOnLifecycle(minActiveState) {
            this@collectAsStateWithLifecycle.collect {
                this@produceState.value = it
            }
        }
    }
}

Typically, this collectAsStateWithLifecycle API would be used like:

@Composable
fun MyScreen(
    viewModel: MyViewModel = viewModel()
) {
    val uiState by viewModel.uiState.collectAsStateWithLifecycle(viewModel.uiState.value)
}

Proposed implementation #2

To avoid passing the initialValue every time for StateFlow types, another alternative could be the rememberStateWithLifecycle API. This API would also be added to a new lifecycle-runtime-compose artifact.

@Composable
fun <T> rememberStateWithLifecycle(
    stateFlow: StateFlow<T>,
    lifecycle: Lifecycle = LocalLifecycleOwner.current.lifecycle,
    minActiveState: Lifecycle.State = Lifecycle.State.STARTED
): State<T> {
    val initialValue = remember(stateFlow) { stateFlow.value }
    return produceState(
        key1 = stateFlow, key2 = lifecycle, key3 = minActiveState,
        initialValue = initialValue
    ) {
        lifecycle.repeatOnLifecycle(minActiveState) {
            stateFlow.collect {
                this@produceState.value = it
            }
        }
    }
}

This would be used as follows:

@Composable
fun MyScreen(
    viewModel: MyViewModel = viewModel()
) {
    val uiState by rememberStateWithLifecycle(viewModel.uiState)
}

This API would also offer a method overload that can take a Flow and an initialValue as parameters.