Snappy Scrollen in RecyclerView

Landete ich kommen mit etwas, die etwas anders als die oben genannten. Es ist nicht ideal, aber es funktioniert akzeptabel gut für mich, und kann hilfreich sein, um jemand anderes. Ich werde nicht akzeptieren, dass diese Antwort in der Hoffnung, dass jemand kommt mit etwas besser und weniger hacky (und es ist möglich, dass bin ich Missverständnis der RecyclerView Umsetzung und die fehlende einfache Möglichkeit, dies zu tun, aber in der Zwischenzeit, das ist gut genug für Regierung arbeiten!)

Werden die Grundlagen der Umsetzung sind diese: Das scrollen in einer RecyclerView ist sozusagen aufgeteilt zwischen den RecyclerView und die LinearLayoutManager. Es gibt zwei Fälle, die ich behandeln muss:

1. Der Anwender schleudert den Blick. Das Standardverhalten ist, dass der RecyclerView übergibt den Seitensprung zu einem internen Scroller welche dann führt das scrollen Magie. Dies ist problematisch, weil dann die RecyclerView meist siedelt sich in einem unsnapped position. Ich löse dieses durch überschreiben der RecyclerView fling() Umsetzung und statt schleudern, smoothscroll die LinearLayoutManager um eine position.
2. Der Benutzer den finger anhebt mit unzureichender Geschwindigkeit zu initiieren, der eine schriftrolle. Kein schleudern tritt in diesem Fall. Ich möchte erkennen, in diesem Fall bei, dass die view nicht in einer angedockten position. Dies geschieht durch das überschreiben der onTouchEvent Methode.

Den SnappyRecyclerView:

public final class SnappyRecyclerView extends RecyclerView {

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

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

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

    @Override
    public boolean fling(int velocityX, int velocityY) {
        final LayoutManager lm = getLayoutManager();        

      if (lm instanceof ISnappyLayoutManager) {
            super.smoothScrollToPosition(((ISnappyLayoutManager) getLayoutManager())
                    .getPositionForVelocity(velocityX, velocityY));
            return true;
        }
        return super.fling(velocityX, velocityY);
    }        

    @Override
    public boolean onTouchEvent(MotionEvent e) {
        //We want the parent to handle all touch events--there's a lot going on there, 
        //and there is no reason to overwrite that functionality--bad things will happen.
        final boolean ret = super.onTouchEvent(e);
        final LayoutManager lm = getLayoutManager();        

      if (lm instanceof ISnappyLayoutManager
                && (e.getAction() == MotionEvent.ACTION_UP || 
                    e.getAction() == MotionEvent.ACTION_CANCEL)
                && getScrollState() == SCROLL_STATE_IDLE) {
            //The layout manager is a SnappyLayoutManager, which means that the 
            //children should be snapped to a grid at the end of a drag or 
            //fling. The motion event is either a user lifting their finger or 
            //the cancellation of a motion events, so this is the time to take 
            //over the scrolling to perform our own functionality.
            //Finally, the scroll state is idle--meaning that the resultant 
            //velocity after the user's gesture was below the threshold, and 
            //no fling was performed, so the view may be in an unaligned state 
            //and will not be flung to a proper state.
            smoothScrollToPosition(((ISnappyLayoutManager) lm).getFixScrollPos());
        }        

      return ret;
    }
}

Schnittstelle für flottes layout-Manager:

/**
 * An interface that LayoutManagers that should snap to grid should implement.
 */
public interface ISnappyLayoutManager {        

    /**
     * @param velocityX
     * @param velocityY
     * @return the resultant position from a fling of the given velocity.
     */
    int getPositionForVelocity(int velocityX, int velocityY);        

    /**
     * @return the position this list must scroll to to fix a state where the 
     * views are not snapped to grid.
     */
    int getFixScrollPos();        

}

Und hier ist ein Beispiel für eine LayoutManager dass Unterklassen die LinearLayoutManager zu einer LayoutManager mit smooth-scrolling:

