Wykrywanie kierunku przewijania w adapterze (góra/dół)

Przypisz OnScrollListener do twojego ListView. Utwórz flagę, która wskazuje, czy użytkownik przewija w górę lub w dół. Ustaw odpowiednią wartość znacznika, sprawdzając, czy obecna pierwszawidoczna pozycja elementu jest równa mniej lub bardziej niż poprzednia pierwsza widoczna pozycja elementu. Włóż ten czek do środka onScrollStateChanged().

Przykładowy kod:

private int mLastFirstVisibleItem;
private boolean mIsScrollingUp;

public void onScrollStateChanged(AbsListView view, int scrollState) {
    final ListView lw = getListView();

    if (view.getId() == lw.getId()) {
        final int currentFirstVisibleItem = lw.getFirstVisiblePosition();

        if (currentFirstVisibleItem > mLastFirstVisibleItem) {
            mIsScrollingUp = false;
        } else if (currentFirstVisibleItem < mLastFirstVisibleItem) {
            mIsScrollingUp = true;
        }

        mLastFirstVisibleItem = currentFirstVisibleItem;
    } 
}

Sprawdź czy mIsScrollingUp jest prawdziwe czy fałszywe w getView() i odpowiednio Przypisz animacje.

Skończyłem robiąc to:

@Override
public View getView(int position, View convertView, ViewGroup parent) {
    Log.i("",position+" - "+lastposition);

    if (position >= lastposition)
        animation = new TranslateAnimation(Animation.RELATIVE_TO_SELF,
                0.0f, Animation.RELATIVE_TO_SELF, 0.0f,
                Animation.RELATIVE_TO_SELF, 1.0f,
                Animation.RELATIVE_TO_SELF, 0.0f);
    else
        animation = new TranslateAnimation(Animation.RELATIVE_TO_SELF,
                0.0f, Animation.RELATIVE_TO_SELF, 0.0f,
                Animation.RELATIVE_TO_SELF, -1.0f,
                Animation.RELATIVE_TO_SELF, 0.0f);

    animation.setDuration(600);
    set.addAnimation(animation);

    row.startAnimation(set);

    lastposition = position;

}

Bardziej złożone rozwiązanie (praca z wysokością długich elementów w listview)

1. Utwórz własny listview

   public class ScrollDetectingListView extends ListView {
       public ScrollDetectingListView(Context context) {
           super(context);
       }
   
       public ScrollDetectingListView(Context context, AttributeSet attrs) {
           super(context,attrs);
       } 
   
       public ScrollDetectingListView(Context context, AttributeSet attrs, int defStyle) {
           super(context, attrs, defStyle);
       }
   
       //we need this protected method for scroll detection
       public int getVerticalScrollOffset() {
           return computeVerticalScrollOffset();
       }
   }
   

2. Override onScroll

       listView.setOnScrollListener(new AbsListView.OnScrollListener() {
   
       private int mInitialScroll = 0;
   
       @Override
       public void onScrollStateChanged(AbsListView view, int scrollState) {
   
       }
   
       @Override
       public void onScroll(AbsListView view, int firstVisibleItem, int visibleItemCount, int totalItemCount) {
           int scrolledOffset = listView.getVerticalScrollOffset();
           if (scrolledOffset!=mInitialScroll) {
               //if scroll position changed
               boolean scrollUp = (scrolledOffset - mInitialScroll) < 0;
               mInitialScroll = scrolledOffset;
           }
       }
       });
   

Przyjęta odpowiedź tak naprawdę nie "wykrywa" przewijania w górę lub w dół. Nie będzie działać, jeśli obecny widoczny element jest naprawdę ogromny. Użycie onTouchListener jest najlepszym sposobem.

Oto fragment kodu, którego użyłem:

