ListView에서 스크롤 업 및 스크롤 다운 감지

ListView에서 스크롤 업 및 스크롤 다운 감지

---

다음 요구 사항이 있습니다.

• 처음에는 페이지 번호 2의 데이터를 서버에서 가져오고 항목은 ListView에 채워집니다.

시나리오에서 이전 페이지와 다음 페이지를 모두 사용할 수 있다는 점을 고려하여 다음 코드가 추가되었습니다.

 if(prevPageNo > 0){
    mListViewActual.setOnScrollListener(this);
 }

 if(nextPageNo > 0){
    mListViewActual.setOnScrollListener(this);
 }

다음 방법에서 스크롤 업 및 스크롤 다운을 감지하려면 어떤 조건을 설정해야합니까?

1. void onScroll (AbsListView view, int firstVisibleItem, int visibleItemCount, int totalItemCount)
2. void onScrollStateChanged (AbsListView view, int scrollState)

조치 후 : 스크롤 업 & 스크롤 다운이 감지되면, 이에 따라 서비스가 이전 페이지 번호 또는 다음 페이지 번호로 호출되어 Listview에 채워질 항목을 가져옵니다.

모든 입력이 도움이 될 것입니다.

다음 링크를 통해 이동했지만 올바른 스크롤 업 / 스크롤 동작을 반환하지 않습니다.

링크 1 링크 2

---

setOnScrollListener를 사용하고 scrollState로 onScrollStateChanged를 구현하십시오.

setOnScrollListener(new OnScrollListener(){
    public void onScroll(AbsListView view, int firstVisibleItem, int visibleItemCount, int totalItemCount) {
      // TODO Auto-generated method stub
    }
    public void onScrollStateChanged(AbsListView view, int scrollState) {
      // TODO Auto-generated method stub
      final ListView lw = getListView();

       if(scrollState == 0) 
      Log.i("a", "scrolling stopped...");


        if (view.getId() == lw.getId()) {
        final int currentFirstVisibleItem = lw.getFirstVisiblePosition();
         if (currentFirstVisibleItem > mLastFirstVisibleItem) {
            mIsScrollingUp = false;
            Log.i("a", "scrolling down...");
        } else if (currentFirstVisibleItem < mLastFirstVisibleItem) {
            mIsScrollingUp = true;
            Log.i("a", "scrolling up...");
        }

        mLastFirstVisibleItem = currentFirstVisibleItem;
    } 
    }
  });

---

다음은 위에 표시된 일부 솔루션에서 작동하는 수정 된 버전입니다.

다른 클래스 ListView를 추가하십시오.

package com.example.view;

import android.content.Context;
import android.util.AttributeSet;
import android.view.View;
import android.widget.AbsListView;

public class ListView extends android.widget.ListView {

    private OnScrollListener onScrollListener;
    private OnDetectScrollListener onDetectScrollListener;

    public ListView(Context context) {
        super(context);
        onCreate(context, null, null);
    }

    public ListView(Context context, AttributeSet attrs) {
        super(context, attrs);
        onCreate(context, attrs, null);
    }

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

    @SuppressWarnings("UnusedParameters")
    private void onCreate(Context context, AttributeSet attrs, Integer defStyle) {
        setListeners();
    }

    private void setListeners() {
        super.setOnScrollListener(new OnScrollListener() {

            private int oldTop;
            private int oldFirstVisibleItem;

            @Override
            public void onScrollStateChanged(AbsListView view, int scrollState) {
                if (onScrollListener != null) {
                    onScrollListener.onScrollStateChanged(view, scrollState);
                }
            }

            @Override
            public void onScroll(AbsListView view, int firstVisibleItem, int visibleItemCount, int totalItemCount) {
                if (onScrollListener != null) {
                    onScrollListener.onScroll(view, firstVisibleItem, visibleItemCount, totalItemCount);
                }

                if (onDetectScrollListener != null) {
                    onDetectedListScroll(view, firstVisibleItem);
                }
            }

            private void onDetectedListScroll(AbsListView absListView, int firstVisibleItem) {
                View view = absListView.getChildAt(0);
                int top = (view == null) ? 0 : view.getTop();

                if (firstVisibleItem == oldFirstVisibleItem) {
                    if (top > oldTop) {
                        onDetectScrollListener.onUpScrolling();
                    } else if (top < oldTop) {
                        onDetectScrollListener.onDownScrolling();
                    }
                } else {
                    if (firstVisibleItem < oldFirstVisibleItem) {
                        onDetectScrollListener.onUpScrolling();
                    } else {
                        onDetectScrollListener.onDownScrolling();
                    }
                }

                oldTop = top;
                oldFirstVisibleItem = firstVisibleItem;
            }
        });
    }

