ViewPager禁止滑动和修改滑动速度

发布于 2021-3-1 16:50
浏览
0收藏

1. 简介


实际开发中,我们有时候需要禁止 ViewPager 滑动,和改变 ViewPager 切换页面时的滑动速率。下面总结了 禁止ViewPager滑动和通过Viewpager 的 scroller 修改滑动速度的实现。非常简单。

 

2. ViewPager 禁止滑动


禁止 ViewPager 滑动,最简单的方式就是拦截 ViewPager 触摸滑动事件。如下代码所示:

 

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

public class NoScrollViewPager extends ViewPager {

    private boolean scrollable = true;

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

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

    public void setScrollable(boolean scrollable) {
        this.scrollable = scrollable;
    }

    public boolean isScrollable() {
        return scrollable;
    }

    @Override
    public boolean onTouchEvent(MotionEvent ev) {
        if (scrollable) {
            return super.onTouchEvent(ev);
        } else {
            return false;
        }
    }

    @Override
    public boolean onInterceptTouchEvent(MotionEvent ev) {
        if (scrollable) {
            return super.onInterceptTouchEvent(ev);
        } else {
            return false;
        }
    }
}

 

使用时,调用 setScrollable(false) 就可以禁止 ViewPager 滑动。

 

3. ViewPager 修改滑动速度


我们都知道,ViewPager 切换页面有两种方式:一是,手指触摸滑动切换页面;二是,调用方法 setCurrentItem(int) 切换页面。用手指触摸滑动切换页面时,页面的滑动与手指滑动速度有关,过渡动画很明显,体验很好。调用方法切换页面时,由于页面切换速度较快,过渡动画不明显甚至没有,往往是直接闪过去。当我们需要 ViewPager 自动切换页面,例如自动轮播时,ViewPager 原有的切换速度有时候难以适应我们的需求,尤其在我们定制了 ViewPager 的切换效果时,就更加难以适应我们对交互体验的需求了。这时我们就需要修改这种情况下页面滑动速度了。如何修改页面切换速度呢?咱们深入了解一下 ViewPager。

 

首先,我们看一下 setCurrentItem(int) 方法的源码:

public void setCurrentItem(int item) {
    mPopulatePending = false;
    setCurrentItemInternal(item, !mFirstLayout, false);
}

 

调用了 setCurrentItemInternal(int, boolean, boolean) 方法,再看 setCurrentItemInternal(int, boolean, boolean) 方法;

void setCurrentItemInternal(int item, boolean smoothScroll, boolean always) {
	setCurrentItemInternal(item, smoothScroll, always, 0);
}

 

继续往下看:

    void setCurrentItemInternal(int item, boolean smoothScroll, boolean always, int velocity) {
        if (mAdapter == null || mAdapter.getCount() <= 0) {
            setScrollingCacheEnabled(false);
            return;
        }
        if (!always && mCurItem == item && mItems.size() != 0) {
            setScrollingCacheEnabled(false);
            return;
        }

        if (item < 0) {
            item = 0;
        } else if (item >= mAdapter.getCount()) {
            item = mAdapter.getCount() - 1;
        }
        final int pageLimit = mOffscreenPageLimit;
        if (item > (mCurItem + pageLimit) || item < (mCurItem - pageLimit)) {
            // We are doing a jump by more than one page.  To avoid
            // glitches, we want to keep all current pages in the view
            // until the scroll ends.
            for (int i = 0; i < mItems.size(); i++) {
                mItems.get(i).scrolling = true;
            }
        }
        final boolean dispatchSelected = mCurItem != item;

        if (mFirstLayout) {
            // We don't have any idea how big we are yet and shouldn't have any pages either.
            // Just set things up and let the pending layout handle things.
            mCurItem = item;
            if (dispatchSelected) {
                dispatchOnPageSelected(item);
            }
            requestLayout();
        } else {
            populate(item);
            scrollToItem(item, smoothScroll, velocity, dispatchSelected);
        }
    }

 

整段代码和滑动相关的大概只有这一行:

scrollToItem(item, smoothScroll, velocity, dispatchSelected);

 

我们看一下此方法:

    private void scrollToItem(int item, boolean smoothScroll, int velocity,
            boolean dispatchSelected) {
        final ItemInfo curInfo = infoForPosition(item);
        int destX = 0;
        if (curInfo != null) {
            final int width = getClientWidth();
            destX = (int) (width * Math.max(mFirstOffset,
                    Math.min(curInfo.offset, mLastOffset)));
        }
        if (smoothScroll) {
            smoothScrollTo(destX, 0, velocity);
            if (dispatchSelected) {
                dispatchOnPageSelected(item);
            }
        } else {
            if (dispatchSelected) {
                dispatchOnPageSelected(item);
            }
            completeScroll(false);
            scrollTo(destX, 0);
            pageScrolled(destX);
        }
    }

 

