自定义垂直方向滑动的ViewGroup

转载自：http://blog.csdn.net/lmj623565791/article/details/23692439
效果：类似竖直方向的ViewPager滑动

一、布局代码的实现

<?xml version="1.0" encoding="utf-8"?>
<com.millet.myblogexercise.VerticalLinearLayoutVeiwGroup.VerticalLinearLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:id="@+id/vertical_linear_layout_group"
    android:layout_width="match_parent"
    android:layout_height="match_parent">

    <RelativeLayout
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:background="@color/colorAccent">

    </RelativeLayout>

    <RelativeLayout
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:background="@color/colorPrimary">

    </RelativeLayout>

    <RelativeLayout
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:background="@color/colorPrimaryDark">

    </RelativeLayout>

    <RelativeLayout
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:background="@color/colorAccent">

    </RelativeLayout>

</com.millet.myblogexercise.VerticalLinearLayoutVeiwGroup.VerticalLinearLayout>

将自定义的ViewGroup定为根节点，然后在内部定义若干个RelativeLayout，设置满屏和背景

二、自定义ViewGroup

直接贴代码，敲完代码要多思考，注释都在代码中

/**
 * Created by llay on 2017/2/12.
 */

public class VerticalLinearLayout extends ViewGroup {
    //屏幕的高度
    private int mScreenHeight;
    //手指按下时的getScrollY
    private int mScrollStart;
    //手指抬起时的getScrollY
    private int mScrollEnd;
    //记录移动时的Y
    private int mLastY;
    //滚动的辅助类
    private Scroller mScroller;
    //是否正在滚动
    private boolean isScrolling;
    //加速度检测
    private VelocityTracker mVelocityTracker;
    //记录当前页
    private int currentPage = 0;

    private OnPageChangeListener mOnPageChangeListener;

