基於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) {

        }
    }


}