Подтвердить что ты не робот

Обнаружение прокрутки вверх и прокрутка вниз в ListView

У меня есть следующее требование:

  • Сначала данные для страницы no: 2 извлекаются с сервера, а элементы заполняются в ListView.

Учитывая, что как предыдущая страница, так и следующая страница доступны в сценарии, добавлен следующий код:

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

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

Какие условия следует установить для обнаружения прокрутки вверх и прокрутки вниз по следующим методам:

  • void onScroll (представление AbsListView, int firstVisibleItem, int visibleItemCount, int totalItemCount)
  • void onScrollStateChanged (просмотр AbsListView, int scrollState)

После того, как действие: прокрутка вверх и прокрутка вниз обнаружены, соответственно служба будет вызываться либо с предыдущей страницей, либо с следующей страницей нет, чтобы получить элементы, которые будут заполнены в Listview.

Любые входы будут полезны.

Прошли следующие ссылки, но не вернули правильное действие прокрутки вверх/прокрутки вниз:

ссылка 1 ссылка 2

4b9b3361

ОТВЕТЫ

Ответ 1

попробуйте использовать setOnScrollListener и реализуйте onScrollStateChanged с помощью scrollState

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;
    } 
    }
  });

Ответ 2

Ниже приведена рабочая измененная версия некоторых из вышеперечисленных решений.

Добавить другой класс 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"/>

Это моя первая тема, не судите меня сурово. =)

Ответ 3

это простая реализация:

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();
    }

}

пример использования: (не забудьте добавить его как Xml-тег в layout.xml)

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

            @Override
            public void onDownScrolling() {

             //Do your thing
            }
        });

Ответ 4

При размещении всего метода возникают проблемы с распознаванием, когда пользователь прокручивается от первого элемента или от последнего. Вот еще один способ обнаружения прокрутки вверх/вниз:

        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;
            }
        });

Ответ 5

            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;
                        }
                    });

Ответ 6

Мое решение отлично работает, давая точное значение для каждого направления прокрутки. 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 решение выглядит следующим образом:

Примечание. Не забудьте запустить в потоке пользовательского интерфейса.

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;
};

Ответ 7

Я использовал это гораздо более простое решение:

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) {


    }

}

Ответ 8

Просто установите прослушиватель прокрутки в список.

Если у вас есть верхний или нижний колонтитул, вы также должны проверить видимый счетчик. Если он увеличивается, это означает, что вы прокручиваете вниз. (Отмените его, если есть нижний колонтитул вместо заголовка)

Если у вас нет заголовка или нижнего колонтитула в списке, вы можете удалить строки, которые просматривают видимый элемент.

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;

Ответ 9

Чтобы также обнаружить прокрутку с большими элементами, я предпочитаю прослушиватель onTouch:

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
        }
    });

Ответ 10

Сохраните файл 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;
}

Ответ 11

Эти методы не могут использоваться для непосредственного определения направлений прокрутки. Есть много способов получить направление. Ниже приведен простой код (непроверенный) для одного такого метода:

public class ScrollTrackingListView extends ListView {

    private boolean readyForMeasurement = false;
    private Boolean isScrollable = null;
    private float prevDistanceToEnd = -1.0;
    private ScrollDirectionListener listener = null;

    public ScrollTrackingListView(Context context) {
        super(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 observer = getViewTreeObserver();
        observer.addOnGlobalLayoutListener(globalLayoutListener);
        setOnScrollListener(scrollListener);
    }

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

        @Override
        public void onGlobalLayout() {
            readyForMeasurement = true;
            calculateDistanceToEnd();
        }

    };

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

    public void unregisterScrollDirectionListener() {
        scrollDirectionListener = null;
    }

    private OnScrollListener scrollListener
            = new OnScrollListener() {

        @Override
        public void onScrollStateChanged(AbsListView absListView, int i) {
            calculateDistanceToEnd();
        }

        @Override
        public void onScroll(AbsListView absListView, int i, int i1, int i2) {
            // Do nothing
        }

    };

