类似于ListView的水平滚动View

import java.util.HashMap;
import java.util.LinkedList;
import java.util.Queue;

import android.content.Context;
import android.content.res.TypedArray;
import android.database.DataSetObserver;
import android.graphics.Rect;
import android.util.AttributeSet;
import android.util.DisplayMetrics;
import android.view.GestureDetector;
import android.view.GestureDetector.OnGestureListener;
import android.view.MotionEvent;
import android.view.View;
import android.view.WindowManager;
import android.widget.AdapterView;
import android.widget.ListAdapter;
import android.widget.Scroller;

import com.ebensz.enote.notepad.R;
import com.ebensz.enote.notepad.app.DeviceInfo;

public class HorizontalListView extends AdapterView<ListAdapter> {

    private int measuredWidth;
    private int selectedIndex;

    public HorizontalListView(final Context context, final AttributeSet attrs) {

        super(context, attrs);
        TypedArray a = context.obtainStyledAttributes(
                attrs,
                R.styleable.HorizontalListView
        );
        measuredWidth = a.getDimensionPixelSize(
                a.getIndex(R.styleable.HorizontalListView_item_width),
                0
        );
        a.recycle();
        initView();
    }

    private synchronized void initView() {

        mLeftViewIndex = -1;
        mRightViewIndex = 0;

        mDisplayOffset = 0;

        mCurrentX = 0;
        mNextX = 0;

        displayWidth = getDisplayWidth();
        mMaxX = Integer.MAX_VALUE;

        mScroller = new Scroller(getContext());
        mGesture = new GestureDetector(getContext(), mOnGesture);
    }

    public void setOnItemPositionChanged(OnItemPositionChanged onItemPositionChanged) {
        this.mOnItemPositionChanged = onItemPositionChanged;
    }
    
    @Override
    public void setOnItemSelectedListener(final OnItemSelectedListener listener) {
        mOnItemSelected = listener;
    }

    @Override
    public void setOnItemClickListener(final OnItemClickListener listener) {
        mOnItemClicked = listener;
    }

    @Override
    public void setOnItemLongClickListener(final OnItemLongClickListener listener) {
        mOnItemLongClicked = listener;
    }

    @Override
    public ListAdapter getAdapter() {
        return mAdapter;
    }

    public OnItemClickListener getItemClickListener() {
        return this.mOnItemClicked;
    }
    
    @Override
    public View getSelectedView() {

        if (getAdapter() != null) {

            return getAdapter().getView(
                    selectedIndex,
                    mRecycler.get(selectedIndex),
                    this
            );
        }

        return null;
    }

    @Override
    public void setAdapter(final ListAdapter adapter) {

        if (mAdapter != null) {
            mAdapter.unregisterDataSetObserver(mDataObserver);
        }

        mAdapter = adapter;
        mAdapter.registerDataSetObserver(mDataObserver);

        reset();
        
        requestLayout();
    }

    /**
     * @param visibleOnly - If set to true, then height is calculated only using visible
     *                    views. If set to false then height is calculated using _all_
     *                    views in adapter. Default is true. Be very careful when
     *                    passing false, as this may result in significant performance
     *                    hit for larger number of views.
     */
    public void setWidthMeasureMode(final boolean visibleOnly) {

        if (mMeasureWidthForVisibleOnly != visibleOnly) {
            mMeasureWidthForVisibleOnly = visibleOnly;
            requestLayout();
        }
    }

    private synchronized void reset() {

        initView();

        removeAllViewsInLayout();
        
    }

    public void jumpTo(final int position) {
        
        if (position == getCurrentPosition()) {
            requestLayout();
            return;
        }
        
        reset();

        final int width = displayWidth;
        final int viewWidthInPx = measuredWidth;

        selectedIndex = position;
        mCurrentX = viewWidthInPx * position;
        mNextX = (viewWidthInPx * position) - (width - viewWidthInPx) / 2;
        
        
        mRightViewIndex = position;
        mLeftViewIndex = position - 1;

        int maxx = (viewWidthInPx * (mAdapter.getCount() - 1)) - (width - viewWidthInPx);
        if (mNextX > maxx) {
            mNextX = maxx + (width - viewWidthInPx) / 2;
        }
        
        if (mAdapter.getCount() == 1) {
            mCurrentX = (width - viewWidthInPx) / 2;
        }
        
        if (mAdapter.getCount() - 1 == position) {
            mMaxX = mNextX;
        }
        
        requestLayout();
        
    }