    public VerticalLinearLayout(Context context, AttributeSet attrs) {
        super(context, attrs);
        //获得屏幕的高度
        WindowManager wm = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
        DisplayMetrics outMetrics = new DisplayMetrics();
        wm.getDefaultDisplay().getMetrics(outMetrics);
        mScreenHeight = outMetrics.heightPixels;
        //初始化
        mScroller = new Scroller(context);
    }

    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        super.onMeasure(widthMeasureSpec, heightMeasureSpec);
        int count = getChildCount();
        for (int i = 0; i < count; ++i) {
            View childView = getChildAt(i);
            measureChild(childView, widthMeasureSpec, mScreenHeight);
        }
    }

    @Override
    protected void onLayout(boolean changed, int l, int t, int r, int b) {
        if (changed) {
            int childCount = getChildCount();
            // 设置主布局的高度
            MarginLayoutParams lp = (MarginLayoutParams) getLayoutParams();
            lp.height = mScreenHeight * childCount;
            setLayoutParams(lp);
            for (int i = 0; i < childCount; i++) {
                View child = getChildAt(i);
                if (child.getVisibility() != View.GONE) {
                    // 调用每个子布局的layout
                    child.layout(l, i * mScreenHeight, r, (i + 1) * mScreenHeight);
                }
            }
        }
    }

    @Override
    public boolean onTouchEvent(MotionEvent event) {
        // 如果当前正在滚动，调用父类的onTouchEvent
        if (isScrolling)
            return super.onTouchEvent(event);
        int action = event.getAction();
        int y = (int) event.getY();
        obtainVelocity(event);
        switch (action) {
            case MotionEvent.ACTION_DOWN:
                mScrollStart = getScrollY();
                mLastY = y;
                break;
            case MotionEvent.ACTION_MOVE:
                if (!mScroller.isFinished()) {
                    mScroller.abortAnimation();
                }
                int dy = mLastY - y;
                // 边界值检查
                int scrollY = getScrollY();
                // 已经到达顶端，下拉多少，就往上滚动多少
                if (dy < 0 && scrollY + dy < 0) {
                    dy = -scrollY;
                }
                // 已经到达底部，上拉多少，就往下滚动多少
                if (dy > 0 && scrollY + dy > getHeight() - mScreenHeight) {
                    dy = getHeight() - mScreenHeight - scrollY;
                }
                scrollBy(0, dy);
                mLastY = y;
                break;
            case MotionEvent.ACTION_UP:
                mScrollEnd = getScrollY();
                int dScrollY = mScrollEnd - mScrollStart;
                // 往上滑动
                if (wantScrollToNext()) {
                    if (shouldScrollToNext()) {
                        mScroller.startScroll(0, getScrollY(), 0, mScreenHeight - dScrollY);
                    } else {
                        mScroller.startScroll(0, getScrollY(), 0, -dScrollY);
                    }
                }
                // 往下滑动
                if (wantScrollToPre()) {
                    if (shouldScrollToPre()) {
                        mScroller.startScroll(0, getScrollY(), 0, -mScreenHeight - dScrollY);
                    } else {
                        mScroller.startScroll(0, getScrollY(), 0, -dScrollY);
                    }
                }
                isScrolling = true;
                postInvalidate();
                recycleVelocity();
                break;
        }
        return true;
    }

    /**
     * 根据滚动距离判断是否能够滚动到下一页
     *
     * @return
     */
    private boolean shouldScrollToNext() {
        return mScrollEnd - mScrollStart > mScreenHeight / 2 || Math.abs(getVelocity()) > 600;
    }

    /**
     * 根据用户滑动，判断用户的意图是否是滚动到下一页
     *
     * @return
     */
    private boolean wantScrollToNext() {
        return mScrollEnd > mScrollStart;
    }

    /**
     * 根据滚动距离判断是否能够滚动到上一页
     *
     * @return
     */
    private boolean shouldScrollToPre() {
        return -mScrollEnd + mScrollStart > mScreenHeight / 2 || Math.abs(getVelocity()) > 600;
    }

    /**
     * 根据用户滑动，判断用户的意图是否是滚动到上一页
     *
     * @return
     */
    private boolean wantScrollToPre() {
        return mScrollEnd < mScrollStart;
    }

    /**
     * 获取y方向的加速度
     *
     * @return
     */
    private int getVelocity() {
        mVelocityTracker.computeCurrentVelocity(1000);
        return (int) mVelocityTracker.getYVelocity();
    }

    /**
     * 释放资源
     */
    private void recycleVelocity() {
        if (mVelocityTracker != null) {
            mVelocityTracker.recycle();
            mVelocityTracker = null;
        }
    }

    @Override
    public void computeScroll() {
        super.computeScroll();
        if (mScroller.computeScrollOffset()) {
            scrollTo(0, mScroller.getCurrY());
            postInvalidate();
        } else {
            int position = getScrollY() / mScreenHeight;
            Log.e("xxx", position + "," + currentPage);
            if (position != currentPage) {
                if (mOnPageChangeListener != null) {
                    currentPage = position;
                    mOnPageChangeListener.onPageChange(currentPage);
                }
            }
            isScrolling = false;
        }
    }

    /**
     * 初始化加速度检测器
     *
     * @param event
     */
    private void obtainVelocity(MotionEvent event) {
        if (mVelocityTracker == null) {
            mVelocityTracker = VelocityTracker.obtain();
        }
        mVelocityTracker.addMovement(event);
    }

    /**
     * 设置回调接口
     *
     * @param onPageChangeListener
     */
    public void setOnPageChangeListener(OnPageChangeListener onPageChangeListener) {
        mOnPageChangeListener = onPageChangeListener;
    }

    /**
     * 回调接口
     *
     * @author zhy
     */
    public interface OnPageChangeListener {
        void onPageChange(int currentPage);
    }

}

解释：Action_down时获得当前的scrollY,然后Action_move时，根据移动的距离不断scrollby就行了，当前处理了一下边界判断，在Action_up中再次获得scrollY，两个的scrollY进行对比，然后根据移动的距离与方向决定最后的动作。

三、工程中使用

public class VerticalLinearLayoutActivity extends BaseActivity {

    private VerticalLinearLayout mVerticalLinearLayout;

    @Override
    protected void initData(Bundle savedInstanceState) {

    }

    @Override
    protected void initView(Bundle savedInstanceState) {
        setContentView(R.layout.activity_vertical_linearlayout);
        mVerticalLinearLayout = (VerticalLinearLayout) findViewById(R.id.vertical_linear_layout_group);
        mVerticalLinearLayout.setOnPageChangeListener(new VerticalLinearLayout.OnPageChangeListener() {
            @Override
            public void onPageChange(int currentPage) {
                Toast.makeText(VerticalLinearLayoutActivity.this, "当前页是" + (currentPage + 1), Toast.LENGTH_SHORT).show();
            }
        });
    }

    @Override
    protected void loadData(Bundle savedInstanceState) {

    }

}

解释：在自定义ViewGroup中，定义了一个OnPageChangeListener接口，用户回调，提高可扩展性。

四、总结

Scroller这个辅助类还是相当好用的，原理我简单说一下：每次滚动时，让Scroller进行滚动，然后调用postInvalidate方法，这个方法会引发调用onDraw方法，onDraw方法中会去调用computeScroll方法，然后我们在computScroll中判断，Scroller的滚动是否结束，没有的话，把当前的View滚动到现在Scroller的位置，然后继续调用postInvalidate，这样一个循环的过程。