    @Override
    public void setOnScrollListener(OnScrollListener onScrollListener) {
        this.onScrollListener = onScrollListener;
    }

    public void setOnDetectScrollListener(OnDetectScrollListener onDetectScrollListener) {
        this.onDetectScrollListener = onDetectScrollListener;
    }
}

그리고 인터페이스 :

public interface OnDetectScrollListener {

    void onUpScrolling();

    void onDownScrolling();
}

마지막으로 사용 방법 :

com.example.view.ListView listView = (com.example.view.ListView) findViewById(R.id.list);
listView.setOnDetectScrollListener(new OnDetectScrollListener() {
    @Override
    public void onUpScrolling() {
        /* do something */
    }

    @Override
    public void onDownScrolling() {
        /* do something */
    }
});

XML 레이아웃에서 :

<com.example.view.ListView
    android:id="@+id/list"
    android:layout_width="match_parent"
    android:layout_height="match_parent"/>

이것은 나의 첫 번째 주제입니다. 나를 거칠게 판단하지 마십시오. =)

---

이것은 간단한 구현입니다.

lv.setOnScrollListener(new OnScrollListener() {
        private int mLastFirstVisibleItem;

        @Override
        public void onScrollStateChanged(AbsListView view, int scrollState) {

        }

        @Override
        public void onScroll(AbsListView view, int firstVisibleItem,
                int visibleItemCount, int totalItemCount) {

            if(mLastFirstVisibleItem<firstVisibleItem)
            {
                Log.i("SCROLLING DOWN","TRUE");
            }
            if(mLastFirstVisibleItem>firstVisibleItem)
            {
                Log.i("SCROLLING UP","TRUE");
            }
            mLastFirstVisibleItem=firstVisibleItem;

        }
    });

더 많은 정밀도가 필요한 경우 다음 사용자 지정 ListView 클래스를 사용할 수 있습니다.

import android.content.Context;
import android.util.AttributeSet;
import android.view.View;
import android.widget.AbsListView;
import android.widget.ListView;

/**
 * Created by root on 26/05/15.
 */
public class ScrollInterfacedListView extends ListView {


    private OnScrollListener onScrollListener;
    private OnDetectScrollListener onDetectScrollListener;

    public ScrollInterfacedListView(Context context) {
        super(context);
        onCreate(context, null, null);
    }

    public ScrollInterfacedListView(Context context, AttributeSet attrs) {
        super(context, attrs);
        onCreate(context, attrs, null);
    }

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

    @SuppressWarnings("UnusedParameters")
    private void onCreate(Context context, AttributeSet attrs, Integer defStyle) {
        setListeners();
    }