public class SnappyLinearLayoutManager extends LinearLayoutManager implements ISnappyLayoutManager {
    //These variables are from android.widget.Scroller, which is used, via ScrollerCompat, by
    //Recycler View. The scrolling distance calculation logic originates from the same place. Want
    //to use their variables so as to approximate the look of normal Android scrolling.
    //Find the Scroller fling implementation in android.widget.Scroller.fling().
    private static final float INFLEXION = 0.35f; //Tension lines cross at (INFLEXION, 1)
    private static float DECELERATION_RATE = (float) (Math.log(0.78) / Math.log(0.9));
    private static double FRICTION = 0.84;

    private double deceleration;

    public SnappyLinearLayoutManager(Context context) {
        super(context);
        calculateDeceleration(context);
    }

    public SnappyLinearLayoutManager(Context context, int orientation, boolean reverseLayout) {
        super(context, orientation, reverseLayout);
        calculateDeceleration(context);
    }

    private void calculateDeceleration(Context context) {
        deceleration = SensorManager.GRAVITY_EARTH //g (m/s^2)
                * 39.3700787 //inches per meter
                //pixels per inch. 160 is the "default" dpi, i.e. one dip is one pixel on a 160 dpi
                //screen
                * context.getResources().getDisplayMetrics().density * 160.0f * FRICTION;
    }

    @Override
    public int getPositionForVelocity(int velocityX, int velocityY) {
        if (getChildCount() == 0) {
            return 0;
        }
        if (getOrientation() == HORIZONTAL) {
            return calcPosForVelocity(velocityX, getChildAt(0).getLeft(), getChildAt(0).getWidth(),
                    getPosition(getChildAt(0)));
        } else {
            return calcPosForVelocity(velocityY, getChildAt(0).getTop(), getChildAt(0).getHeight(),
                    getPosition(getChildAt(0)));
        }
    }

    private int calcPosForVelocity(int velocity, int scrollPos, int childSize, int currPos) {
        final double dist = getSplineFlingDistance(velocity);

        final double tempScroll = scrollPos + (velocity > 0 ? dist : -dist);

        if (velocity < 0) {
            //Not sure if I need to lower bound this here.
            return (int) Math.max(currPos + tempScroll / childSize, 0);
        } else {
            return (int) (currPos + (tempScroll / childSize) + 1);
        }
    }

    @Override
    public void smoothScrollToPosition(RecyclerView recyclerView, State state, int position) {
        final LinearSmoothScroller linearSmoothScroller =
                new LinearSmoothScroller(recyclerView.getContext()) {

                    //I want a behavior where the scrolling always snaps to the beginning of 
                    //the list. Snapping to end is also trivial given the default implementation. 
                    //If you need a different behavior, you may need to override more
                    //of the LinearSmoothScrolling methods.
                    protected int getHorizontalSnapPreference() {
                        return SNAP_TO_START;
                    }

                    protected int getVerticalSnapPreference() {
                        return SNAP_TO_START;
                    }

                    @Override
                    public PointF computeScrollVectorForPosition(int targetPosition) {
                        return SnappyLinearLayoutManager.this
                                .computeScrollVectorForPosition(targetPosition);
                    }
                };
        linearSmoothScroller.setTargetPosition(position);
        startSmoothScroll(linearSmoothScroller);
    }

    private double getSplineFlingDistance(double velocity) {
        final double l = getSplineDeceleration(velocity);
        final double decelMinusOne = DECELERATION_RATE - 1.0;
        return ViewConfiguration.getScrollFriction() * deceleration
                * Math.exp(DECELERATION_RATE / decelMinusOne * l);
    }

    private double getSplineDeceleration(double velocity) {
        return Math.log(INFLEXION * Math.abs(velocity)
                / (ViewConfiguration.getScrollFriction() * deceleration));
    }

    /**
     * This implementation obviously doesn't take into account the direction of the 
     * that preceded it, but there is no easy way to get that information without more
     * hacking than I was willing to put into it.
     */
    @Override
    public int getFixScrollPos() {
        if (this.getChildCount() == 0) {
            return 0;
        }

        final View child = getChildAt(0);
        final int childPos = getPosition(child);

        if (getOrientation() == HORIZONTAL
                && Math.abs(child.getLeft()) > child.getMeasuredWidth() / 2) {
            //Scrolled first view more than halfway offscreen
            return childPos + 1;
        } else if (getOrientation() == VERTICAL
                && Math.abs(child.getTop()) > child.getMeasuredWidth() / 2) {
            //Scrolled first view more than halfway offscreen
            return childPos + 1;
        }
        return childPos;
    }

}

