Jetpack Compose: scrolling to the bottom of list on event-CodePudding

I have a composable representing list of results:

@Composable
fun ResultsList(results: List<Pair<Square, Boolean>>) {

    val coroutineScope = rememberCoroutineScope()
    val listState = rememberLazyListState()
    LazyRow(state = listState) {
        items(results) { result ->
            ResultsItem(result.first, result.second)
            coroutineScope.launch {
                listState.animateScrollToItem(results.size)
            }
        }
    }
}

Expected behaviour: The list smoothly scrolls to the last item whenever a new item is added

Actual behaviour: All is good, but whenever I manually scroll fast through the list, it is also automatically put on the bottom. Also, the scrolling is not smooth.

CodePudding user response：

Your code gives the following error:

Calls to launch should happen inside a LaunchedEffect and not composition

You should not ignore it by calling the side effect directly from the Composable function. See side effects documentation for more details.

You can use LaunchedEffect instead (as this error suggests). By providing results.size as a key, you guarantee that this will be called only once when your list size changes:

@Composable
fun ResultsList(results: List<Pair<Square, Boolean>>) {
    val listState = rememberLazyListState()
    LaunchedEffect(results.size) {
        listState.animateScrollToItem(results.size)
    }
    LazyRow(state = listState) {
        items(results) { result ->
            ResultsItem(result.first, result.second)
        }
    }
}

CodePudding user response：

Philip's solution will work for you. However, I'm posting this to ensure that you understand why

A.) The scroll was not smooth
B.) The list gets scrolled to the bottom when you scroll through it fast enough.

Explanation for A.) It is because you are using animateScollTo. I've experienced issues with this method if called too often,

Explanation for this lies in how Lazy scrollers handle their children internally. You see, Lazy scrollers, as you might know, are meant to display only a small window of a large dataset to the user. To achieve this, it uses internal caching. So, the items on the screen, AND a couple of items to the top and bottom of the current window are cached.

Now, since in your code, you are making a call to animateScrollTo(size) inside the Composable's body (the items scope), the code will essentially be executed upon every composition.

Hence, on every recomposition, there is an active clash between the animateScrollTo method, and the users touch input. When the user scrolls past in a not-so-fast manner, this is what happens - user presses down, gently scrolls, then lifts up the finger. Now, remember this, for as long as the finger is actually pressed down, they animateScrollTo will seem to have no effect (because the user is actively holding a position on the scroller, so it won't be scrolled past it by the system). Hence, while the user is scrolling, some items ahead of the list are cached, but the animateScrollTo does not work. Then, because the motion is slow enough, the distance the scroller travels because of inertia is not a problem, since the list already has enough cached items to show for the distance. That also explains the second problem.

B.)

When you are scrolling through the list FAST enough, the exact same thing as the above case (the slow-scroll) happens. Only, this time the inertia carries the list too forward for the scroller to be handled based on the internal cache, and hence there is active recomposition. However, now since there is no active user input (they have lifted their finger off the screen), it actually does animate to the bottom, since their is no clash here for the animateScrollTo method.

For as long as your finger is pressed, no matter how fast you scroll, it won't scroll to the bottom (test that!)

Now to the solution of the actual problem. Philip your answer is brilliant. The only thing is that it might not work if the developer has an item remove implementation as well. Since only the size of the list is monitored, it will scroll to end when an item is added OR deleted. To counteract that, we would actually need some sort of reference value. So, either you can implement something of your own to provide you with a Boolean variable that actually confirms whether an item has been ADDED, or you could just use something like this.

@Composable
fun ResultsList(results: List<Pair<Square, Boolean>>) {
    //Right here, create a variable to remember the current size
    val currentSize by rememberSaveable { mutableStateOf (results.size) }
   //Now, extract a Boolean to be used as a key for LaunchedEffect
    var isItemAdded by mutableStateO(results.size > currentSize)

    LaunchedEffect (isItemAdded){ //Won't be called upon item deletion
        if(isItemAdded){
           listState.animateScrollToItem(results.size)
           currentSize = results.size
        }
    }

    val listState = rememberLazyListState()
    LazyRow(state = listState) {
        items(results) { result ->
            ResultsItem(result.first, result.second)
        }
    }
}

This should ensure the proper behaviour. Of course, let me know if there is anything else, happy to help.

CodePudding user response：

Pretty obvious. Why are you calling:

listState.animateScrollToItem(results.size) inside your LazyList? Of course you're going to get extremely bad performance. You shouldn't be messing around with scrolling when items are being rendered. Get rid of this line of code.