listView.setOnTouchListener(new View.OnTouchListener() {
    float initialY, finalY;
    boolean isScrollingUp;

    @Override
    public boolean onTouch(View v, MotionEvent event) {
        int action = MotionEventCompat.getActionMasked(event);

        switch(action) {
            case (MotionEvent.ACTION_DOWN):
                initialY = event.getY();
            case (MotionEvent.ACTION_UP):
                finalY = event.getY();

                if (initialY < finalY) {
                    Log.d(TAG, "Scrolling up");
                    isScrollingUp = true;
                } else if (initialY > finalY) {
                    Log.d(TAG, "Scrolling down");
                    isScrollingUp = false;
                }
            default:
        }

        if (isScrollingUp) {
            // do animation for scrolling up
        } else {
            // do animation for scrolling down
        }

        return false; // has to be false, or it will freeze the listView
    }
});

Spróbuj tego . Mam nadzieję, że to ci pomoże . Logic From @ Gal Rom Odpowiedz .

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;

        }
    });

Oto moje podejście: dzięki niemu uzyskasz natychmiastową informację zwrotną o tym, ile przewijałeś: OnScroll, możesz po prostu uzyskać najwyższą pozycję pierwszego elementu na liście. Jest to dość wiarygodne, aby natychmiast uzyskać rzeczywiste informacje o pozycji przewijania.

listView.getChildAt(0).getTop()

Użyłem tego znacznie prostszego rozwiązania:

public class ScrollDetectingListView extends ListView

...

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


    }

}

list.setOnScrollListener(new OnScrollListener() {
        int last_item;
        @Override
        public void onScrollStateChanged(AbsListView view, int scrollState) {

        }

        @Override
        public void onScroll(AbsListView view, int firstVisibleItem,
                int visibleItemCount, int totalItemCount) {
            if(last_item<firstVisibleItem+visibleItemCount-1){
                System.out.println("List is scrolling upwards");
            }
            else if(last_item>firstVisibleItem+visibleItemCount-1){
                System.out.println("List is scrolling downwards");
            }
             last_item = firstVisibleItem+visibleItemCount-1;
        }
    });

Na podstawie pozycji ostatniego widocznego elementu decyduję czy Listview idzie w górę czy w dół.

Ogólne rozwiązanie, które nie opiera się na pozycjach widoków / etc. Wystarczy sprawdzić pionowe przesunięcie przewijania i porównać je z poprzednim przesunięciem przewijania. Jeśli nowa wartość jest większa niż stara, użytkownik przewija w dół i odwrotnie.

// [START check vertical scroll direction]
int oldScrollOffset = 0;

listView.setOnScrollChangeListener(new View.OnScrollChangeListener() {
        @Override
        public void onScrollChange(View view, int i, int i1, int i2, int i3) {

            Boolean scrollDirectionDown;

            int newScrollOffset = listView.computeVerticalScrollOffset();

            if (newScrollOffset > oldScrollOffset) {
                scrollDirectionDown = true;
            } else {
                scrollDirectionDown = false;
            }

            oldScrollOffset = newScrollOffset;

            if (scrollDirectionDown) {
                // Update accordingly for scrolling down
                Log.d(TAG, "scrolling down");
            } else {
                // Update accordingly for scrolling up
                Log.d(TAG, "scrolling up");
            }

    });
// [END check vertical scroll direction]

view.setOnTouchListener(new View.OnTouchListener() {

        private long startClickTime;
        float y0 = 0;
        float y1 = 0;
        @Override
        public boolean onTouch(View view, MotionEvent motionEvent) {

            if (motionEvent.getAction() == MotionEvent.ACTION_DOWN) {
                y0 = motionEvent.getY();
                startClickTime = System.currentTimeMillis();

            } else if (motionEvent.getAction() == MotionEvent.ACTION_UP) {
                if (System.currentTimeMillis() - startClickTime < ViewConfiguration.getTapTimeout()) {

                    // Touch was a simple tap. Do whatever.

                } else {
                    y1 = motionEvent.getY();
                    // Touch was a not a simple tap.
                    if (y1 - y0 > 50) {
                        // this is down
                    } else if (y1 - y0 < 50) {
                        Log.d("daniY", "-");
                        // this is up
                    }
                }

            }

            return true;
        }

    });

To zadziałało dla mnie, a to zadziała na wykrycie kierunku przewijania wszystkich widoków, o których myślę.