基于view的复用的自定义横向滚动的Viewgroup

首先特别感谢http://blog.csdn.net/mtaxot/article/details/51446083，这个代码就是在他的代码上改的，

package com.baidu.baike;

import android.content.Context;
import android.database.DataSetObserver;
import android.graphics.Rect;
import android.support.v4.view.ViewCompat;
import android.util.AttributeSet;
import android.view.GestureDetector;
import android.view.MotionEvent;
import android.view.View;
import android.view.ViewGroup;
import android.widget.ListAdapter;
import android.widget.Scroller;

import java.util.LinkedList;

public class HorizontalScrollView extends ViewGroup {
    // ===========================================================
    // Constants
    // ===========================================================

    //这两个常量是为ViewGroup.addViewInLayout(View, int, LayoutParams, boolean)
    //准备的，第二个参数如果为-1表示尾插，0表示头插
    private static final int INSERT_AT_END_OF_LIST = -1;
    private static final int INSERT_AT_START_OF_LIST = 0;

    // ===========================================================
    // Fields
    // ===========================================================

    /**
     * 用于计算fling时滑动dx的Scroller，会根据你的滑动，为你计算出下一个滚动位置
     */
    protected Scroller mScroller = new Scroller(getContext());

    /**
     * 检测fling等操作的回调
     */
    private final GestureListener mGestureListener = new GestureListener();

    /**
     * 检测fling等操作
     */
    private GestureDetector mDetector;

    /**
     * 记录最左边可见的那个View从什么位置开始展示
     * 取值范围0到-view.getWidth()
     * 其实就是我们layout的时候需要用到的那个offset
     **/
    private int mLeftVisibleViewDisplayOffset;

    /**
     * 适配器
     */
    protected ListAdapter mAdapter;

    /**
     * 回收，缓存View的队列
     */
    private LinkedList<View> mViewsCache = new LinkedList<>();

    /**
     * 标记数据集改变，你对notifyDataSetChanged一定不陌生
     */
    private boolean mDataSetChanged = false;

    /**
     * 用来帮助计算坐标（x，y）所在的item
     */
    private Rect mRect = new Rect();
    /**
     * 这个值以像素为单位，是最重要的一个值，记录当前滑动的距离里
     * 取值范围是0-最大滑动距离，也就是最后一个Item完全显示出来的时候，永远是正数
     */
    protected int mCurrentScrollX;

    /**
     * 滑动的过程是平滑的，这需要保存下一个滚动的位置，一般地， mCurrentScrollX和mNextScrollX相差很小，
     * 这样重绘UI的时候才会觉得平滑，mNextScrollX可以通过Scroller计算，亦可以通过GestureListener 计算得到，
     * 不滑动的时候mNextScrollX等于mCurrentScrollX
     */
    protected int mNextScrollX;

    /**
     * 记录最大的滚动距离，也就是最后一个item完全显示出来的时候的滚动距离。
     * 这个值没有办法初始化，只能在滑动的过程中动态计算，且一旦计算完成就不需要再计算，除非布局发生改变
     */
    private int mMaxScrollX = Integer.MAX_VALUE;

    /**
     * 最左边的View在adapter中的索引
     */
    private int mLeftVisibleViewAdapterIndex;

    /**
     * 最右边的View在adapter中的索引
     */
    private int mRightVisibleViewAdapterIndex;
    // ===========================================================
    // Constructors
    // ===========================================================

    public HorizontalScrollView(Context context) {
        this(context, null);
    }

    public HorizontalScrollView(Context context, AttributeSet attrs) {
        this(context, attrs, 0);
    }

    public HorizontalScrollView(Context context, AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
        mDetector = new GestureDetector(context, mGestureListener);//手势检测
        initView();
    }

    // ===========================================================
    // Public Methods
    // ===========================================================

    /**
     * 给adapter赋值
     */
    public void setAdapter(ListAdapter adapter) {
        if (mAdapter != null) {
            mAdapter.unregisterDataSetObserver(mAdapterDataObserver);
        }
        if (adapter != null) {
            mAdapter = adapter;
            mAdapter.registerDataSetObserver(mAdapterDataObserver);
        }
        reset();
    }

    /**
     * 根据坐标返回item的位置
     */
    public int getChildIndex(final int x, final int y) {
        int childCount = getChildCount();

        for (int index = 0; index < childCount; index++) {
            getChildAt(index).getHitRect(mRect);
            if (mRect.contains(x, y)) {
                return index;
            }
        }
        return -1;
    }




    // ===========================================================
    // Methods for/from SuperClass/Interfaces
    // ===========================================================