    @Override
    public void setSelection(final int position) {

        getSelectedView().setSelected(false);
        selectedIndex = position;
        getSelectedView().setSelected(true);

        centerInView(position);

    }

    public int getPosition() {
        return mLeftViewIndex + 1;
    }
    
    public int getCurrentPosition() {
        return mCurrentPosition;
    }
    
    public int getHitItemPosition() {
        return hitItemPostion;
    }
    
    public long getItemID(int position) {
        if (null == mAdapter) {
            return -1;
        }
        
        return mAdapter.getItemId(position);
    }
    
    public View getHitItemView(int x, int y) {
        final Rect viewRect = new Rect();
        final int childCount = getChildCount();

        for (int i = 0; i < childCount; i++) {

            final View child = getChildAt(i);

            final int left = child.getLeft();
            final int right = child.getRight();
            final int top = child.getTop();
            final int bottom = child.getBottom();

            viewRect.set(left, top, right, bottom);

            if (viewRect.contains(x, y)) {
                hitItemPostion = mLeftViewIndex + 1 + i;
                return child;
            }
        }
        
        return null;
    }
    
    private void centerInView(final int position) {

        final int width = displayWidth;
        final int viewWidthInPx = measuredWidth;

        final int whereShouldIScrollTo = viewWidthInPx * position  - (width - viewWidthInPx) / 2;
        scrollTo(whereShouldIScrollTo);
    }

    private void addAndMeasureChild(final View child, final int viewPos) {

        LayoutParams params = child.getLayoutParams();

        if (params == null) {
            params = new LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT);
        }
        
        addViewInLayout(child, viewPos, params, true);

