Spowolnienie kontrolera Viewpager w systemie Android

Czy istnieje sposób na spowolnienie prędkości przewijania za pomocą adaptera przeglądarki w systemie Android?

Wiesz, patrzyłem na ten kod. Nie mogę zrozumieć, co się mylę.

try{ 
    Field mScroller = mPager.getClass().getDeclaredField("mScroller"); 
    mScroller.setAccessible(true); 
    Scroller scroll = new Scroller(cxt);
    Field scrollDuration = scroll.getClass().getDeclaredField("mDuration");
    scrollDuration.setAccessible(true);
    scrollDuration.set(scroll, 1000);
    mScroller.set(mPager, scroll);
}catch (Exception e){
    Toast.makeText(cxt, "something happened", Toast.LENGTH_LONG).show();
} 

To niczego nie zmienia, a nie ma wyjątków?

Zacząłem od kodu HighFlyer, który rzeczywiście zmienił pole mScroller (co jest świetnym początkiem), ale nie pomógł wydłużyć czasu trwania przewijania, ponieważ ViewPager jawnie przekazuje czas trwania do mScroller, gdy żąda przewijania.

Rozszerzanie ViewPager nie działało, ponieważ nie można zastąpić ważnej metody (smoothScrollTo).

Skończyło się na naprawieniu tego, rozszerzając Scroller o ten kod:

public class FixedSpeedScroller extends Scroller {

    private int mDuration = 5000;

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

    public FixedSpeedScroller(Context context, Interpolator interpolator) {
        super(context, interpolator);
    }

    public FixedSpeedScroller(Context context, Interpolator interpolator, boolean flywheel) {
        super(context, interpolator, flywheel);
    }


    @Override
    public void startScroll(int startX, int startY, int dx, int dy, int duration) {
        // Ignore received duration, use fixed one instead
        super.startScroll(startX, startY, dx, dy, mDuration);
    }

    @Override
    public void startScroll(int startX, int startY, int dx, int dy) {
        // Ignore received duration, use fixed one instead
        super.startScroll(startX, startY, dx, dy, mDuration);
    }
}

I używając tego w ten sposób:

try {
    Field mScroller;
    mScroller = ViewPager.class.getDeclaredField("mScroller");
    mScroller.setAccessible(true); 
    FixedSpeedScroller scroller = new FixedSpeedScroller(mPager.getContext(), sInterpolator);
    // scroller.setFixedDuration(5000);
    mScroller.set(mPager, scroller);
} catch (NoSuchFieldException e) {
} catch (IllegalArgumentException e) {
} catch (IllegalAccessException e) {
}

Zasadniczo zakodowałem czas trwania do 5 sekund i sprawiłem, że mój ViewPager go używa.

Mam nadzieję że to pomoże.

Chciałem zrobić sam i osiągnąłem rozwiązanie (jednak wykorzystując refleksję). Jest podobny do przyjętego rozwiązania, ale używa tego samego interpolatora i zmienia tylko czas trwania na podstawie współczynnika. Musisz użyć a ViewPagerCustomDurationw swoim XML zamiast ViewPager, a następnie możesz to zrobić:

ViewPagerCustomDuration vp = (ViewPagerCustomDuration) findViewById(R.id.myPager);
vp.setScrollDurationFactor(2); // make the animation twice as slow

ViewPagerCustomDuration.java:

import android.content.Context;
import android.support.v4.view.ViewPager;
import android.util.AttributeSet;
import android.view.animation.Interpolator;

import java.lang.reflect.Field;

public class ViewPagerCustomDuration extends ViewPager {

    public ViewPagerCustomDuration(Context context) {
        super(context);
        postInitViewPager();
    }

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

    private ScrollerCustomDuration mScroller = null;

    /**
     * Override the Scroller instance with our own class so we can change the
     * duration
     */
    private void postInitViewPager() {
        try {
            Class<?> viewpager = ViewPager.class;
            Field scroller = viewpager.getDeclaredField("mScroller");
            scroller.setAccessible(true);
            Field interpolator = viewpager.getDeclaredField("sInterpolator");
            interpolator.setAccessible(true);

            mScroller = new ScrollerCustomDuration(getContext(),
                    (Interpolator) interpolator.get(null));
            scroller.set(this, mScroller);
        } catch (Exception e) {
        }
    }

    /**
     * Set the factor by which the duration will change
     */
    public void setScrollDurationFactor(double scrollFactor) {
        mScroller.setScrollDurationFactor(scrollFactor);
    }

}

ScrollerCustomDuration.java:

import android.annotation.SuppressLint;
import android.content.Context;
import android.view.animation.Interpolator;
import android.widget.Scroller;

public class ScrollerCustomDuration extends Scroller {

    private double mScrollFactor = 1;

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

    public ScrollerCustomDuration(Context context, Interpolator interpolator) {
        super(context, interpolator);
    }

    @SuppressLint("NewApi")
    public ScrollerCustomDuration(Context context, Interpolator interpolator, boolean flywheel) {
        super(context, interpolator, flywheel);
    }