    private void calculateDistanceToEnd() {

        if (readyForMeasurement) {

            // I'm using the height of the layout, horizontal scrollbar and
            // content along with scroll down offset

            // computeVerticalScrollExtent is used to compute the length of the thumb within the scrollbar track.
            // The length of the thumb is a function of the view height and the content length.
            int verticalScrollExtent = computeVerticalScrollExtent();
            int verticalScrollOffset = computeVerticalScrollOffset();
            int verticalScrollRange = computeVerticalScrollRange();
            int horizontalScrollBarHeight = getHorizontalScrollbarHeight();

            /**
             * 1. Let "R" represent the range of the vertical scrollbar. This corresponds to the length of the content
             * in the view.
             * 2. Let "E" represent the extent of the vertical scrollbar. The extent is a constant value and is
             * (probably) equal to a value proportional to the height of the view.
             * 3. Offset "o" represents the current position in the range that is visible to the user. It can take
             * values from "0 to E".
             *
             * Now the DistanceToEnd is calculated using these three values as follows :
             *
             * DistanceToEnd = (R - o) / E
             *
             * DistanceToEnd will hold the value in NumberOfScreenToEnd units.
             *
             */

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

            if(prevDistanceToEnd == -1) {
                 prevDistanceToEnd = distanceToEnd;
            } else {
                 if(listener != null) {
                     if(distanceToEnd > prevDistanceToEnd) {
                        // User is scrolling up
                         listener.onScrollingUp();
                     } else {
                        // User is scrolling up
                         listener.onScrollingDown();
                    }
                 }
                 prevDistanceToEnd = distanceToEnd;
            }

            if(isScrollable == null) {
                // Check if the view height is less than a screen (i.e., no scrolling is enabled)
                if((horizontalScrollBarHeight + verticalScrollExtent) >= verticalScrollRange) {
                    isScrollable = Boolean.FALSE;
                } else {
                    isScrollable = Boolean.TRUE;
                }
            }

        }

    }

    public interface ScrollDirectionListener {

        public void onScrollingUp();

        public void onScrollingDown();

    }

}

Идея состоит в том, чтобы вычислить расстояние до точки. Если distanceToEnd увеличивается, пользователь прокручивается, и если он уменьшается, пользователь прокручивается вниз. Это также даст вам точное расстояние до конца списка.

Если вы просто пытаетесь узнать, прокручивается ли пользователь вверх или вниз, вы можете переопределить onInterceptTouchEvent, чтобы определить направление прокрутки, например ниже:

    @Override
    public boolean onInterceptTouchEvent(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; // yDiff less than 0.0 implies scrolling down while yDiff greater than 0.0 implies scrolling up. If I try to add the less than or greater than symbols, the preview refuses to display it.
                if(yDiff less than 0.0) listener.onScrollingDown();
                else if(yDiff greater than 0.0) listener.onScrollingUp();
                break;
        }
        return super.onInterceptTouchEvent(event);
    }

Ответ 12

Обманите прокрутку вверх или вниз в списке, вы просто вызываете эту функцию в функции onScroll в OnScrollListener ListView.

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();
            }
        }
    }

Ответ 13

Простой способ обнаружения прокрутки вверх/вниз по списку андроидов

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

  prevVisibleItem = firstVisibleItem;
}

Не забывайте

yourListView.setOnScrollListener(yourScrollListener);

Ответ 14

По какой-то причине Android-документ не охватывает это, и используемый метод даже не в документах... мне понадобилось некоторое время, чтобы его найти.

Чтобы определить, находится ли ваш свиток вверху, вы должны использовать это.

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

Это проверит, находится ли ваш скроллер вверху. Теперь, чтобы сделать это для дна, вам придется передать ему количество детей, которые у вас есть, и проверить это число. Возможно, вам придется выяснить, сколько из них на экране за один раз, и вычесть это из вашего числа детей. Мне никогда не приходилось это делать. Надеюсь, что это поможет

Ответ 15

Вот что я постараюсь первым:

1) Создайте интерфейс (позвоните ему OnScrollTopOrBottomListener) следующими способами:

void onScrollTop();

void onScrollBottom();

2) В своем адаптере списка добавьте экземпляр участника, набрав его как созданный интерфейс и поставьте сеттер и получатель.

3) В реализации вашего адаптера getView() проверьте, равен ли параметр позиции 0 или getCount() - 1. Также проверьте, что ваш экземпляр OnScrollTopOrBottomListener не является нулевым.

4) Если позиция равна 0, вызовите функциюScrollTopOrBottomListener.onScrollTop(). Если позиция getCount() - 1, вызовите onScrollTopOrBottomListener.onScrollBottom().

5) В своей реализации OnScrollTopOrBottomListener вызовите соответствующие методы для получения требуемых данных.

Надеюсь, что это поможет в некотором роде.

-Brandon

Ответ 16

У меня возникли проблемы с использованием некоторого примера, где размер ячейки ListView велик. Поэтому я нашел решение своей проблемы, которая обнаруживает малейшее движение пальца. Я упростил до минимума и следующим образом:

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: Я использую MARGIN, чтобы не обнаружить свиток, пока вы не встретите это поле. Это позволяет избежать проблем, когда я показываю или скрываю представления и не моргаю их.