IssueTracker

Yes, we basically just changed the default behavior for the empty case for now. Please track this bug b/179397301 for the following work in this space.

yes, it is expected as the paging is starting loading asynchronously and there is always at least one frame when there is no items yet

Where can I find the new bug? this issue affect me as well.

In my case .cachedIn(viewModelScope) preserves data from loading again, but scroll position is still resetting to the start every time I navigate to another composable and back. I use LazyColumn with header (item element before items), so that might be the case

Check if you have any other item in the LazyList outside the paged items it will lose position.

If you have any comment it out and see if it still lose position.

I have found a workaround that works for me.

The LazyPagingItems.kt file was copied from the androidx.paging:paging-compose artifact into my project (it doesn't have any other dependencies).

I modified it to add a flag inside the LazyPagingItems class:

    /**
     * The number of items which can be accessed.
     */
    val itemCount: Int get() = itemSnapshotList.size


    // The code below was added:

    /**
     * Added to fix scroll state restoration - wait for this flag to be set to true
     * before setting your [LazyListState] on the [LazyColumn].
     * 
     * @author Baptiste Candellier
     */
    var hasRestoredItems: Boolean = false
        private set

The flag is set inside the updateItemSnapshotList() method

    private fun updateItemSnapshotList() {
        itemSnapshotList = pagingDataDiffer.snapshot()

        // The code below was added:
        hasRestoredItems = true
    }

Then on my composable, I wait for this flag to become true to pass the "real" LazyListState, that comes from a ViewModel.

            LazyColumn(
                // Wait for the items to be restored to set the real list state, so that it isn't reset in the meantime
                state = if (lazyPagingItems.hasRestoredItems) lazyListState else LazyListState()
            ) {
                // ... your items here

There might be edge cases but it works for me, I hope it helps.

rememberLazyListState() is doing pretty much the same internally. Could you please elaborate a bit more on why the build in solution doesn't work for you?

Ouch! I'm new on Compose, so don't know how state, rememberLazyListState() works so i directly pass

fun ProfileTab() LazyVerticalGrid( state = rememberLazyListState(), ) }

and while i switch tab from 1->2 and back from 2-> the state of LazyVerticalGrid regenerated, but i didn't try to save in state on globally and pass in composable.

After i seeing this https://developer.android.com/jetpack/compose/state, i understand state and usage of state, and also found that i make mistake previously comment.

https://issuetracker.google.com/issues/177245496#comment20 its works and thank you for check my request and guiding me.

as a lot of people mentioned, LazyColumn can't restore position correct when Paging has a Header
this is because rememberLazyListState can restore position when there are at least 1 element in the list
but if there is a Header or Footer in LazyColumn, then it will restore in first frame when paging's item count is still 0

so I store listState in ViewModel and restore it when Paging item count > 0

val listState = if (pagingData.itemCount > 0) viewModel.listState else rememberLazyListState()

Try this workaround, you need to check lazyPagingItems before use:

    @Composable
    fun MainFrame(lazyPagingItems: LazyPagingItems<PerformanceEvent.Building>) {
        val refresh = lazyPagingItems.loadState.refresh

        // My temp solution
        if (lazyPagingItems.itemCount == 0 && refresh is LoadState.NotLoading ) return //skip dummy state, waiting next compose

        LazyColumn { ... }
     }

Here is a workaround:

@Composable
fun <T : Any> LazyPagingItems<T>.rememberLazyListState(): LazyListState {
    // After recreation, LazyPagingItems first return 0 items, then the cached items.
    // This behavior/issue is resetting the LazyListState scroll position.
    // Below is a workaround. More info: https://issuetracker.google.com/issues/177245496.
    return when (itemCount) {
        // Return a different LazyListState instance.
        0 -> remember(this) { LazyListState(0, 0) }
        // Return rememberLazyListState (normal case).
        else -> androidx.compose.foundation.lazy.rememberLazyListState()
    }
}

Should we still expect a fix from any Jetpack library ?