    /**
     * 控件消除的时候接触观察者的监听
     */
    @Override
    protected void onDetachedFromWindow() {
        if (mAdapter != null)
            mAdapter.unregisterDataSetObserver(mAdapterDataObserver);
        super.onDetachedFromWindow();
    }
    /**
     * 核心逻辑在这里。。。。。
     * 为了让滑动生效，我们需要每滑动一小段距离，或是fling一小段距离，就需要调用一下requestLayout来
     * 触发本方法执行，直到滑动结束或是fling完毕，
     */
    @Override
    protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
        if (mAdapter == null) {
            return;
        }
        // 如果数据改变
        if (mDataSetChanged) {
            int oldCurrentX = mCurrentScrollX;
            initView();
            removeAllViewsInLayout();
            mNextScrollX = oldCurrentX;// mCurrentX is 0 now.
            mDataSetChanged = false;
        }
        //做一个简单的非法值校验
        //滑到最左边或最右边就强制停止fling
        if (mNextScrollX <= 0) {
            mNextScrollX = 0;
            mScroller.forceFinished(true);
        } else if (mNextScrollX >= mMaxScrollX) {
            mNextScrollX = mMaxScrollX;
            mScroller.forceFinished(true);
        }
        //计算滑动的变化量，向左滑动 dx < 0  向右滑动 dx > 0
        int dx = mCurrentScrollX - mNextScrollX;
        mCurrentScrollX = mNextScrollX;
        removeNonVisibleChildren(dx);
        fillList(dx);
        positionChildren(dx);
        //滑动的过程当中，尝试计算mMaxScrollX
        measuerMaxScrollX();
        //如果惯性滑动没有停止，就低轨道调用onLayuout计算，直到停止
        if (!mScroller.isFinished()) {
            //递归调用onLayout
            ViewCompat.postOnAnimation(this, mDelayedLayout);

        }
    }

    /**
     * 控制滚动的方法
     */
    @Override
    public void computeScroll() {
        //这个方法会帮你计算下一个要滑动的位置，Scroller如何使用，自己去查查
        if (mScroller.computeScrollOffset()) {
            // Compute the next position
            mNextScrollX = mScroller.getCurrX();
        }
    }

    /**
     * 检测到fling事件，启动scroller，并且触发onLayout，就会触发整个fling操作
     */
    protected boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX, float velocityY) {
        mScroller.fling(mNextScrollX, 0, (int) -velocityX, 0, 0, mMaxScrollX, 0, 0);
        requestLayout();
        return true;
    }

    protected boolean onDown(MotionEvent e) {
        //滑动过程中，只要触摸就停止滑动
        mScroller.forceFinished(true);
        return true;
    }

    @Override
    public boolean onTouchEvent(MotionEvent event) {
        mDetector.onTouchEvent(event);
        return true;
    }


    // ===========================================================
    // Private Methods
    // ===========================================================

    /**
     * 初始化默认值
     */
    private void initView() {
        mLeftVisibleViewAdapterIndex = -1;
        mRightVisibleViewAdapterIndex = -1;
        mLeftVisibleViewDisplayOffset = 0;
        mCurrentScrollX = 0;
        mNextScrollX = 0;
        mMaxScrollX = Integer.MAX_VALUE;
    }

    /**
     * 重置默认值
     */
    private void reset() {
        initView();
        removeAllViewsInLayout();
        requestLayout();
    }

    /**
     * ListView也使用这个，可以到源码里看一下，继承的层次略深
     */
    private DataSetObserver mAdapterDataObserver = new DataSetObserver() {
        @Override
        public void onChanged() {
            mDataSetChanged = true;
            // 数据集改变，我们就重绘自己
            invalidate();
            requestLayout();
        }

        @Override
        public void onInvalidated() {
            reset();
            invalidate();
            requestLayout();
        }
    };

    /**
     * 得到缓存的view的第一个
     */
    private View getRecycledView() {
        if (mViewsCache.size() != 0) {
            return mViewsCache.removeFirst();
        }
        return null;
    }

    /**
     * 添加到缓存
     */
    private void recycleView(View view) {
        mViewsCache.addLast(view);
    }

    /**
     * 将一个view放置到HorizontalListView里，但是View只被测量了，没有被layout 和draw
     */
    private void addAndMeasureChild(final View child, int viewPos) {
        LayoutParams params = child.getLayoutParams();
        if (params == null) {
            params = new LayoutParams(LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT);
        }
        addViewInLayout(child, viewPos, params, true);
        final int itemHeight = getHeight();
        child.measure(MeasureSpec.UNSPECIFIED, MeasureSpec.EXACTLY | itemHeight);
    }


    /**
     * 用来递归调用onLayout方法
     */
    private Runnable mDelayedLayout = new Runnable() {
        @Override
        public void run() {
            requestLayout();
        }
    };

    /**
     * 用来测量最大的滚动距离
     * 也就最后一个child的右边界x坐标减去父控件的宽度（一般都是屏幕的宽度）
     */
    private void measuerMaxScrollX() {
        //只有最后一个，也是最右边的item滑入屏幕的时候才计算mMaxScrollX
        if (mRightVisibleViewAdapterIndex == mAdapter.getCount() - 1) {
            View rightView = getChildAt(getChildCount() - 1);
            if (rightView != null) {
                mMaxScrollX = mCurrentScrollX + rightView.getRight() - getWidth();
                if (mMaxScrollX < 0) {
                    mMaxScrollX = 0;
                }
            }
        }
    }

    /**
     * 添加view
     */
    private void fillList(final int dx) {
        // 从右边添加
        int edge = 0;
        View child = getChildAt(getChildCount() - 1);
        if (child != null) {
            edge = child.getRight();
        }
        fillListRight(edge, dx);//如果最右边空了，就填充，直到最右边填满屏幕为止

        // 从左边添加
        edge = 0;
        child = getChildAt(0);
        if (child != null) {
            edge = child.getLeft();
        }
        //如果最左边空了，就填充，直到最左边填满屏幕为止
        fillListLeft(edge, dx);
    }

    /**
     * 移除view
     */
    private void removeNonVisibleChildren(final int dx) {
        View child = getChildAt(0);
        //移除左边的滑出屏幕的view，直到最左边的view还可见，就停止
        while (child != null && child.getRight() + dx <= 0) {
            mLeftVisibleViewDisplayOffset += child.getMeasuredWidth();
            recycleView(child);
            removeViewInLayout(child);
            mLeftVisibleViewAdapterIndex++;
            child = getChildAt(0);
        }

        child = getChildAt(getChildCount() - 1);
        //移除右边的滑出屏幕的view，直到最右边的view还可见，就停止
        while (child != null && child.getLeft() + dx >= getWidth()) {
            recycleView(child);
            removeViewInLayout(child);
            mRightVisibleViewAdapterIndex--;
            child = getChildAt(getChildCount() - 1);
        }
    }

    /**
     * 从右边填充
     */
    private void fillListRight(int rightEdge, final int dx) {
        while (rightEdge + dx < getWidth() && mRightVisibleViewAdapterIndex + 1 < mAdapter.getCount()) {
            mRightVisibleViewAdapterIndex++;
            if (mLeftVisibleViewAdapterIndex < 0) {
                mLeftVisibleViewAdapterIndex = mRightVisibleViewAdapterIndex;
            }
            //我们写的adapter的getView，第一个参数是position,第二个参数是convertView，第三个参数是ViewGroup
            View child = mAdapter.getView(mRightVisibleViewAdapterIndex, getRecycledView(), this);
            addAndMeasureChild(child, INSERT_AT_END_OF_LIST);
            rightEdge += child.getMeasuredWidth();

        }
    }

    /**
     * 从左边填充
     */
    private void fillListLeft(int leftEdge, final int dx) {
        while (leftEdge + dx > 0 && mLeftVisibleViewAdapterIndex >= 1) {
            mLeftVisibleViewAdapterIndex--;
            View child = mAdapter.getView(mLeftVisibleViewAdapterIndex, getRecycledView(), this);
            addAndMeasureChild(child, INSERT_AT_START_OF_LIST);
            leftEdge -= child.getMeasuredWidth();
            mLeftVisibleViewDisplayOffset -= child.getMeasuredWidth();
        }
    }

    /**
     * 这个方法就是item的摆放逻辑了，从做摆放到右，用到mLeftVisibleViewDisplayOffset这个值
     * 这里需要强调一下,layout的过程，可用的宽度只有屏幕的大小，这个坐标也是相对于屏幕的
     * 而mCurrentScrollX则是逻辑上的，其实这个逻辑就是，将item整体移动dx具体，可能向左，可能向右，取决于dx的正负
     */
    private void positionChildren(final int dx) {
        int childCount = getChildCount();
        if (childCount > 0) {
            mLeftVisibleViewDisplayOffset += dx;
            int left = mLeftVisibleViewDisplayOffset;
            for (int i = 0; i < childCount; i++) {
                View child = getChildAt(i);
                int right = child.getMeasuredWidth();
                int bottom = child.getMeasuredHeight();
                child.layout(left, 0, left + right, bottom);
                left += child.getMeasuredWidth();
            }
        }
    }

    // ===========================================================
    // Inner and Anonymous Classes
    // ===========================================================


    private class GestureListener extends GestureDetector.SimpleOnGestureListener {
        @Override
        public boolean onDown(MotionEvent e) {
            return HorizontalScrollView.this.onDown(e);
        }

        @Override
        public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX, float velocityY) {
            return HorizontalScrollView.this.onFling(e1, e2, velocityX, velocityY);
        }

        @Override
        public boolean onScroll(MotionEvent e1, MotionEvent e2, float distanceX, float distanceY) {
            //触摸滚动的时候，计算mNextScrollX，然后触发onLayout进行重绘，触摸滑动停止，重新布局停止
            mNextScrollX += (int) distanceX;
            requestLayout();
            return true;
        }

        @Override
        public boolean onSingleTapConfirmed(MotionEvent e) {
            return false;
        }

        @Override
        public void onLongPress(MotionEvent e) {

        }
    }


}