        child.measure(
                MeasureSpec.makeMeasureSpec(getWidth(), MeasureSpec.AT_MOST),
                MeasureSpec.makeMeasureSpec(getHeight(), MeasureSpec.AT_MOST)
        );
    }

    @Override
    protected void onMeasure(final int widthMeasureSpec, final int heightMeasureSpec) {
        super.onMeasure(widthMeasureSpec, heightMeasureSpec);
        
        //EXACTLY表示父元素会在一个指定的精确尺寸区域放置View
        if (MeasureSpec.getMode(heightMeasureSpec) != MeasureSpec.EXACTLY) {

            int height = 0;

            if (mMeasureWidthForVisibleOnly) {

                final int childCount = getChildCount();

                for (int i = 0; i < childCount; i++) {

                    final View v = getChildAt(i);

                    v.measure(MeasureSpec.UNSPECIFIED, MeasureSpec.UNSPECIFIED);
                    if (v.getMeasuredHeight() > height) height = v.getMeasuredHeight();
                }
            }
            else {
                final int childCount = getAdapter().getCount();

                for (int i = 0; i < childCount; i++) {

                    final int type = getAdapter().getItemViewType(i);
                    final View convertView = mRecycler.get(type);
                    final View v = getAdapter().getView(i, convertView, this);

                    mRecycler.put(type, v);

                    v.measure(MeasureSpec.UNSPECIFIED, MeasureSpec.UNSPECIFIED);
                    if (v.getMeasuredHeight() > height) height = v.getMeasuredHeight();
                }
            }

            //AT_MOST表示会给出最大的范围
            if (MeasureSpec.getMode(heightMeasureSpec) == MeasureSpec.AT_MOST) {
                final int maxHeight = MeasureSpec.getSize(heightMeasureSpec);
                if (maxHeight < height) height = maxHeight;
            }

            setMeasuredDimension(getMeasuredWidth(), height);
        }
    }

    @Override
    protected synchronized void onLayout(final boolean changed, final int left,
                                         final int top, final int right, final int bottom) {
        super.onLayout(changed, left, top, right, bottom);

        if (mAdapter == null) return;
        
        if (mDataChanged) {

            final int oldCurrentX = mCurrentX;

            initView();
            removeAllViewsInLayout();

            mNextX = oldCurrentX;
            mDataChanged = false;
        }

        if (mScroller.computeScrollOffset()) {
            mNextX = mScroller.getCurrX();
        }

        if (mNextX <= 0) {
            mNextX = 0;
            mScroller.forceFinished(true);
        }

        if (mNextX >= mMaxX) {
            mNextX = mMaxX;
            mScroller.forceFinished(true);
        }

        final int dx = mCurrentX - mNextX;

        removeNonVisibleItems(dx);
        fillList(dx);
        positionItems(dx);
        
        mCurrentX = mNextX;
        
        setCurrentPosition();
        
        if (!mScroller.isFinished()) {
            post(requestLayout);
        }
    }

    private void setCurrentPosition() {
        float position = (float) (mCurrentX + (DeviceInfo.screenWidth - measuredWidth) / 2) / measuredWidth;
        if (mCurrentPosition != Math.round(position)) {
            mCurrentPosition = Math.round(position);
            if (mCurrentPosition < 0) {
                mCurrentPosition = 0;
            }
            
            if (mCurrentPosition > (mAdapter.getCount() - 1)) {
                mCurrentPosition = mAdapter.getCount() - 1;
            }
            
            itemPositionChanged();
        }
    }
    
    private Runnable requestLayout = new Runnable() {
        public void run() {
            requestLayout();
        }
    };

    private void fillList(final int dx) {

        View rightChild = getChildAt(getChildCount() - 1);
        int rightEdge = (rightChild == null) ? 0 : rightChild.getRight();
        fillListRight(rightEdge, dx);

        View leftChild = getChildAt(0);
        int leftEdge = (leftChild == null) ? 0 : leftChild.getLeft();
        fillListLeft(leftEdge, dx);
        
    }

    private void fillListRight(int rightEdge, final int dx) {

        while (rightEdge + dx < getWidth() && mRightViewIndex < mAdapter.getCount()) {

            final View child = mAdapter.getView(mRightViewIndex, mRemovedViewQueue.poll(), this);
            
            addAndMeasureChild(child, -1);
            rightEdge += child.getMeasuredWidth();

            if (mMaxX < 0) mMaxX = 0;

            mRightViewIndex++;
        }
    }

    private void fillListLeft(int leftEdge, final int dx) {

        while (leftEdge + dx > 0 && mLeftViewIndex >= 0) {

            final View child = mAdapter.getView(mLeftViewIndex, mRemovedViewQueue.poll(), this);
            
            addAndMeasureChild(child, 0);
            leftEdge -= child.getMeasuredWidth();

            mLeftViewIndex--;
            mDisplayOffset -= child.getMeasuredWidth();
        }
    }

    private void removeNonVisibleItems(final int dx) {

        View child = getChildAt(0);

        while (child != null && child.getRight() + dx <= 0) {

            mDisplayOffset += child.getMeasuredWidth();
            mRemovedViewQueue.offer(child);
            removeViewInLayout(child);

            mLeftViewIndex++;
            child = getChildAt(0);
        }

        child = getChildAt(getChildCount() - 1);

        while (child != null && child.getLeft() + dx >= getWidth()) {

            mRemovedViewQueue.offer(child);
            removeViewInLayout(child);

            mRightViewIndex--;
            child = getChildAt(getChildCount() - 1);
        }
    }

    private void positionItems(final int dx) {

        if (getChildCount() > 0) {

            mDisplayOffset += dx;
            int left = mDisplayOffset;

            for (int i = 0; i < getChildCount(); i++) {

                final View child = getChildAt(i);
                final int childWidth = child.getMeasuredWidth();

                child.layout(left, 0, left + childWidth, child.getMeasuredHeight());
                left += childWidth;
            }
        }
    }

    public synchronized void scrollTo(final int x) {
        mScroller.startScroll(mNextX, 0, x - mNextX, 0);
        requestLayout();
    }

    @Override
    public boolean dispatchTouchEvent(final MotionEvent ev) {
        boolean handled = super.dispatchTouchEvent(ev);
        handled |= mGesture.onTouchEvent(ev);
        return handled;
    }

    protected boolean onFling(final MotionEvent e1, final MotionEvent e2,
                              final float velocityX, final float velocityY) {

        if (1 == mAdapter.getCount()) {
            return true;
        }
        
        synchronized (HorizontalListView.this) {
            int maxx = (measuredWidth * (mAdapter.getCount() - 1)) - (displayWidth - measuredWidth);
            if (mMaxX > maxx) {
                mMaxX = maxx + (displayWidth - measuredWidth) / 2;
            }
            mScroller.fling(mNextX, 0, (int) -velocityX, 0, 0, mMaxX, 0, 0);
        }

        requestLayout();

        return true;
    }

    protected boolean onDown(final MotionEvent e) {
        mScroller.forceFinished(true);
        return true;
    }

    private final OnGestureListener mOnGesture = new GestureDetector.SimpleOnGestureListener() {

        @Override
        public boolean onDown(final MotionEvent e) {
            return HorizontalListView.this.onDown(e);
        }

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

        @Override
        public boolean onScroll(final MotionEvent e1, final MotionEvent e2,
                final float distanceX, final float distanceY) {

            synchronized (HorizontalListView.this) {
                mNextX += (int) distanceX;
            }
            requestLayout();

            return true;
        }

        @Override
        public boolean onSingleTapConfirmed(final MotionEvent e) {

            View childView = getHitItemView((int)e.getX(),(int)e.getY());
            if (childView != null) {
                if (mOnItemClicked != null) {
                    mOnItemClicked.onItemClick(HorizontalListView.this,
                            childView, hitItemPostion,
                            getItemID(hitItemPostion));
                }

            }

            /*if (itemSelectedListener != null) {
                itemSelectedListener.onItemSelected(HorizontalListView.this,
                        childView, hitItemPostion,
                        mAdapter.getItemId(hitItemPostion));

            }

            if (mOnItemSelected != null) {

                mOnItemSelected.onItemSelected(HorizontalListView.this,
                        childView, hitItemPostion,
                        mAdapter.getItemId(hitItemPostion));
            }*/

            return true;
        }

        @Override
        public void onLongPress(final MotionEvent e) {
            View childView = getHitItemView((int)e.getX(),(int)e.getY());
            if (childView != null) {
                if (mOnItemLongClicked != null) {
                    mOnItemLongClicked.onItemLongClick(HorizontalListView.this,
                            childView, hitItemPostion,
                            getItemID(hitItemPostion));
                }
            }
        }
    };

    private final OnItemSelectedListener itemSelectedListener = new OnItemSelectedListener() {

        public void onItemSelected(final AdapterView<?> parent, final View view, final int position, final long id) {
            // setSelection(position);
        }

        public void onNothingSelected(final AdapterView<?> arg0) {
        }
    };

    private final DataSetObserver mDataObserver = new DataSetObserver() {

        @Override
        public void onChanged() {

            synchronized (HorizontalListView.this) {
                mDataChanged = true;
            }

            invalidate();
            requestLayout();
        }

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

    private void itemPositionChanged() {
        if (null != mOnItemPositionChanged) {
            mOnItemPositionChanged.itemPositionChanged(this, getChildAt(getCurrentPosition()), getCurrentPosition());
        }
    }
    
    private int getDisplayWidth() {
        final WindowManager wm = (WindowManager) getContext().getSystemService(Context.WINDOW_SERVICE);
        DisplayMetrics displayMetrics = new DisplayMetrics();
        wm.getDefaultDisplay().getMetrics(displayMetrics);

        return displayMetrics.widthPixels;
    }
    
    public interface OnItemPositionChanged{
        void itemPositionChanged(AdapterView<?> paramAdapterView, View paramView, int paramInt);
    }
    
    protected ListAdapter mAdapter;

    private int mLeftViewIndex = -1;
    private int mRightViewIndex = 0;

    private int hitItemPostion;
    private int displayWidth;
    protected int mCurrentX;
    protected int mNextX;
    protected int mCurrentPosition = -1;

    private int mMaxX = Integer.MAX_VALUE;
    private int mDisplayOffset = 0;

    protected Scroller mScroller;
    private GestureDetector mGesture;

    private final Queue<View> mRemovedViewQueue = new LinkedList<View>();

    private OnItemPositionChanged mOnItemPositionChanged;
    private OnItemSelectedListener mOnItemSelected;
    private OnItemClickListener mOnItemClicked;
    private OnItemLongClickListener mOnItemLongClicked;
    
    private boolean mDataChanged = false;
    private boolean mMeasureWidthForVisibleOnly = true;

    private final HashMap<Integer, View> mRecycler = new HashMap<Integer, View>();

}