InformationsquelleAutor der Antwort Catherine

Habe ich es geschafft, zu finden eine bessere Möglichkeit, dies zu tun. @Katharina (OP) lassen Sie mich wissen, wenn dies verbessert werden kann, oder Sie fühlen, ist eine Verbesserung über deins 🙂

Hier ist die scroll-Hörer, die ich benutze.

https://github.com/humblerookie/centerlockrecyclerview/

Habe ich weggelassen, einige kleinere Annahmen hier wie zB.

1) Erste und Letzte Polstern: die Ersten und letzten Elemente in der horizontalen scrollen müssen, haben die erste und Letzte Polstern jeweils so eingestellt, dass die ersten und letzten Ansichten in der Mitte, wenn gescrollt erste und Letzte beziehungsweise.ZB in der onBindViewHolder Sie könnte so etwas tun.

@Override
public void onBindViewHolder(ReviewHolder holder, int position) {
holder.container.setPadding(0,0,0,0);//Resetpadding
     if(position==0){
//Only one element
            if(mData.size()==1){
                holder.container.setPadding(totalpaddinginit/2,0,totalpaddinginit/2,0);
            }
            else{
//>1 elements assign only initpadding
                holder.container.setPadding(totalpaddinginit,0,0,0);
            }
        }
        else
        if(position==mData.size()-1){
            holder.container.setPadding(0,0,totalpaddingfinal,0);
        } 
}

 public class ReviewHolder extends RecyclerView.ViewHolder {

    protected TextView tvName;
    View container;

    public ReviewHolder(View itemView) {
        super(itemView);
        container=itemView;
        tvName= (TextView) itemView.findViewById(R.id.text);
    }
}

Die Logik ist prettty generische und man kann es für viele andere Fälle. Mein Fall ist der recycler Ansicht horizontal und erstreckt sich die gesamte horizontale Breite ohne Ränder( im Grunde recyclerview Mittelpunkt X-Koordinate ist der Bildschirm in der Mitte)oder unebenen Polster.

Incase jemand konfrontiert ist, Frage freundlich Kommentar.

InformationsquelleAutor der Antwort humblerookie

Hier ist ein einfacher hack für das reibungslose scrollen zu einer bestimmten position auf einem Seitensprung Veranstaltung:

@Override
public boolean fling(int velocityX, int velocityY) {

    smoothScrollToPosition(position);
    return super.fling(0, 0);
}

Überschreiben der Seitensprung-Methode mit einem Aufruf smoothScrollToPosition(int position), wo die "int " position" ist die position der Ansicht, die Sie wollen in den adapter. Sie müssen, um den Wert der position irgendwie, aber das ist abhängig von Ihren Bedürfnissen und Umsetzung.

InformationsquelleAutor der Antwort eDizzle