在此方法中,velocity 表示速度,与速度有关的是 smoothScrollTo(destX, 0, velocity),我们只需关注 smoothScrollTo() 方法。

    void smoothScrollTo(int x, int y, int velocity) {
        if (getChildCount() == 0) {
            // Nothing to do.
            setScrollingCacheEnabled(false);
            return;
        }

        int sx;
        boolean wasScrolling = (mScroller != null) && !mScroller.isFinished();
        if (wasScrolling) {
            // We're in the middle of a previously initiated scrolling. Check to see
            // whether that scrolling has actually started (if we always call getStartX
            // we can get a stale value from the scroller if it hadn't yet had its first
            // computeScrollOffset call) to decide what is the current scrolling position.
            sx = mIsScrollStarted ? mScroller.getCurrX() : mScroller.getStartX();
            // And abort the current scrolling.
            mScroller.abortAnimation();
            setScrollingCacheEnabled(false);
        } else {
            sx = getScrollX();
        }
        int sy = getScrollY();
        int dx = x - sx;
        int dy = y - sy;
        if (dx == 0 && dy == 0) {
            completeScroll(false);
            populate();
            setScrollState(SCROLL_STATE_IDLE);
            return;
        }

        setScrollingCacheEnabled(true);
        setScrollState(SCROLL_STATE_SETTLING);

        final int width = getClientWidth();
        final int halfWidth = width / 2;
        final float distanceRatio = Math.min(1f, 1.0f * Math.abs(dx) / width);
        final float distance = halfWidth + halfWidth
                * distanceInfluenceForSnapDuration(distanceRatio);

        int duration;
        velocity = Math.abs(velocity);
        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);

        // Reset the "scroll started" flag. It will be flipped to true in all places
        // where we call computeScrollOffset().
        mIsScrollStarted = false;
        mScroller.startScroll(sx, sy, dx, dy, duration);
        ViewCompat.postInvalidateOnAnimation(this);
    }

 

这个方法就是关键了!我们知道 velocity 代表速度,找到 velocity,发现 velocity > 0 时,通过 velocity 和 滑动距离(这个应该是手指滑动的)计算出了一个 duration,与设定的最大时间间隔 MAX_SETTLE_DURATION 比较,取较小的,然后再参与滚动。我们向上找 velocity 的传值,发现在 void

 

setCurrentItemInternal(int item, boolean smoothScroll, boolean always) 方法中我们传了 0,duration 会根据 将要滚动的距离 和 页面占用的宽度 计算出滚动的页数,duration 为 100*(滚动页数 + 1) 毫秒,最后还是会取 duration 和 MAX_SETTLE_DURATION 的较小值。最终,duration 最大为 MAX_SETTLE_DURATION ,MAX_SETTLE_DURATION 的值是 600。而 duration 最终传入了 mScroller.startScroll(sx, sy, dx, dy, duration) 。两个页面切换时,滚动距离是固定的,duration 越小,速度越快;duration 越大,速度越慢。速度越慢,我越是有时间展示我们的页面切换动画,交互体验就越好。

 

那么,如何改变这个duration 呢?我们还要看 mScroller。发现,mScroller 是 ViewPager 的私有属性,而且没有提供对外的方法去修改这个 mScroller。没有办法,我们只能借助于强大的反射机制,简单粗暴但实用。

 

既然要改变 mScroller ,那么就需要为 mScroller 重新赋值,我们先继承 Scroller 重写 startScroll() 方法,使用自己的 duration,弃用上面代码传入的 duration 如下代码所示:

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

public class FixedSpeedScroller extends Scroller {

    private static final int DURATION_DEF = 1500;
    private int mDuration = DURATION_DEF;
                                                                                                            
    public FixedSpeedScroller(Context context) {
        this(context, DURATION_DEF);
    }

    public FixedSpeedScroller(Context context, int duration) {
        this(context, null, duration);
    }
                                                                                                            
    public FixedSpeedScroller(Context context, Interpolator interpolator) {
        this(context, interpolator, DURATION_DEF);
    }
    public FixedSpeedScroller(Context context, Interpolator interpolator, int duration) {
        super(context, interpolator);
        this.mDuration = duration;
    }
                                                                                                            
    @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
        this.startScroll(startX, startY, dx, dy, mDuration);
    }
                                                                                                            
    public void setDuration(int duration) {
        mDuration = duration;
    }

}

 

这样的话,我们就可以自己自定义滑动的时间,控制滑动的速度。下一步就是如何修改 mScroller值了,上面提到,我们只能使用反射,那我们就用反射为 mScroller 重新赋上我们想要的值,如下代码:

try {
    Field field = ViewPager.class.getDeclaredField("mScroller");
    field.setAccessible(true);
    FixedSpeedScroller scroller = new FixedSpeedScroller(viewPager.getContext(), new AccelerateInterpolator());
    field.set(viewPager, scroller);
    scroller.setDuration(2000);
} catch (NoSuchFieldException e) {
    e.printStackTrace();
} catch (IllegalAccessException e) {
    e.printStackTrace();
}

 

4. 参考


·1> android之ViewPager修改滑动速度:
https://www.cnblogs.com/cmai/p/7705190.html

 

分类
标签
已于2021-3-1 16:50:17修改
收藏
回复
举报
回复
添加资源
添加资源将有机会获得更多曝光,你也可以直接关联已上传资源 去关联
    相关推荐