Can I have onScrollListener for a ScrollView?

Question

I am using a HorizontalScrollView in a layout and I need to identify the user have reached the start and end point of the scroll.

For ListView I have tried a the onScrollListener and it is possible to find the start and end point of scroll.

I tried to do the same in my Scrollview but it seems not possible. Is there any other possible ways to achieve what I need.

It is possible. See user2695685's answer. In short the following in `onStart` will do the trick: `hsv.getViewTreeObserver().addOnScrollChangedListener(new ViewTreeObserver.OnScrollChangedListener() {@Override public void onScrollChanged() {Log.i(TAG,"scroll:"+hsv.getScrollX());}});` in onStart() where `hsv` is a `HorizontalScrollView` works. — JohnnyLambada, Jun 19 '14 at 22:02
Why is detecting a scroll event with a ScrollView so difficult in Android? This is nuts imo. — worked, Sep 28 '15 at 01:26

score 420 · Accepted Answer · edited Sep 16 '16 at 06:48

420

Every instance of View calls getViewTreeObserver(). Now when holding an instance of ViewTreeObserver, you can add an OnScrollChangedListener() to it using the method addOnScrollChangedListener().

You can see more information about this class here.

It lets you be aware of every scrolling event - but without the coordinates. You can get them by using getScrollY() or getScrollX() from within the listener though.

scrollView.getViewTreeObserver().addOnScrollChangedListener(new OnScrollChangedListener() {
    @Override
    public void onScrollChanged() {
        int scrollY = rootScrollView.getScrollY(); // For ScrollView
        int scrollX = rootScrollView.getScrollX(); // For HorizontalScrollView
        // DO SOMETHING WITH THE SCROLL COORDINATES
    }
});

edited Sep 16 '16 at 06:48

Pavneet_Singh

36,884
5
53
68

answered Apr 29 '14 at 13:06

Zbun

4,875
4
19
28

7

This answer should be marked correct. `hsv.getViewTreeObserver().addOnScrollChangedListener(new ViewTreeObserver.OnScrollChangedListener() {@Override public void onScrollChanged() {Log.i(TAG,"scroll:"+hsv.getScrollX());}});` in onStart() where `hsv` is a `HorizontalScrollView` works. I suspect the same will work for a ScrollView as well. – JohnnyLambada Jun 19 '14 at 22:00
3

exactly. this is the best answer. no need to extend HorizontalScrollView. Just tested with a ScrollView, works great: final ScrollView sv = (ScrollView) findViewById(R.id.scrollViewArticle); sv.getViewTreeObserver().addOnScrollChangedListener(new ViewTreeObserver.OnScrollChangedListener() { @Override public void onScrollChanged() { Log.d("onScrollChanged Y", String.valueOf(sv.getScrollY())); } }); – Raphael C Jul 10 '14 at 14:04
5