Einen sehr einfachen Ansatz für das erzielen einer snap-in-position-Verhalten -

    recyclerView.setOnScrollListener(new OnScrollListener() {
        private boolean scrollingUp;

        @Override
        public void onScrolled(RecyclerView recyclerView, int dx, int dy) {
            //Or use dx for horizontal scrolling
            scrollingUp = dy < 0;
        }

        @Override
        public void onScrollStateChanged(RecyclerView recyclerView, int newState) {
            //Make sure scrolling has stopped before snapping
            if (newState == RecyclerView.SCROLL_STATE_IDLE) {
                //layoutManager is the recyclerview's layout manager which you need to have reference in advance
                int visiblePosition = scrollingUp ? layoutManager.findFirstVisibleItemPosition()
                        : layoutManager.findLastVisibleItemPosition();
                int completelyVisiblePosition = scrollingUp ? layoutManager
                        .findFirstCompletelyVisibleItemPosition() : layoutManager
                        .findLastCompletelyVisibleItemPosition();
                //Check if we need to snap
                if (visiblePosition != completelyVisiblePosition) {
                    recyclerView.smoothScrollToPosition(visiblePosition);
                    return;
                }

        }
    });

Der einzige kleine Nachteil ist, dass es keinen snap rückwärts, wenn Sie einen Bildlauf weniger als die Hälfte Weg von der teilweise sichtbaren Zelle - aber wenn Sie das nicht stört Sie als es ist eine saubere und einfache Lösung.

InformationsquelleAutor der Antwort Nati Dykstein

Implementierte ich eine funktionierende Lösung für die Horizontale Ausrichtung der RecyclerView, dass gerade liest Koordinaten onTouchEvent, auf den ersten zu BEWEGEN und auf BIS. BIS auf die Berechnung der position, die wir gehen müssen.

public final class SnappyRecyclerView extends RecyclerView {

private Point   mStartMovePoint = new Point( 0, 0 );
private int     mStartMovePositionFirst = 0;
private int     mStartMovePositionSecond = 0;

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

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

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


@Override
public boolean onTouchEvent( MotionEvent e ) {

    final boolean ret = super.onTouchEvent( e );
    final LayoutManager lm = getLayoutManager();
    View childView = lm.getChildAt( 0 );
    View childViewSecond = lm.getChildAt( 1 );

    if( ( e.getAction() & MotionEvent.ACTION_MASK ) == MotionEvent.ACTION_MOVE
            && mStartMovePoint.x == 0) {

        mStartMovePoint.x = (int)e.getX();
        mStartMovePoint.y = (int)e.getY();
        mStartMovePositionFirst = lm.getPosition( childView );
        if( childViewSecond != null )
            mStartMovePositionSecond = lm.getPosition( childViewSecond );

    }//if MotionEvent.ACTION_MOVE

    if( ( e.getAction() & MotionEvent.ACTION_MASK ) == MotionEvent.ACTION_UP ){

        int currentX = (int)e.getX();
        int width = childView.getWidth();

        int xMovement = currentX - mStartMovePoint.x;
        //move back will be positive value
        final boolean moveBack = xMovement > 0;

        int calculatedPosition = mStartMovePositionFirst;
        if( moveBack && mStartMovePositionSecond > 0 )
            calculatedPosition = mStartMovePositionSecond;

        if( Math.abs( xMovement ) > ( width / 3 )  )
            calculatedPosition += moveBack ? -1 : 1;

        if( calculatedPosition >= getAdapter().getItemCount() )
            calculatedPosition = getAdapter().getItemCount() -1;

        if( calculatedPosition < 0 || getAdapter().getItemCount() == 0 )
            calculatedPosition = 0;

        mStartMovePoint.x           = 0;
        mStartMovePoint.y           = 0;
        mStartMovePositionFirst     = 0;
        mStartMovePositionSecond    = 0;

        smoothScrollToPosition( calculatedPosition );
    }//if MotionEvent.ACTION_UP

    return ret;
}}

Funktioniert gut für mich, lassen Sie mich wissen, wenn etwas falsch ist.

InformationsquelleAutor der Antwort Michail L

Wenn Sie brauchen, schnappen Unterstützung für start, Spitze, Ende oder unten, verwenden Sie GravitySnapHelper(https://github.com/rubensousa/RecyclerViewSnap/blob/master/app/src/main/java/com/github/rubensousa/recyclerviewsnap/GravitySnapHelper.java).

Einrasten center:

SnapHelper snapHelper = new LinearSnapHelper();
snapHelper.attachToRecyclerView(recyclerView);

Einrasten start mit GravitySnapHelper:

startRecyclerView.setLayoutManager(new LinearLayoutManager(this,
                LinearLayoutManager.HORIZONTAL, false));

SnapHelper snapHelperStart = new GravitySnapHelper(Gravity.START);
snapHelperStart.attachToRecyclerView(startRecyclerView);

Einrasten top mit GravitySnapHelper:

topRecyclerView.setLayoutManager(new LinearLayoutManager(this));

SnapHelper snapHelperTop = new GravitySnapHelper(Gravity.TOP);
snapHelperTop.attachToRecyclerView(topRecyclerView);

InformationsquelleAutor der Antwort PrakhaRaM

Ich benötigt etwas ein bisschen anders als alle der oben genannten Antworten.

Die wichtigsten Anforderungen waren:

1. Es funktioniert auf die gleiche, wenn der Benutzer schleudert oder nur frei seine finger.
2. Verwendet das native scrolling-Mechanismus, um die gleiche "Gefühl" als reguläre RecyclerView.
3. Wenn es aufhört, fängt es glatt scrollen, um den nächsten snap-Punkt.
4. Keine Notwendigkeit für das verwenden einer benutzerdefinierten LayoutManager oder RecyclerView. Nur ein RecyclerView.OnScrollListener, die wird dann befestigt, indem recyclerView.addOnScrollListener(snapScrollListener). Dieser Weg, der code ist viel sauberer.

Und zwei sehr spezifische Anforderungen, die sollte leicht zu ändern, im Beispiel unten, um zu passen zu Ihrem Fall:

1. Arbeitet horizontal.
2. Rastet die linke Kante des Elements zu einem bestimmten Zeitpunkt in der RecyclerView.

Diese Lösung nutzt die native LinearSmoothScroller. Der Unterschied ist, dass im letzten Schritt, wenn die "Ziel-Ansicht" ist gefunden, es ändert sich die Berechnung des Versatzes, so dass es einrastet, um eine bestimmte position.

public class SnapScrollListener extends RecyclerView.OnScrollListener {

private static final float MILLIS_PER_PIXEL = 200f;

/** The x coordinate of recycler view to which the items should be scrolled */
private final int snapX;

int prevState = RecyclerView.SCROLL_STATE_IDLE;
int currentState = RecyclerView.SCROLL_STATE_IDLE;

public SnapScrollListener(int snapX) {
    this.snapX = snapX;
}

@Override
public void onScrollStateChanged(RecyclerView recyclerView, int newState) {
    super.onScrollStateChanged(recyclerView, newState);
    currentState = newState;
    if(prevState != RecyclerView.SCROLL_STATE_IDLE && currentState == RecyclerView.SCROLL_STATE_IDLE ){
        performSnap(recyclerView);
    }
    prevState = currentState;

}

private void performSnap(RecyclerView recyclerView) {
    for( int i = 0 ;i < recyclerView.getChildCount() ; i ++ ){
        View child = recyclerView.getChildAt(i);
        final int left = child.getLeft();
        int right = child.getRight();
        int halfWidth = (right - left) / 2;
        if (left == snapX) return;
        if (left - halfWidth <= snapX && left + halfWidth >= snapX) { //check if child is over the snapX position
            int adapterPosition = recyclerView.getChildAdapterPosition(child);
            int dx = snapX - left;
            smoothScrollToPositionWithOffset(recyclerView, adapterPosition, dx);
            return;
        }
    }
}

private void smoothScrollToPositionWithOffset(RecyclerView recyclerView, int adapterPosition, final int dx) {
    final RecyclerView.LayoutManager layoutManager = recyclerView.getLayoutManager();
    if( layoutManager instanceof LinearLayoutManager) {

        LinearSmoothScroller scroller = new LinearSmoothScroller(recyclerView.getContext()) {
            @Override
            public PointF computeScrollVectorForPosition(int targetPosition) {
                return ((LinearLayoutManager) layoutManager).computeScrollVectorForPosition(targetPosition);
            }

            @Override
            protected void onTargetFound(View targetView, RecyclerView.State state, Action action) {
                final int dy = calculateDyToMakeVisible(targetView, getVerticalSnapPreference());
                final int distance = (int) Math.sqrt(dx * dx + dy * dy);
                final int time = calculateTimeForDeceleration(distance);
                if (time > 0) {
                    action.update(-dx, -dy, time, mDecelerateInterpolator);
                }
            }

            @Override
            protected float calculateSpeedPerPixel(DisplayMetrics displayMetrics) {
                return MILLIS_PER_PIXEL / displayMetrics.densityDpi;
            }
        };

        scroller.setTargetPosition(adapterPosition);
        layoutManager.startSmoothScroll(scroller);

    }
}

InformationsquelleAutor der Antwort Michał K