RecyclerView.Adapter.notifyItemMoved(0,1) scrolls screen

Question

I have a RecyclerView managed by a LinearlayoutManager, if I swap item 1 with 0 and then call mAdapter.notifyItemMoved(0,1), the moving animation causes the screen to scroll. How can I prevent it?

Answer 1

Sadly the workaround presented by yigit scrolls the RecyclerView to the top. This is the best workaround I found till now:

// figure out the position of the first visible item
int firstPos = manager.findFirstCompletelyVisibleItemPosition();
int offsetTop = 0;
if(firstPos >= 0) {
    View firstView = manager.findViewByPosition(firstPos);
    offsetTop = manager.getDecoratedTop(firstView) - manager.getTopDecorationHeight(firstView);
}

// apply changes
adapter.notify...

// reapply the saved position
if(firstPos >= 0) {
    manager.scrollToPositionWithOffset(firstPos, offsetTop);
}

Answer 2

Call scrollToPosition(0) after moving items. Unfortunately, i assume, LinearLayoutManager tries to keep first item stable, which moves so it moves the list with it.

Answer 3

Translate @Andreas Wenger's answer to kotlin:

val firstPos = manager.findFirstCompletelyVisibleItemPosition()
var offsetTop = 0
if (firstPos >= 0) {
    val firstView = manager.findViewByPosition(firstPos)!!
    offsetTop = manager.getDecoratedTop(firstView) - manager.getTopDecorationHeight(firstView)
}

// apply changes
adapter.notify...

if (firstPos >= 0) {
    manager.scrollToPositionWithOffset(firstPos, offsetTop)
}

In my case, the view can have a top margin, which also needs to be counted in the offset, otherwise the recyclerview will not scroll to the intended position. To do so, just write:

val topMargin = (firstView.layoutParams as? MarginLayoutParams)?.topMargin ?: 0
offsetTop = manager.getDecoratedTop(firstView) - manager.getTopDecorationHeight(firstView) - topMargin

Even easier if you have ktx dependency in your project:

offsetTop = manager.getDecoratedTop(firstView) - manager.getTopDecorationHeight(firstView) - firstView.marginTop

Answer 4

I've faced the same problem. Nothing of the suggested helped. Each solution fix and breakes different cases. But this workaround worked for me:

    adapter.registerAdapterDataObserver(object: RecyclerView.AdapterDataObserver() {
        override fun onItemRangeMoved(fromPosition: Int, toPosition: Int, itemCount: Int) {
            if (fromPosition == 0 || toPosition == 0)
                binding.recycler.scrollToPosition(0)
        }
    })

It helps to prevent scrolling while moving the first item for cases: direct notifyItemMoved and via ItemTouchHelper (drag and drop)

Answer 5

I have faced the same problem. In my case, the scroll happens on the first visible item (not only on the first item in the dataset). And I would like to thanks everybody because their answers help me to solve this problem. I inspire my solution based on Andreas Wenger' answer and from resoluti0n' answer

And, here is my solution (in Kotlin):

RecyclerViewOnDragFistItemScrollSuppressor.kt

class RecyclerViewOnDragFistItemScrollSuppressor private constructor(
    lifecycleOwner: LifecycleOwner,
    private val recyclerView: RecyclerView
) : LifecycleObserver {

    private val adapterDataObserver = object : RecyclerView.AdapterDataObserver() {
        override fun onItemRangeMoved(fromPosition: Int, toPosition: Int, itemCount: Int) {
            suppressScrollIfNeeded(fromPosition, toPosition)
        }
    }

    init {
        lifecycleOwner.lifecycle.addObserver(this)
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    fun registerAdapterDataObserver() {
        recyclerView.adapter?.registerAdapterDataObserver(adapterDataObserver) ?: return
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    fun unregisterAdapterDataObserver() {
        recyclerView.adapter?.unregisterAdapterDataObserver(adapterDataObserver) ?: return
    }

    private fun suppressScrollIfNeeded(fromPosition: Int, toPosition: Int) {
        (recyclerView.layoutManager as LinearLayoutManager).apply {
            var scrollPosition = -1

            if (isFirstVisibleItem(fromPosition)) {
                scrollPosition = fromPosition
            } else if (isFirstVisibleItem(toPosition)) {
                scrollPosition = toPosition
            }

            if (scrollPosition == -1) return

            scrollToPositionWithCalculatedOffset(scrollPosition)
        }
    }

    companion object {
        fun observe(
            lifecycleOwner: LifecycleOwner,
            recyclerView: RecyclerView
        ): RecyclerViewOnDragFistItemScrollSuppressor {
            return RecyclerViewOnDragFistItemScrollSuppressor(lifecycleOwner, recyclerView)
        }
    }
}

private fun LinearLayoutManager.isFirstVisibleItem(position: Int): Boolean {
    apply {
        return position == findFirstVisibleItemPosition()
    }
}

private fun LinearLayoutManager.scrollToPositionWithCalculatedOffset(position: Int) {
    apply {
        val offset = findViewByPosition(position)?.let {
            getDecoratedTop(it) - getTopDecorationHeight(it)
        } ?: 0

        scrollToPositionWithOffset(position, offset)
    }
}

and then, you may use it as (e.g. fragment):

RecyclerViewOnDragFistItemScrollSuppressor.observe(
            viewLifecycleOwner,
            binding.recyclerView
        )

Answer 6

LinearLayoutManager has done this for you in LinearLayoutManager.prepareForDrop.

All you need to provide is the moving (old) View and the target (new) View.

layoutManager.prepareForDrop(oldView, targetView, -1, -1)
// the numbers, x and y don't matter to LinearLayoutManager's implementation of prepareForDrop

It's an "unofficial" API because it states in the source

// This method is only intended to be called (and should only ever be called) by
// ItemTouchHelper.
public void prepareForDrop(@NonNull View view, @NonNull View target, int x, int y) {
    ...
}

But it still works and does exactly what the other answers say, doing all the offset calculations accounting for layout direction for you.

This is actually the same method that is called by LinearLayoutManager when used by an ItemTouchHelper to account for this dreadful bug.