    /**
     * Set the factor by which the duration will change
     */
    public void setScrollDurationFactor(double scrollFactor) {
        mScrollFactor = scrollFactor;
    }

    @Override
    public void startScroll(int startX, int startY, int dx, int dy, int duration) {
        super.startScroll(startX, startY, dx, dy, (int) (duration * mScrollFactor));
    }

}

Mam nadzieję, że to komuś pomoże!

Znalazłem lepsze rozwiązanie w oparciu o odpowiedź @ df778899 i Android ValueAnimator API . Działa dobrze bez refleksów i jest bardzo elastyczny. Nie ma również potrzeby tworzenia niestandardowego ViewPagera i umieszczania go w pakiecie android.support.v4.view. Oto przykład:

private void animatePagerTransition(final boolean forward) {

    ValueAnimator animator = ValueAnimator.ofInt(0, viewPager.getWidth() - ( forward ? viewPager.getPaddingLeft() : viewPager.getPaddingRight() ));
    animator.addListener(new Animator.AnimatorListener() {
        @Override
        public void onAnimationStart(Animator animation) {
        }

        @Override
        public void onAnimationEnd(Animator animation) {
            viewPager.endFakeDrag();
        }

        @Override
        public void onAnimationCancel(Animator animation) {
            viewPager.endFakeDrag();
        }

        @Override
        public void onAnimationRepeat(Animator animation) {
        }
    });

    animator.setInterpolator(new AccelerateInterpolator());
    animator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {

        private int oldDragPosition = 0;

        @Override
        public void onAnimationUpdate(ValueAnimator animation) {
            int dragPosition = (Integer) animation.getAnimatedValue();
            int dragOffset = dragPosition - oldDragPosition;
            oldDragPosition = dragPosition;
            viewPager.fakeDragBy(dragOffset * (forward ? -1 : 1));
        }
    });

    animator.setDuration(AppConstants.PAGER_TRANSITION_DURATION_MS);
    viewPager.beginFakeDrag();
    animator.start();
}

Jak widać w źródłach ViewPagera, czas trwania rzutowania kontrolowany przez obiekt mScroller. W dokumentacji możemy przeczytać:

Czas trwania przewijania można przekazać w konstruktorze i określa on maksymalny czas, jaki powinna zająć animacja przewijania

Więc jeśli chcesz kontrolować prędkość, możesz zmienić obiekt mScroller poprzez odbicie.

Powinieneś napisać coś takiego:

setContentView(R.layout.main);
mPager = (ViewPager)findViewById(R.id.view_pager);
Field mScroller = ViewPager.class.getDeclaredField("mScroller");   
mScroller.setAccessible(true);
mScroller.set(mPager, scroller); // initialize scroller object by yourself 

To nie jest idealne rozwiązanie, nie możesz spowolnić prędkości, ponieważ jest to int. Ale jak dla mnie jest wystarczająco wolny i nie muszę używać refleksji.

Zwróć uwagę na pakiet, w którym znajduje się klasa. smoothScrollToma widoczność pakietu.

package android.support.v4.view;

import android.content.Context;
import android.util.AttributeSet;

public class SmoothViewPager extends ViewPager {
    private int mVelocity = 1;

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

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

    @Override
    void smoothScrollTo(int x, int y, int velocity) {
        //ignore passed velocity, use one defined here
        super.smoothScrollTo(x, y, mVelocity);
    }
}

Wydaje się, że metody fakeDrag na ViewPager zapewniają alternatywne rozwiązanie.

Na przykład spowoduje to stronicowanie od pozycji 0 do 1:

rootView.setOnClickListener(new OnClickListener() {
  @Override
  public void onClick(View v) {
      ViewPager pager = (ViewPager) getActivity().findViewById(R.id.pager);
      //pager.setCurrentItem(1, true);
      pager.beginFakeDrag();
      Handler handler = new Handler();
      handler.post(new PageTurner(handler, pager));
  }
});


private static class PageTurner implements Runnable {
  private final Handler handler;
  private final ViewPager pager;
  private int count = 0;

  private PageTurner(Handler handler, ViewPager pager) {
    this.handler = handler;
    this.pager = pager;
  }

  @Override
  public void run() {
    if (pager.isFakeDragging()) {
      if (count < 20) {
        count++;
        pager.fakeDragBy(-count * count);
        handler.postDelayed(this, 20);
      } else {
        pager.endFakeDrag();
      }
    }
  }
}

( count * countJest tam tylko po to, aby przyspieszyć przeciąganie)

używałem

DecelerateInterpolator ()

Oto przykład:

  mViewPager = (ViewPager) findViewById(R.id.container);
            mViewPager.setAdapter(mSectionsPagerAdapter);
            Field mScroller = null;
            try {
                mScroller = ViewPager.class.getDeclaredField("mScroller");
                mScroller.setAccessible(true);
                Scroller scroller = new Scroller(this, new DecelerateInterpolator());
                mScroller.set(mViewPager, scroller);
            } catch (NoSuchFieldException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }

Na podstawie przyjętego rozwiązania stworzyłem klasę kotlin z rozszerzeniem do przeglądania pagera. Cieszyć się! :)

