Wie bekomme ich die Scrollgeschwindigkeit auf einem ListView?

Division erste sichtbare Elemente Unterschied, Zeitunterschied, ist keine gute Lösung. OnScroll-listener erhält onScroll event jeden festen Zeitraum, so dass in den meisten Fällen das Ergebnis der division wird auf "0".

So können Sie versuchen, so etwas wie dieses:

private OnScrollListener onScrollListener = new OnScrollListener() {

    private int previousFirstVisibleItem = 0;
    private long previousEventTime = 0;
    private double speed = 0;

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

        if (previousFirstVisibleItem != firstVisibleItem){
            long currTime = System.currentTimeMillis();
            long timeToScrollOneElement = currTime - previousEventTime;
            speed = ((double)1/timeToScrollOneElement)*1000;

            previousFirstVisibleItem = firstVisibleItem;
            previousEventTime = currTime;

            Log.d("DBG", "Speed: " +speed + " elements/second");
        }

    }

    @Override
    public void onScrollStateChanged(HtcAbsListView view, int scrollState) {
    }
};

InformationsquelleAutor der Antwort SSemashko

So ist dies nur einige theoretische pseudo-code, aber nicht so etwas wie diese Arbeit?

Ich denke, die akzeptierten Antworten funktioniert nicht wirklich, die Auflösung ist super gering (d.h. man bekommt nur eine Geschwindigkeit, nachdem ein Objekt ein Bildlauf durchgeführt wurde aus den gesamten Bildschirm, aber was ist, wenn Sie große items?).

   int mTrackingPosition = -1;
   int mLastTop;
   long mLastEventTime;

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

       //Get a new tracking position if our old one is no longer on screen
       //(this also includes the first time)
       if (first > mTrackingPosition || last < mTrackingPosition) {

           //We get the middle position here since that's likely to stay 
           //on screen for a bit when scrolling up or down.
           mTrackingPosition = firstVisibleItem + visibleItemCount / 2;

           //Reset our times since we can't really get velocity from this
           //one measurement
           mLastTop = mLastEventTime = -1;

           //Handle the case that this happens more than once in a
           //row if that's even reasonably possible (i.e. they 
           //scrolled rediculously fast)
       }

       //Get the measurements of the tracking view
       View v = view.getViewForPosition(mTrackingPosition);
       int top = v.getTop();
       long time = System.currentTimeMillis();

       //We can only get speed if we have a last recorded time
       if (mLastTop != -1 && mLastEventTime != -1) {
           //Velocity = distance /time
           float velocity = (mLastTop - top) / (time - mLastEventTime);

           //What do you want to do with the velocity?
           ...
       }

       //Update the last top and time so that we can track the difference
       mLastTop = top;
       mLastEventTime = time;
   }

Wieder das ist nur pseudo-code, habe ich noch nicht getestet, aber ich denke, es sollte funktionieren. Sie haben auch das zurücksetzen der letzten Zeit und die top-position der Werte, wenn die Rollen-Zustand ist STATE_IDLE.

InformationsquelleAutor der Antwort rharter

Hier ist der code, wenn Sie brauchen, um zu wissen, wie viele Pixel pro Sekunde scrollen, wenn die Elemente haben unterschiedliche Größen, oder wenn Sie eine sehr lange Liste. Die Berechnung und Zwischenspeicherung jedes Element Größe würde nicht funktionieren, wenn einige Elemente fehlen. BTW, wenn Sie wählen Sie diese Methode, sollten Sie den cache der item offset statt der Höhe, so dass Sie nicht haben, um so viele Berechnung.

Überschreiben OnScrollListener:

private HashMap<Integer, Integer> offsetMap = new HashMap<>();
private long prevScrollTime = System.currentTimeMillis();

@Override
public void onScroll(AbsListView view, int firstVisibleItem, int visibleItemCount, int totalItemCount) {
        float traveled = 0;
        Set<Integer> oldKeys = new HashSet<>(offsetMap.keySet());
        for (int i = 0; i < visibleItemCount; i++) {
            int pos = firstVisibleItem + i;
            int newOffset = view.getChildAt(i).getTop();
            if (offsetMap.containsKey(pos) && traveled == 0) {
                traveled = Math.abs(newOffset - offsetMap.get(pos));
            }
            offsetMap.put(pos, newOffset);
            oldKeys.remove(pos);
        }
        //remove those that are no longer in view
        for (Integer key : oldKeys) {
            offsetMap.remove(key);
        }
        long newTime = System.currentTimeMillis();
        long t = newTime - prevScrollTime;
        if (t > 0) {
            float speed = traveled / t * 1000f;
        } else {
            //speed = 0
        }
        prevScrollTime = newTime;
}

InformationsquelleAutor der Antwort Dalton Tan