Change ViewPager animation duration when sliding programmatically

I have found better solution, based on @df778899's answer and the Android ValueAnimator API. It works fine without reflection and is very flexible. Also there is no need for making custom ViewPager and putting it into android.support.v4.view package. Here is an example:

private void animatePagerTransition(final boolean forward) { ValueAnimator animator = ValueAnimator.ofInt(0, viewPager.getWidth()); 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); if (viewPager.beginFakeDrag()) { animator.start(); } } 

UPDATE:

Just checked if this solution can be used to swipe several pages at once (for example if first page should be showed after the last one). This is slightly modified code to handle specified page count:

private int oldDragPosition = 0; private void animatePagerTransition(final boolean forward, int pageCount) { // if previous animation have not finished we can get exception if (pagerAnimation != null) { pagerAnimation.cancel(); } pagerAnimation = getPagerTransitionAnimation(forward, pageCount); if (viewPager.beginFakeDrag()) { // checking that started drag correctly pagerAnimation.start(); } } private Animator getPagerTransitionAnimation(final boolean forward, int pageCount) { ValueAnimator animator = ValueAnimator.ofInt(0, viewPager.getWidth() - 1); 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) { viewPager.endFakeDrag(); oldDragPosition = 0; viewPager.beginFakeDrag(); } }); animator.setInterpolator(new AccelerateInterpolator()); animator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() { @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 / pageCount); // remove divider if you want to make each transition have the same speed as single page transition animator.setRepeatCount(pageCount); return animator; } 

 public class PresentationViewPager extends ViewPager { public static final int DEFAULT_SCROLL_DURATION = 250; public static final int PRESENTATION_MODE_SCROLL_DURATION = 1000; public PresentationViewPager (Context context) { super(context); } public PresentationViewPager (Context context, AttributeSet attrs) { super(context, attrs); } public void setDurationScroll(int millis) { try { Class<?> viewpager = ViewPager.class; Field scroller = viewpager.getDeclaredField("mScroller"); scroller.setAccessible(true); scroller.set(this, new OwnScroller(getContext(), millis)); } catch (Exception e) { e.printStackTrace(); } } public class OwnScroller extends Scroller { private int durationScrollMillis = 1; public OwnScroller(Context context, int durationScroll) { super(context, new DecelerateInterpolator()); this.durationScrollMillis = durationScroll; } @Override public void startScroll(int startX, int startY, int dx, int dy, int duration) { super.startScroll(startX, startY, dx, dy, durationScrollMillis); } } } 

Better solution is to simply access the private fields by creating the class in the support package. EDIT This is bound to the MAX_SETTLE_DURATION of 600ms, set by the ViewPagerclass.

package android.support.v4.view; import android.content.Context; import android.util.AttributeSet; public class SlowViewPager extends ViewPager { // The speed of the scroll used by setCurrentItem() private static final int VELOCITY = 200; public SlowViewPager(Context context) { super(context); } public SlowViewPager(Context context, AttributeSet attrs) { super(context, attrs); } @Override void setCurrentItemInternal(int item, boolean smoothScroll, boolean always) { setCurrentItemInternal(item, smoothScroll, always, VELOCITY); } } 

You can, of course, then add a custom attribute so this can be set via XML.

Here is my code used in Librera Reader

public class MyViewPager extends ViewPager { public MyViewPager(Context context, AttributeSet attrs) { super(context, attrs); initMyScroller(); } private void initMyScroller() { try { Class<?> viewpager = ViewPager.class; Field scroller = viewpager.getDeclaredField("mScroller"); scroller.setAccessible(true); scroller.set(this, new MyScroller(getContext())); // my liner scroller Field mFlingDistance = viewpager.getDeclaredField("mFlingDistance"); mFlingDistance.setAccessible(true); mFlingDistance.set(this, Dips.DP_10);//10 dip Field mMinimumVelocity = viewpager.getDeclaredField("mMinimumVelocity"); mMinimumVelocity.setAccessible(true); mMinimumVelocity.set(this, 0); //0 velocity } catch (Exception e) { LOG.e(e); } } public class MyScroller extends Scroller { public MyScroller(Context context) { super(context, new LinearInterpolator()); // my LinearInterpolator } @Override public void startScroll(int startX, int startY, int dx, int dy, int duration) { super.startScroll(startX, startY, dx, dy, 175);//175 duration } } } 

I used Cicero Moura's version to make a Kotlin class that still works perfectly as of Android 10.

import android.content.Context import android.util.AttributeSet import android.view.MotionEvent import android.view.animation.DecelerateInterpolator import android.widget.Scroller import androidx.viewpager.widget.ViewPager class CustomViewPager(context: Context, attrs: AttributeSet) : ViewPager(context, attrs) { private companion object { const val DEFAULT_SPEED = 1000 } init { setScrollerSpeed(DEFAULT_SPEED) } var scrollDuration = DEFAULT_SPEED set(millis) { setScrollerSpeed(millis) } private fun setScrollerSpeed(millis: Int) { try { ViewPager::class.java.getDeclaredField("mScroller") .apply { isAccessible = true set(this@CustomViewPager, OwnScroller(millis)) } } catch (e: Exception) { e.printStackTrace() } } inner class OwnScroller(private val durationScrollMillis: Int) : Scroller(context, AccelerateDecelerateInterpolator()) { override fun startScroll(startX: Int, startY: Int, dx: Int, dy: Int, duration: Int) { super.startScroll(startX, startY, dx, dy, durationScrollMillis) } } } 

Initializing from the activity class:

viewPager.apply { scrollDuration = 2000 adapter = pagerAdapter } 

After wasting my whole day I found a solution set offscreenPageLimit to total no. of the page.

In order to keep a constant length ViewPager scrolls smooth, setOffScreenLimit(page.length) will keep all the views in memory. However, this poses a problem for any animations that involves calling View.requestLayout function (e.g. any animation that involves making changes to the margin or bounds). It makes them really slow (as per Romain Guy) because the all of the views that's in memory will be invalidated as well. So I tried a few different ways to make things smooth but overriding requestLayout and other invalidate methods will cause many other problems.

A good compromise is to dynamically modify the off screen limit so that most of the scrolls between pages will be very smooth while making sure that all of the in page animations smooth by removing the views when the user. This works really well when you only have 1 or 2 views that will have to make other views off memory.

***Use this when no any solution works because by setting offeset limit u will load all the fragments at the same time