class ViewPageScroller : Scroller {

    var fixedDuration = 1500 //time to scroll in milliseconds

    constructor(context: Context) : super(context)

    constructor(context: Context, interpolator: Interpolator) : super(context, interpolator)

    constructor(context: Context, interpolator: Interpolator, flywheel: Boolean) : super(context, interpolator, flywheel)


    override fun startScroll(startX: Int, startY: Int, dx: Int, dy: Int, duration: Int) {
        // Ignore received duration, use fixed one instead
        super.startScroll(startX, startY, dx, dy, fixedDuration)
    }

    override fun startScroll(startX: Int, startY: Int, dx: Int, dy: Int) {
        // Ignore received duration, use fixed one instead
        super.startScroll(startX, startY, dx, dy, fixedDuration)
    }
}

fun ViewPager.setViewPageScroller(viewPageScroller: ViewPageScroller) {
    try {
        val mScroller: Field = ViewPager::class.java.getDeclaredField("mScroller")
        mScroller.isAccessible = true
        mScroller.set(this, viewPageScroller)
    } catch (e: NoSuchFieldException) {
    } catch (e: IllegalArgumentException) {
    } catch (e: IllegalAccessException) {
    }

}

Oto odpowiedź wykorzystująca zupełnie inne podejście. Ktoś mógłby powiedzieć, że to hacky; jednak nie używa refleksji i twierdziłbym, że zawsze będzie działać.

Wewnątrz znajdujemy następujący kod ViewPager.smoothScrollTo:

    if (velocity > 0) {
        duration = 4 * Math.round(1000 * Math.abs(distance / velocity));
    } else {
        final float pageWidth = width * mAdapter.getPageWidth(mCurItem);
        final float pageDelta = (float) Math.abs(dx) / (pageWidth + mPageMargin);
        duration = (int) ((pageDelta + 1) * 100);
    }
    duration = Math.min(duration, MAX_SETTLE_DURATION);

Oblicza czas trwania na podstawie kilku rzeczy. Widzisz coś, co możemy kontrolować? mAdapter.getPageWidth. Zaimplementujmy ViewPager.OnPageChangeListener w naszym adapterze . Zamierzamy wykryć przewijanie ViewPager i podać fałszywą wartość szerokości . Jeśli chcę, żeby trwanie byłok*100 , wrócę 1.0/(k-1)po getPageWidth. Poniżej znajduje się Kotlin impl tej części adaptera, który zmienia czas trwania na 400:

    var scrolling = false
    override fun getPageWidth(position: Int): Float {
        return if (scrolling) 0.333f else 1f
    }

    // OnPageChangeListener to detect scroll state
    override fun onPageScrollStateChanged(state: Int) {
        scrolling = state == ViewPager.SCROLL_STATE_SETTLING
    }

    override fun onPageScrolled(position: Int, positionOffset: Float, positionOffsetPixels: Int) {
    }

    override fun onPageSelected(position: Int) {
    }

Nie zapomnij dodać adaptera jako OnPageChangedListener.

W moim konkretnym przypadku można bezpiecznie założyć, że użytkownik nie może przesuwać palcem, aby przeciągać między stronami. Jeśli musisz wspierać osiadanie po przeciągnięciu, musisz zrobić trochę więcej w swoich obliczeniach.

Jedną wadą jest to, że zależy to od tej zakodowanej na stałe 100wartości czasu trwania podstawowego w ViewPager. Jeśli to się zmieni, czas trwania zmieni się dzięki temu podejściu.

                binding.vpTour.beginFakeDrag();
                lastFakeDrag = 0;
                ValueAnimator va = ValueAnimator.ofInt(0, binding.vpTour.getWidth());
                va.setDuration(1000);
                va.addUpdateListener(animation -> {
                    if (binding.vpTour.isFakeDragging()) {
                        int animProgress = (Integer) animation.getAnimatedValue();
                        binding.vpTour.fakeDragBy(lastFakeDrag - animProgress);
                        lastFakeDrag = animProgress;
                    }
                });
                va.addListener(new AnimatorListenerAdapter() {
                    @Override
                    public void onAnimationEnd(Animator animation) {
                        super.onAnimationEnd(animation);
                        if (binding.vpTour.isFakeDragging()) {
                            binding.vpTour.endFakeDrag();
                        }
                    }
                });
                va.start();

Chciałem rozwiązać ten sam problem, co wy wszyscy i to jest moje rozwiązanie tego samego problemu, ale myślę, że w ten sposób rozwiązanie jest bardziej elastyczne, ponieważ możesz zmienić czas trwania, jak chcesz, a także zmienić interpolację wartości według potrzeb aby osiągnąć różne efekty wizualne. Moje rozwiązanie przesuwa się ze strony „1” na stronę „2”, więc tylko w rosnących pozycjach, ale można je łatwo zmienić na malejące, wykonując „animProgress - lastFakeDrag” zamiast „lastFakeDrag - animProgress”. Myślę, że jest to najbardziej elastyczne rozwiązanie do wykonania tego zadania.