You should first check [ViewTreeObserver.isAlive()](http://developer.android.com/reference/android/view/ViewTreeObserver.html#isAlive()) – M.Salomaa Feb 06 '15 at 07:57
This works but might introduce a lag between the scroll and the callback being called, yielding a weird visual effect. I had to extend ScrollView anyway! – Takhion Jun 18 '15 at 16:06
8

The sample code in the answer introduces a memory leak. Since the method is `add` and not `set`, all listeners will be retained until explicitly removed. So the anonymous class used as a listener implementation in the sample will leak (along with anything it is referencing, i.e. the outer class). – Brett Duncavage Aug 31 '15 at 21:08
7

Probably a dumb question, but what is rootScrollView? – Iqbal Feb 13 '16 at 09:53
I get scrollView.getScrollY() value always 0. – Iqbal Feb 13 '16 at 10:02
1

this may lead memory leak, u should wrap rootScrollView with WeakReference – hoot Mar 13 '16 at 10:25
i was looking a lot for the right answer. 10x a lot. work like charm. – Tzahie Leibovich Apr 07 '16 at 08:17
I have to set a handler.postDelayed for most things that i want to do, inside onscrollChanged. http://stackoverflow.com/questions/17237287/how-can-i-wait-10-second-without-locking-ui-in-android – Alberto Perez Sep 03 '16 at 13:52
This causes a crash when I leave the fragment/activity, even if I check for isAlive() – Siavash Oct 05 '18 at 18:36

score 63 · Answer 2 · edited Nov 20 '17 at 07:42

63

This might be very useful. Use NestedScrollView instead of ScrollView. Support Library 23.1 introduced an OnScrollChangeListener to NestedScrollView. So you can do something like this.

 myScrollView.setOnScrollChangeListener(new NestedScrollView.OnScrollChangeListener() {
        @Override
        public void onScrollChange(NestedScrollView v, int scrollX, int scrollY, int oldScrollX, int oldScrollY) {
            Log.d("ScrollView","scrollX_"+scrollX+"_scrollY_"+scrollY+"_oldScrollX_"+oldScrollX+"_oldScrollY_"+oldScrollY);
            //Do something
        }
    });

edited Nov 20 '17 at 07:42

Lavekush Agrawal

6,040
7
52
85

answered Oct 20 '15 at 07:52

Midhun Vijayakumar

2,927
2
19
23

2

Definitely easier than keeping track of whether you've added the listener before with getViewTreeObserver(). Thanks! – Anthony Mills Mar 22 '16 at 17:19
But how use NestedScrollView as horizontal scroll view? Cannt find any resource – GensaGames Mar 26 '16 at 10:41
What if I want to use horizontal scroll? – Nikita Axyonov Mar 20 '17 at 11:37
9

@dazed'n'confused `NestedScrollView` is part of the support library, its `setOnScrollChangeListener` method has no minimum version requirement. – Tom Sep 03 '18 at 03:08
5

Not to be confused with `View`'s `setOnScrollChangeListener` which requires API level 23 – Anders Ullnæss Feb 13 '19 at 10:59
WoW, this is really confusing, in Kotlin can't use lamda, you must specify the listener to be `NestedScrollView.OnScrollChangeListener`, like this: `nestedScrollView.setOnScrollChangeListener( NestedScrollView.OnScrollChangeListener { view, scrollX, scrollY, oldScrollX, oldScrollY -> // Your code }` – y.allam Mar 09 '20 at 12:11

score 21 · Answer 3 · edited Aug 06 '20 at 20:18

Here's a derived HorizontalScrollView I wrote to handle notifications about scrolling and scroll ending. It properly handles when a user has stopped actively scrolling and when it fully decelerates after a user lets go:

public class ObservableHorizontalScrollView extends HorizontalScrollView {
    public interface OnScrollListener {
        public void onScrollChanged(ObservableHorizontalScrollView scrollView, int x, int y, int oldX, int oldY);
        public void onEndScroll(ObservableHorizontalScrollView scrollView);
    }

    private boolean mIsScrolling;
    private boolean mIsTouching;
    private Runnable mScrollingRunnable;
    private OnScrollListener mOnScrollListener;

    public ObservableHorizontalScrollView(Context context) {
        this(context, null, 0);
    }

    public ObservableHorizontalScrollView(Context context, AttributeSet attrs) {
        this(context, attrs, 0);
    }

    public ObservableHorizontalScrollView(Context context, AttributeSet attrs, int defStyle) {
        super(context, attrs, defStyle);
    }

    @Override
    public boolean onTouchEvent(MotionEvent ev) {
        int action = ev.getAction();

        if (action == MotionEvent.ACTION_MOVE) {
            mIsTouching = true;
            mIsScrolling = true;
        } else if (action == MotionEvent.ACTION_UP || action == MotionEvent.ACTION_CANCEL) {
            if (mIsTouching && !mIsScrolling) {
                if (mOnScrollListener != null) {
                    mOnScrollListener.onEndScroll(this);
                }
            }

            mIsTouching = false;
        }

        return super.onTouchEvent(ev);
    }

    @Override
    protected void onScrollChanged(int x, int y, int oldX, int oldY) {
        super.onScrollChanged(x, y, oldX, oldY);

        if (Math.abs(oldX - x) > 0) {
            if (mScrollingRunnable != null) {
                removeCallbacks(mScrollingRunnable);
            }

            mScrollingRunnable = new Runnable() {
                public void run() {
                    if (mIsScrolling && !mIsTouching) {
                        if (mOnScrollListener != null) {
                            mOnScrollListener.onEndScroll(ObservableHorizontalScrollView.this);
                        }
                    }

                    mIsScrolling = false;
                    mScrollingRunnable = null;
                }
            };

            postDelayed(mScrollingRunnable, 200);
        }

        if (mOnScrollListener != null) {
            mOnScrollListener.onScrollChanged(this, x, y, oldX, oldY);
        }
    }

    public OnScrollListener getOnScrollListener() {
        return mOnScrollListener;
    }

    public void setOnScrollListener(OnScrollListener mOnEndScrollListener) {
        this.mOnScrollListener = mOnEndScrollListener;
    }

}

It seems like this is better than using ViewTreeObserver method. Just because when you have an activity where you have multiple fragments loaded (for example 3 fragments with sliding tabs) with ListViews and ScrollViews and you need to register events for specific view. Whereas if the ViewTreeObserver is registered it will fire events even if it isn't active view. — Torsten Ojaperv, Jan 07 '15 at 09:18
@ZaBlanc - Can you please tel me how to initialise this class and the listeners from my Activity, which holds the ScrollView? I have implemented it just fine, but the listeners won't return any values yet. — Edmond Tamas, Apr 21 '15 at 07:20

score 15 · Answer 4 · answered Jul 17 '18 at 15:37

15

You can use NestedScrollView instead of ScrollView. However, when using a Kotlin Lambda, it won't know you want NestedScrollView's setOnScrollChangeListener instead of the one at View (which is API level 23). You can fix this by specifying the first parameter as a NestedScrollView.

nestedScrollView.setOnScrollChangeListener { _: NestedScrollView, scrollX: Int, scrollY: Int, _: Int, _: Int ->
    Log.d("ScrollView", "Scrolled to $scrollX, $scrollY")
}

answered Jul 17 '18 at 15:37

Cristan

12,083
7
65
69

3

This should be the accepted answer because the method using a viewTreeObserver causes memory leaks and must be manually removed or else multiple scroll observers will be added. – Ray Li Jan 04 '19 at 18:04
1

I absolutely agree. Switching to `NestedScrollView` and setting its `OnScrollChangeListener` solved my problem. When I set `OnScrollChangedListener` on ScrollView's `ViewTreeObserver` than the listener was called multiple times for no reason. – Vít Kapitola May 19 '21 at 12:29

score 8 · Answer 5 · answered Oct 22 '20 at 23:25

Beside accepted answer, you need to hold a reference of listener and remove when you don't need it. Otherwise you will get a null pointer exception for your ScrollView and memory leak (mentioned in comments of accepted answer).

You can implement OnScrollChangedListener in your activity/fragment.
```
MyFragment : ViewTreeObserver.OnScrollChangedListener
```

Add it to scrollView when your view is ready.

scrollView.viewTreeObserver.addOnScrollChangedListener(this)

Remove listener when no longer need (ie. onPause())

scrollView.viewTreeObserver.removeOnScrollChangedListener(this)

score 6 · Answer 6 · edited Apr 18 '18 at 15:13

If you want to know the scroll position of a view, then you can use the following extension function on View class:

fun View?.onScroll(callback: (x: Int, y: Int) -> Unit) {
    var oldX = 0
    var oldY = 0
    this?.viewTreeObserver?.addOnScrollChangedListener {
        if (oldX != scrollX || oldY != scrollY) {
            callback(scrollX, scrollY)
            oldX = scrollX
            oldY = scrollY
        }
    }
}

Fattie · Answer 7 · 2022-06-20T12:22:32.643

2022 answer - it's now trivial:

ScrollView anyScrollView;
...

anyScrollView.setOnScrollChangeListener(new View.OnScrollChangeListener() {
    @Override
    public void onScrollChange(View view, int x, int y, int oldX, int oldY) {
        Log.d("yo", "it works " + y + " " + x);
    }
});

Don't forget in practice in Android you want to convert everything back and fore to dp:

public void onScrollChange(View view, int x, int y, int oldX, int oldY) {
    float ydp =
       y / getBaseContext().getResources().getDisplayMetrics().density;
    Log.d("yo", "it works " + ydp);
}

So to copy paste:

anyScrollView.setOnScrollChangeListener(new View.OnScrollChangeListener() {
    float dsy = getBaseContext().getResources().getDisplayMetrics().density;
    @Override
    public void onScrollChange(View view, int x, int y, int oldX, int oldY) {
        float ydp = y / dsy;
        Log.d("yo", "offset " + ydp);
    }
});

Doco:

https://developer.android.com/reference/android/view/View.OnScrollChangeListener

score 1 · Answer 8 · edited Apr 03 '20 at 08:47

you can define a custom ScrollView class, & add an interface be called when scrolling like this:

public class ScrollChangeListenerScrollView extends HorizontalScrollView {


private MyScrollListener mMyScrollListener;

public ScrollChangeListenerScrollView(Context context) {
    super(context);
}

public ScrollChangeListenerScrollView(Context context, AttributeSet attrs) {
    super(context, attrs);
}

public ScrollChangeListenerScrollView(Context context, AttributeSet attrs, int defStyleAttr) {
    super(context, attrs, defStyleAttr);
}


public void setOnMyScrollListener(MyScrollListener myScrollListener){
    this.mMyScrollListener = myScrollListener;
}


@Override
protected void onScrollChanged(int l, int t, int oldl, int oldt) {
    super.onScrollChanged(l, t, oldl, oldt);
    if(mMyScrollListener!=null){
        mMyScrollListener.onScrollChange(this,l,t,oldl,oldt);
    }

}

public interface MyScrollListener {
    void onScrollChange(View view,int scrollX,int scrollY,int oldScrollX, int oldScrollY);
}

}

score 0 · Answer 9 · answered Aug 28 '17 at 02:49

    // --------Start Scroll Bar Slide--------
    final HorizontalScrollView xHorizontalScrollViewHeader = (HorizontalScrollView) findViewById(R.id.HorizontalScrollViewHeader);
    final HorizontalScrollView xHorizontalScrollViewData = (HorizontalScrollView) findViewById(R.id.HorizontalScrollViewData);
    xHorizontalScrollViewData.getViewTreeObserver().addOnScrollChangedListener(new ViewTreeObserver.OnScrollChangedListener() {
        @Override
        public void onScrollChanged() {
            int scrollX; int scrollY;
            scrollX=xHorizontalScrollViewData.getScrollX();
            scrollY=xHorizontalScrollViewData.getScrollY();
            xHorizontalScrollViewHeader.scrollTo(scrollX, scrollY);
        }
    });
    // ---------End Scroll Bar Slide---------

please try to add some description to support you code which will make everyone understand batter — Aniruddha Das, Aug 28 '17 at 03:32
This code is very similar to another [answer](https://stackoverflow.com/a/23365539/5728095), isn't it? — Sergii, Aug 28 '17 at 03:32

score 0 · Answer 10 · answered Aug 03 '21 at 03:03

Kotlin users looking for a solution for a normal ScrollView implementation:

As an extension to this answer, I created a custom view that solved my problems very well.

The view (create a new Kotlin file, maintain your package reference on line 1):

import android.annotation.SuppressLint
import android.content.Context
import android.util.AttributeSet
import android.view.MotionEvent
import android.widget.ScrollView
import kotlin.math.abs


class ScrollViewWithEndFunc (
    context: Context?,
    attrs: AttributeSet?,
    defStyle: Int
) : ScrollView(context, attrs, defStyle) {

    constructor(context: Context?) : this(context, null, 0) {}
    constructor(context: Context?, attrs: AttributeSet?) : this(context, attrs, 0) {}

    interface OnScrollListener {
        fun onScrollChanged(scrollView: ScrollViewWithEndFunc?, x: Int, y: Int, oldX: Int, oldY: Int)
        fun onEndScroll(scrollView: ScrollViewWithEndFunc?)
    }

    private var isScrolling = false
    private var isTouching = false
    private var scrollingRunnable: Runnable? = null
    private var onScrollListener: OnScrollListener? = null

    fun setOnScrollListener(onScrollListener: OnScrollListener) {
        this.onScrollListener = onScrollListener
    }

    fun removeOnScrollListener() {
        this.onScrollListener = null
    }

    @SuppressLint("ClickableViewAccessibility")
    override fun onTouchEvent(ev: MotionEvent): Boolean {
        val action = ev.action
        if (action == MotionEvent.ACTION_MOVE) {
            isTouching = true; isScrolling = true
        } else if (action == MotionEvent.ACTION_UP || action == MotionEvent.ACTION_CANCEL) {
            if (isTouching && !isScrolling) {
                onScrollListener?.onEndScroll(this)
            }
            isTouching = false
        }
        return super.onTouchEvent(ev)
    }

    override fun onScrollChanged(x: Int, y: Int, oldX: Int, oldY: Int) {
        super.onScrollChanged(x, y, oldX, oldY)
        if (abs(oldY - y) > 0) {
            scrollingRunnable?.let { removeCallbacks(it) }
            scrollingRunnable = Runnable {
                if (isScrolling && !isTouching) {
                    onScrollListener?.onEndScroll(this@ScrollViewWithEndFunc)
                }
                isScrolling = false
                scrollingRunnable = null
            }
            postDelayed(scrollingRunnable, 200)
        }
        onScrollListener?.onScrollChanged(this, x, y, oldX, oldY)
     }
    }

XML view implementation:

<your.package.here.ScrollViewWithEndFunc
        android:id="@+id/scrollview_main_dashboard"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:fillViewport="true">

Activity/Fragment implementation:

scrollviewMainDashboard.setOnScrollListener(object : ScrollViewWithEndFunc.OnScrollListener {
            override fun onScrollChanged(scrollView: ScrollViewWithEndFunc?, x: Int, y: Int, oldX: Int, oldY: Int) { }
            override fun onEndScroll(scrollView: ScrollViewWithEndFunc?) {
                /* Scroll ended, handle here */
        })

Can I have onScrollListener for a ScrollView?

10 Answers10

2022 answer - it's now trivial:

Linked