    private void setListeners() {
        super.setOnScrollListener(new OnScrollListener() {

            private int oldTop;
            private int oldFirstVisibleItem;

            @Override
            public void onScrollStateChanged(AbsListView view, int scrollState) {
                if (onScrollListener != null) {
                    onScrollListener.onScrollStateChanged(view, scrollState);
                }
            }

            @Override
            public void onScroll(AbsListView view, int firstVisibleItem, int visibleItemCount, int totalItemCount) {
                if (onScrollListener != null) {
                    onScrollListener.onScroll(view, firstVisibleItem, visibleItemCount, totalItemCount);
                }

                if (onDetectScrollListener != null) {
                    onDetectedListScroll(view, firstVisibleItem);
                }
            }

            private void onDetectedListScroll(AbsListView absListView, int firstVisibleItem) {
                View view = absListView.getChildAt(0);
                int top = (view == null) ? 0 : view.getTop();

                if (firstVisibleItem == oldFirstVisibleItem) {
                    if (top > oldTop) {
                        onDetectScrollListener.onUpScrolling();
                    } else if (top < oldTop) {
                        onDetectScrollListener.onDownScrolling();
                    }
                } else {
                    if (firstVisibleItem < oldFirstVisibleItem) {
                        onDetectScrollListener.onUpScrolling();
                    } else {
                        onDetectScrollListener.onDownScrolling();
                    }
                }

                oldTop = top;
                oldFirstVisibleItem = firstVisibleItem;
            }
        });
    }

    @Override
    public void setOnScrollListener(OnScrollListener onScrollListener) {
        this.onScrollListener = onScrollListener;
    }

    public void setOnDetectScrollListener(OnDetectScrollListener onDetectScrollListener) {
        this.onDetectScrollListener = onDetectScrollListener;
    }


    public interface OnDetectScrollListener {

        void onUpScrolling();

        void onDownScrolling();
    }

}

사용 예 : (layout.xml에 Xml 태그로 추가하는 것을 잊지 마십시오)

scrollInterfacedListView.setOnDetectScrollListener(new ScrollInterfacedListView.OnDetectScrollListener() {
            @Override
            public void onUpScrolling() {
               //Do your thing
            }

            @Override
            public void onDownScrolling() {

             //Do your thing
            }
        });

---

            ListView listView = getListView();
            listView.setOnScrollListener(new OnScrollListener() {

                @Override
                public void onScrollStateChanged(AbsListView view, int scrollState) {

                    view.setOnTouchListener(new OnTouchListener() {
                        private float mInitialX;
                        private float mInitialY;

                        @Override
                        public boolean onTouch(View v, MotionEvent event) {
                            switch (event.getAction()) {
                                case MotionEvent.ACTION_DOWN:
                                    mInitialX = event.getX();
                                    mInitialY = event.getY();
                                    return true;
                                case MotionEvent.ACTION_MOVE:
                                    final float x = event.getX();
                                    final float y = event.getY();
                                    final float yDiff = y - mInitialY;
                                    if (yDiff > 0.0) {
                                        Log.d(tag, "SCROLL DOWN");
                                        scrollDown = true;
                                        break;

                                    } else if (yDiff < 0.0) {
                                        Log.d(tag, "SCROLL up");
                                        scrollDown = true;
                                        break;

                                    }
                                    break;
                            }
                            return false;
                        }
                    });

---

모든 메소드가 게시되면 사용자가 첫 번째 요소에서 위로 스크롤하거나 마지막 요소에서 아래로 스크롤 할 때 인식하는 데 문제가 있습니다. 스크롤 업 / 다운을 감지하는 또 다른 방법은 다음과 같습니다.

        listView.setOnTouchListener(new View.OnTouchListener() {
            float height;
            @Override
            public boolean onTouch(View v, MotionEvent event) {
                int action = event.getAction();
                float height = event.getY();
                if(action == MotionEvent.ACTION_DOWN){
                    this.height = height;
                }else if(action == MotionEvent.ACTION_UP){
                    if(this.height < height){
                        Log.v(TAG, "Scrolled up");
                    }else if(this.height > height){
                        Log.v(TAG, "Scrolled down");
                    }
                }
                return false;
            }
        });

---

내 솔루션은 각 스크롤 방향에 대한 정확한 값을 완벽하게 제공합니다. distanceFromFirstCellToTop첫 번째 셀에서 상위 뷰 상단까지의 정확한 거리를 포함합니다. 이 값을 저장 previousDistanceFromFirstCellToTop하고 스크롤 할 때 새 값과 비교합니다. 더 낮 으면 위로 스크롤하고 그렇지 않으면 아래로 스크롤했습니다.

private int previousDistanceFromFirstCellToTop;

listview.setOnScrollListener(new OnScrollListener() {

    @Override
    public void onScrollStateChanged(AbsListView view, int scrollState) {

    }

    @Override
    public void onScroll(AbsListView view, int firstVisibleItem, int visibleItemCount, int totalItemCount) {
        View firstCell = listview.getChildAt(0);
        int distanceFromFirstCellToTop = listview.getFirstVisiblePosition() * firstCell.getHeight() - firstCell.getTop();

        if(distanceFromFirstCellToTop < previousDistanceFromFirstCellToTop)
        {
           //Scroll Up
        }
        else if(distanceFromFirstCellToTop  > previousDistanceFromFirstCellToTop)
        {
           //Scroll Down
        }
        previousDistanceFromFirstCellToTop = distanceFromFirstCellToTop;
    }
});

Xamarin 개발자의 경우 솔루션은 다음과 같습니다.

참고 : UI 스레드에서 실행하는 것을 잊지 마십시오.

listView.Scroll += (o, e) =>
{
    View firstCell = listView.GetChildAt(0);
    int distanceFromFirstCellToTop = listView.FirstVisiblePosition * firstCell.Height - firstCell.Top;

    if (distanceFromFirstCellToTop < previousDistanceFromFirstCellToTop)
    {
        //Scroll Up
    }
    else if (distanceFromFirstCellToTop > previousDistanceFromFirstCellToTop)
    {
        //Scroll Down
    }
    previousDistanceFromFirstCellToTop = distanceFromFirstCellToTop;
};

---

이 훨씬 간단한 솔루션을 사용했습니다.

setOnScrollListener( new OnScrollListener() 
{

    private int mInitialScroll = 0;

    @Override
    public void onScroll(AbsListView view, int firstVisibleItem,
            int visibleItemCount, int totalItemCount) 
    {
        int scrolledOffset = computeVerticalScrollOffset();

        boolean scrollUp = scrolledOffset > mInitialScroll;
        mInitialScroll = scrolledOffset;
    }


    @Override
    public void onScrollStateChanged(AbsListView view, int scrollState) {


    }

}

---

더 큰 요소로 스크롤을 감지하려면 onTouch Listener를 선호합니다.

listview.setOnTouchListener(new View.OnTouchListener() {

        int scrollEventListSize = 5; 
        float lastY;
        // Used to correct for occasions when user scrolls down(/up) but the onTouchListener detects it incorrectly. We will store detected up-/down-scrolls with -1/1 in this list and evaluate later which occured more often
        List<Integer> downScrolledEventsHappened;

        @Override
        public boolean onTouch(View v, MotionEvent event) {

            float diff = 0;
            if(event.getAction() == event.ACTION_DOWN){
                lastY = event.getY();
                downScrolledEventsHappened = new LinkedList<Integer>();
            }
            else if(event.getAction() == event.ACTION_MOVE){
                diff = event.getY() - lastY;
                lastY = event.getY();

                if(diff>0)
                    downScrolledEventsHappened.add(1);
                else 
                    downScrolledEventsHappened.add(-1);

               //List needs to be filled with some events, will happen very quickly
                if(downScrolledEventsHappened.size() == scrollEventListSize+1){
                    downScrolledEventsHappened.remove(0);
                    int res=0;
                    for(int i=0; i<downScrolledEventsHappened.size(); i++){
                        res+=downScrolledEventsHappened.get(i);
                    }

                    if (res > 0) 
                        Log.i("INFO", "Scrolled up");
                    else 
                        Log.i("INFO", "Scrolled down");
                }
            }
            return false; // don't interrupt the event-chain
        }
    });

---

firstVisibleItem을 저장하고 다음 onScroll에서 새 firstVisibleItem이 이전 항목보다 작거나 큰지 확인합니다.

의사 코드 예 (테스트되지 않음) :

int lastVisibleItem = 0;
boolean isScrollingDown = false;

void onScroll(AbsListView view, int firstVisibleItem, int visibleItemCount, int totalItemCount) {
    if (firstVisibleItem > lastVisibleItem) {
        isScrollingDown = true;
    }
    else {
        isScrollingDown = false;
    }
    lastVisibleItem = firstVisibleItem;
}

---

목록보기에 스크롤 리스너를 설정하십시오.

머리글 또는 바닥 글이있는 경우 보이는 개수도 확인해야합니다. 증가하면 아래로 스크롤한다는 의미입니다. (머리글 대신 바닥 글이 있으면 반대로)

목록보기에 머리글이나 바닥 글이 없으면 보이는 항목 수를 확인하는 줄을 제거 할 수 있습니다.

listView.setOnScrollListener(new AbsListView.OnScrollListener() {
        public void onScroll(AbsListView view, int firstVisibleItem, int visibleItemCount, int totalItemCount) {
            if (mLastFirstVisibleItem > firstVisibleItem) {
                Log.e(getClass().toString(), "scrolling up");
            } else if (mLastFirstVisibleItem < firstVisibleItem) {
                Log.e(getClass().toString(), "scrolling down");
            } else if (mLastVisibleItemCount < visibleItemCount) {
                Log.e(getClass().toString(), "scrolling down");
            } else if (mLastVisibleItemCount > visibleItemCount) {
                Log.e(getClass().toString(), "scrolling up");
            }
            mLastFirstVisibleItem = firstVisibleItem;
            mLastVisibleItemCount = visibleItemCount;
        }

        public void onScrollStateChanged(AbsListView listView, int scrollState) {
        }
    });

이 변수를

int mLastFirstVisibleItem;
int mLastVisibleItemCount;

---

어떤 이유로 Android 문서는 이것을 다루지 않으며 사용 된 방법은 문서에서도 사용되지 않습니다 ... 찾는 데 시간이 걸렸습니다.

스크롤이 맨 위에 있는지 감지하려면 이것을 사용합니다.

public boolean checkAtTop() 
{
    if(listView.getChildCount() == 0) return true;
    return listView.getChildAt(0).getTop() == 0;
}

스크롤러가 맨 위에 있는지 확인합니다. 이제 바닥을 위해 그것을하기 위해, 당신은 당신이 가지고있는 자녀의 수를 전달하고 그 수와 비교해야합니다. 한 번에 화면에 몇 명인지 파악하고 자녀 수에서 빼야 할 수도 있습니다. 나는 그렇게 할 필요가 없었습니다. 도움이 되었기를 바랍니다

---

이러한 방법은 스크롤 방향을 직접 감지하는 데 사용할 수 없습니다. 방향을 잡는 방법에는 여러 가지가 있습니다. 이러한 방법 중 하나에 대한 간단한 코드 (예상되지 않음)가 아래에 설명되어 있습니다.

공용 클래스 ScrollTrackingListView extends ListView {

    private 부울 readyForMeasurement = false;
    private 부울 isScrollable = null;
    개인 부동 소수점 prevDistanceToEnd = -1.0;
    개인 ScrollDirectionListener 리스너 = null;

    public ScrollTrackingListView (Context context) {
        슈퍼 (문맥);
        init ();
    }

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

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

    private void init () {
        ViewTreeObserver 관찰자 = getViewTreeObserver ();
        관찰자 .addOnGlobalLayoutListener (globalLayoutListener);
        setOnScrollListener (scrollListener);
    }

    private ViewTreeObserver.OnGlobalLayoutListener globalLayoutListener
            = new ViewTreeObserver.OnGlobalLayoutListener () {

        @우세하다
        public void onGlobalLayout () {
            readyForMeasurement = true;
            calculateDistanceToEnd ();
        }

    };

    public void registerScrollDirectionListener (ScrollDirectionListener listener) {
        scrollDirectionListener = 리스너;
    }

    public void unregisterScrollDirectionListener () {
        scrollDirectionListener = null;
    }

    private OnScrollListener scrollListener
            = new OnScrollListener () {

        @우세하다
        public void onScrollStateChanged (AbsListView absListView, int i) {
            calculateDistanceToEnd ();
        }

        @우세하다
        public void onScroll (AbsListView absListView, int i, int i1, int i2) {
            // 아무것도하지 마세요
        }

    };

    private void calculateDistanceToEnd () {

        if (readyForMeasurement) {

            // 레이아웃의 높이, 가로 스크롤바 및
            // 스크롤 다운 오프셋과 함께 콘텐츠

            // computeVerticalScrollExtent는 스크롤바 트랙 내의 썸 길이를 계산하는 데 사용됩니다.
            // 엄지 손가락의 길이는 뷰 높이와 콘텐츠 길이의 함수입니다.
            int verticalScrollExtent = computeVerticalScrollExtent ();
            int verticalScrollOffset = computeVerticalScrollOffset ();
            int verticalScrollRange = computeVerticalScrollRange ();
            int horizontalScrollBarHeight = getHorizontalScrollbarHeight ();

            / **
             * 1. "R"은 수직 스크롤바의 범위를 나타냅니다. 콘텐츠의 길이에 해당합니다.
             *보기에서.
             * 2. "E"는 수직 스크롤바의 범위를 나타냅니다. 범위는 상수 값이며
             * (아마도) 뷰의 높이에 비례하는 값과 같습니다.
             * 3. 오프셋 "o"는 사용자가 볼 수있는 범위의 현재 위치를 나타냅니다. 걸릴 수 있습니다
             * "0에서 E"까지의 값.
             *
             * 이제 DistanceToEnd는 다음과 같은 세 가지 값을 사용하여 계산됩니다.
             *
             * 끝까지 거리 = (R-o) / E
             *
             * DistanceToEnd는 NumberOfScreenToEnd 단위의 값을 유지합니다.
             *
             * /

            float distanceToEnd =
                    ((float) (verticalScrollRange-verticalScrollOffset)) / ((float) (verticalScrollExtent));

            if (prevDistanceToEnd == -1) {
                 prevDistanceToEnd = distanceToEnd;
            } else {
                 if (listener! = null) {
                     if (distanceToEnd> prevDistanceToEnd) {
                        // 사용자가 위로 스크롤
                         listener.onScrollingUp ();
                     } else {
                        // 사용자가 위로 스크롤
                         listener.onScrollingDown ();
                    }
                 }
                 prevDistanceToEnd = distanceToEnd;
            }

            if (isScrollable == null) {
                //보기 높이가 화면보다 작은 지 확인합니다 (즉, 스크롤이 활성화되지 않음).
                if ((horizontalScrollBarHeight + verticalScrollExtent)> = verticalScrollRange) {
                    isScrollable = Boolean.FALSE;
                } else {
                    isScrollable = Boolean.TRUE;
                }
            }

        }

    }

    공용 인터페이스 ScrollDirectionListener {

        public void onScrollingUp ();

        public void onScrollingDown ();

    }

}

아이디어는 distanceToEnd를 계산하는 것입니다. distanceToEnd가 증가하면 사용자가 위로 스크롤하고 감소하면 사용자가 아래로 스크롤합니다. 또한 목록 끝까지의 정확한 거리를 제공합니다.

사용자가 위아래로 스크롤하는지 확인하려는 경우 onInterceptTouchEvent 를 재정 의하여 아래와 같이 스크롤 방향을 감지 할 수 있습니다 .

    @우세하다
    public boolean onInterceptTouchEvent (MotionEvent event) {
        switch (event.getAction ()) {
            case MotionEvent.ACTION_DOWN :
                mInitialX = event.getX ();
                mInitialY = event.getY ();
                true를 반환하십시오.
            case MotionEvent.ACTION_MOVE :
                최종 부동 x = event.getX ();
                최종 플로트 y = event.getY ();
                최종 부동 소수점 yDiff = y-mInitialY; // yDiff가 0.0보다 작 으면 아래로 스크롤하는 것을 의미하고 yDiff가 0.0보다 큰 것은 위로 스크롤을 의미합니다. 보다 작거나 큰 기호를 추가하려고하면 미리보기에서 표시되지 않습니다.
                if (yDiff가 0.0보다 작음) listener.onScrollingDown ();
                else if (yDiff가 0.0보다 큼) listener.onScrollingUp ();
                단절;
        }
        return super.onInterceptTouchEvent (event);
    }

---

ListView에서 스크롤을 위아래로 감지하는 트릭은 ListView의 OnScrollListener에있는 onScroll 함수에서이 함수를 호출하기 만하면됩니다.

private int oldFirstVisibleItem = -1;
    private protected int oldTop = -1;
    // you can change this value (pixel)
    private static final int MAX_SCROLL_DIFF = 5;

    private void calculateListScroll(AbsListView view, int firstVisibleItem, int visibleItemCount, int totalItemCount) {
        if (firstVisibleItem == oldFirstVisibleItem) {
            int top = view.getChildAt(0).getTop();
            // range between new top and old top must greater than MAX_SCROLL_DIFF
            if (top > oldTop && Math.abs(top - oldTop) > MAX_SCROLL_DIFF) {
                // scroll up
            } else if (top < oldTop && Math.abs(top - oldTop) > MAX_SCROLL_DIFF) {
                // scroll down
            }
            oldTop = top;
        } else {
            View child = view.getChildAt(0);
            if (child != null) {
                oldFirstVisibleItem = firstVisibleItem;
                oldTop = child.getTop();
            }
        }
    }

---

Simple way to detect scroll up/down on android listview

@Override
public void onScroll(AbsListView view, int firstVisibleItem, int visibleItemCount, int totalItemCount){
  if(prevVisibleItem != firstVisibleItem){
    if(prevVisibleItem < firstVisibleItem)
      //ScrollDown
    else
      //ScrollUp

  prevVisibleItem = firstVisibleItem;
}

dont forget

yourListView.setOnScrollListener(yourScrollListener);

---

Here's what I would try first:

1) Create an interface (let's call it OnScrollTopOrBottomListener) with these methods:

void onScrollTop();

void onScrollBottom();

2) In your list's adapter, add a member instance, typed as the interface you created and supply a setter and getter.

3) In the getView() implementation of your adapter, check if the position parameter is either 0 or getCount() - 1. Also check that your OnScrollTopOrBottomListener instance is not null.

4) If the position is 0, call onScrollTopOrBottomListener.onScrollTop(). If position is getCount() - 1, call onScrollTopOrBottomListener.onScrollBottom().

5) In your OnScrollTopOrBottomListener implementation, call the appropriate methods to get the desired data.

Hope that helps in some way.

-Brandon

---

I have encountered problems using some example where the cell size of ListView is great. So I have found a solution to my problem which detects the slightest movement of your finger . I've simplified to the minimum possible and is as follows:

private int oldScrolly;


@Override
public void onScrollStateChanged(AbsListView view, int scrollState) {

}

@Override
public void onScroll(AbsListView view, int firstVisibleItem, int    visibleItemCount, int totalItemCount) {

            View view = absListView.getChildAt(0);
            int scrolly = (view == null) ? 0 : -view.getTop() + absListView.getFirstVisiblePosition() * view.getHeight();
            int margin = 10;

            Log.e(TAG, "Scroll y: " + scrolly + " - Item: " + firstVisibleItem);


            if (scrolly > oldScrolly + margin) {
                Log.d(TAG, "SCROLL_UP");
                oldScrolly = scrolly;
            } else if (scrolly < oldScrolly - margin) {
                Log.d(TAG, "SCROLL_DOWN");
                oldScrolly = scrolly;
            }
        }
    });

PD: I use the MARGIN to not detect the scroll until you meet that margin . This avoids problems when I show or hide views and avoid blinking of them.

참고URL : https://stackoverflow.com/questions/16791100/detect-scroll-up-scroll-down-in-listview