FlipView.java

package com.marshalchen.common.uimodule.flipViews.flipview;

import android.animation.Animator;
import android.animation.AnimatorListenerAdapter;
import android.animation.TimeInterpolator;
import android.animation.ValueAnimator;
import android.animation.ValueAnimator.AnimatorUpdateListener;
import android.content.Context;
import android.content.res.TypedArray;
import android.database.DataSetObserver;
import android.graphics.*;
import android.graphics.Paint.Style;
import android.support.v4.view.MotionEventCompat;
import android.support.v4.view.VelocityTrackerCompat;
import android.util.AttributeSet;
import android.view.MotionEvent;
import android.view.VelocityTracker;
import android.view.View;
import android.view.ViewConfiguration;
import android.view.animation.AccelerateDecelerateInterpolator;
import android.view.animation.DecelerateInterpolator;
import android.view.animation.Interpolator;
import android.widget.FrameLayout;
import android.widget.ListAdapter;
import android.widget.Scroller;
import com.marshalchen.common.uimodule.R;
import com.marshalchen.common.uimodule.flipViews.flipview.Recycler.Scrap;

public class FlipView extends FrameLayout {

	public interface OnFlipListener {
		public void onFlippedToPage(FlipView v, int position, long id);
	}

	public interface OnOverFlipListener {
		public void onOverFlip(FlipView v, OverFlipMode mode,
                               boolean overFlippingPrevious, float overFlipDistance,
                               float flipDistancePerPage);
	}

	/**
	 * 
	 * @author emilsjolander
	 * 
	 *         Class to hold a view and its corresponding info
	 */
	static class Page {
		View v;
		int position;
		int viewType;
		boolean valid;
	}

	// this will be the postion when there is not data
	private static final int INVALID_PAGE_POSITION = -1;
	// "null" flip distance
	private static final int INVALID_FLIP_DISTANCE = -1;

	private static final int PEAK_ANIM_DURATION = 600;// in ms
	private static final int MAX_SINGLE_PAGE_FLIP_ANIM_DURATION = 300;// in ms

	// for normalizing width/height
	private static final int FLIP_DISTANCE_PER_PAGE = 180;
	private static final int MAX_SHADOW_ALPHA = 180;// out of 255
	private static final int MAX_SHADE_ALPHA = 130;// out of 255
	private static final int MAX_SHINE_ALPHA = 100;// out of 255

	// value for no pointer
	private static final int INVALID_POINTER = -1;

	// constant used by the attributes
	private static final int VERTICAL_FLIP = 0;

	// constant used by the attributes
	@SuppressWarnings("unused")
	private static final int HORIZONTAL_FLIP = 1;

	private DataSetObserver dataSetObserver = new DataSetObserver() {

		@Override
		public void onChanged() {
			dataSetChanged();
		}

		@Override
		public void onInvalidated() {
			dataSetInvalidated();
		}

	};

	private Scroller mScroller;
	private final Interpolator flipInterpolator = new DecelerateInterpolator();
	private ValueAnimator mPeakAnim;
	private TimeInterpolator mPeakInterpolator = new AccelerateDecelerateInterpolator();

	private boolean mIsFlippingVertically = true;
	private boolean mIsFlipping;
	private boolean mIsUnableToFlip;
	private boolean mIsFlippingEnabled = true;
	private boolean mLastTouchAllowed = true;
	private int mTouchSlop;
	private boolean mIsOverFlipping;

	// keep track of pointer
	private float mLastX = -1;
	private float mLastY = -1;
	private int mActivePointerId = INVALID_POINTER;

	// velocity stuff
	private VelocityTracker mVelocityTracker;
	private int mMinimumVelocity;
	private int mMaximumVelocity;

	// views get recycled after they have been pushed out of the active queue
	private Recycler mRecycler = new Recycler();

	private ListAdapter mAdapter;
	private int mPageCount = 0;
	private Page mPreviousPage = new Page();
	private Page mCurrentPage = new Page();
	private Page mNextPage = new Page();
	private View mEmptyView;

	private OnFlipListener mOnFlipListener;
	private OnOverFlipListener mOnOverFlipListener;

	private float mFlipDistance = INVALID_FLIP_DISTANCE;
	private int mCurrentPageIndex = INVALID_PAGE_POSITION;
	private int mLastDispatchedPageEventIndex = 0;
	private long mCurrentPageId = 0;

	private OverFlipMode mOverFlipMode;
	private OverFlipper mOverFlipper;

	// clipping rects
	private Rect mTopRect = new Rect();
	private Rect mBottomRect = new Rect();
	private Rect mRightRect = new Rect();
	private Rect mLeftRect = new Rect();

	// used for transforming the canvas
	private Camera mCamera = new Camera();
	private Matrix mMatrix = new Matrix();

	// paints drawn above views when flipping
	private Paint mShadowPaint = new Paint();
	private Paint mShadePaint = new Paint();
	private Paint mShinePaint = new Paint();

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

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

	public FlipView(Context context, AttributeSet attrs, int defStyle) {
		super(context, attrs, defStyle);

		TypedArray a = context.obtainStyledAttributes(attrs,
				R.styleable.FlipView);

		// 0 is vertical, 1 is horizontal
		mIsFlippingVertically = a.getInt(R.styleable.FlipView_orientation,
				VERTICAL_FLIP) == VERTICAL_FLIP;

		setOverFlipMode(OverFlipMode.values()[a.getInt(
				R.styleable.FlipView_overFlipMode, 0)]);

		a.recycle();

		init();
	}

	private void init() {
		final Context context = getContext();
		final ViewConfiguration configuration = ViewConfiguration.get(context);

		mScroller = new Scroller(context, flipInterpolator);
		mTouchSlop = configuration.getScaledPagingTouchSlop();
		mMinimumVelocity = configuration.getScaledMinimumFlingVelocity();
		mMaximumVelocity = configuration.getScaledMaximumFlingVelocity();

		mShadowPaint.setColor(Color.BLACK);
		mShadowPaint.setStyle(Style.FILL);
		mShadePaint.setColor(Color.BLACK);
		mShadePaint.setStyle(Style.FILL);
		mShinePaint.setColor(Color.WHITE);
		mShinePaint.setStyle(Style.FILL);
	}

	private void dataSetChanged() {
		final int currentPage = mCurrentPageIndex;
		int newPosition = currentPage;

		// if the adapter has stable ids, try to keep the page currently on
		// stable.
		if (mAdapter.hasStableIds() && currentPage != INVALID_PAGE_POSITION) {
			newPosition = getNewPositionOfCurrentPage();
		} else if (currentPage == INVALID_PAGE_POSITION) {
			newPosition = 0;
		}

		// remove all the current views
		recycleActiveViews();
		mRecycler.setViewTypeCount(mAdapter.getViewTypeCount());
		mRecycler.invalidateScraps();

		mPageCount = mAdapter.getCount();

		// put the current page within the new adapter range
		newPosition = Math.min(mPageCount - 1,
				newPosition == INVALID_PAGE_POSITION ? 0 : newPosition);

		if (newPosition != INVALID_PAGE_POSITION) {
			// TODO pretty confusing
			// this will be correctly set in setFlipDistance method
			mCurrentPageIndex = INVALID_PAGE_POSITION;
			mFlipDistance = INVALID_FLIP_DISTANCE;
			flipTo(newPosition);
		} else {
			mFlipDistance = INVALID_FLIP_DISTANCE;
			mPageCount = 0;
			setFlipDistance(0);
		}

		updateEmptyStatus();
	}

	private int getNewPositionOfCurrentPage() {
		// check if id is on same position, this is because it will
		// often be that and this way you do not need to iterate the whole
		// dataset. If it is the same position, you are done.
		if (mCurrentPageId == mAdapter.getItemId(mCurrentPageIndex)) {
			return mCurrentPageIndex;
		}

		// iterate the dataset and look for the correct id. If it
		// exists, set that position as the current position.
		for (int i = 0; i < mAdapter.getCount(); i++) {
			if (mCurrentPageId == mAdapter.getItemId(i)) {
				return i;
			}
		}

		// Id no longer is dataset, keep current page
		return mCurrentPageIndex;
	}

	private void dataSetInvalidated() {
		if (mAdapter != null) {
			mAdapter.unregisterDataSetObserver(dataSetObserver);
			mAdapter = null;
		}
		mRecycler = new Recycler();
		removeAllViews();
	}

	@Override
	protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
		int width = getDefaultSize(0, widthMeasureSpec);
		int height = getDefaultSize(0, heightMeasureSpec);

		measureChildren(widthMeasureSpec, heightMeasureSpec);

		setMeasuredDimension(width, height);
	}

	@Override
	protected void measureChildren(int widthMeasureSpec, int heightMeasureSpec) {
		int width = getDefaultSize(0, widthMeasureSpec);
		int height = getDefaultSize(0, heightMeasureSpec);

		int childWidthMeasureSpec = MeasureSpec.makeMeasureSpec(width,
				MeasureSpec.EXACTLY);
		int childHeightMeasureSpec = MeasureSpec.makeMeasureSpec(height,
				MeasureSpec.EXACTLY);
		final int childCount = getChildCount();
		for (int i = 0; i < childCount; i++) {
			final View child = getChildAt(i);
			measureChild(child, childWidthMeasureSpec, childHeightMeasureSpec);
		}
	}

	@Override
	protected void measureChild(View child, int parentWidthMeasureSpec,
			int parentHeightMeasureSpec) {
		child.measure(parentWidthMeasureSpec, parentHeightMeasureSpec);
	}

	@Override
	protected void onLayout(boolean changed, int l, int t, int r, int b) {
		layoutChildren();

		mTopRect.top = 0;
		mTopRect.left = 0;
		mTopRect.right = getWidth();
		mTopRect.bottom = getHeight() / 2;

		mBottomRect.top = getHeight() / 2;
		mBottomRect.left = 0;
		mBottomRect.right = getWidth();
		mBottomRect.bottom = getHeight();

		mLeftRect.top = 0;
		mLeftRect.left = 0;
		mLeftRect.right = getWidth() / 2;
		mLeftRect.bottom = getHeight();

		mRightRect.top = 0;
		mRightRect.left = getWidth() / 2;
		mRightRect.right = getWidth();
		mRightRect.bottom = getHeight();
	}

	private void layoutChildren() {
		final int childCount = getChildCount();
		for (int i = 0; i < childCount; i++) {
			final View child = getChildAt(i);
			layoutChild(child);
		}
	}

	private void layoutChild(View child) {
		child.layout(0, 0, getWidth(), getHeight());
	}

	private void setFlipDistance(float flipDistance) {

		if (mPageCount < 1) {
			mFlipDistance = 0;
			mCurrentPageIndex = INVALID_PAGE_POSITION;
			mCurrentPageId = -1;
			recycleActiveViews();
			return;
		}

		if (flipDistance == mFlipDistance) {
			return;
		}

		mFlipDistance = flipDistance;

		final int currentPageIndex = (int) Math.round(mFlipDistance
				/ FLIP_DISTANCE_PER_PAGE);

		if (mCurrentPageIndex != currentPageIndex) {
			mCurrentPageIndex = currentPageIndex;
			mCurrentPageId = mAdapter.getItemId(mCurrentPageIndex);

			// TODO be smarter about this. Dont remove a view that will be added
			// again on the next line.
			recycleActiveViews();

			// add the new active views
			if (mCurrentPageIndex > 0) {
				fillPageForIndex(mPreviousPage, mCurrentPageIndex - 1);
				addView(mPreviousPage.v);
			}
			if (mCurrentPageIndex >= 0 && mCurrentPageIndex < mPageCount) {
				fillPageForIndex(mCurrentPage, mCurrentPageIndex);
				addView(mCurrentPage.v);
			}
			if (mCurrentPageIndex < mPageCount - 1) {
				fillPageForIndex(mNextPage, mCurrentPageIndex + 1);
				addView(mNextPage.v);
			}
		}

		invalidate();
	}

	private void fillPageForIndex(Page p, int i) {
		p.position = i;
		p.viewType = mAdapter.getItemViewType(p.position);
		p.v = getView(p.position, p.viewType);
		p.valid = true;
	}

	private void recycleActiveViews() {
		// remove and recycle the currently active views
		if (mPreviousPage.valid) {
			removeView(mPreviousPage.v);
			mRecycler.addScrapView(mPreviousPage.v, mPreviousPage.position,
					mPreviousPage.viewType);
			mPreviousPage.valid = false;
		}
		if (mCurrentPage.valid) {
			removeView(mCurrentPage.v);
			mRecycler.addScrapView(mCurrentPage.v, mCurrentPage.position,
					mCurrentPage.viewType);
			mCurrentPage.valid = false;
		}
		if (mNextPage.valid) {
			removeView(mNextPage.v);
			mRecycler.addScrapView(mNextPage.v, mNextPage.position,
					mNextPage.viewType);
			mNextPage.valid = false;
		}
	}

	private View getView(int index, int viewType) {
		// get the scrap from the recycler corresponding to the correct view
		// type
		Scrap scrap = mRecycler.getScrapView(index, viewType);

		// get a view from the adapter if a scrap was not found or it is
		// invalid.
		View v = null;
		if (scrap == null || !scrap.valid) {
			v = mAdapter.getView(index, scrap == null ? null : scrap.v, this);
		} else {
			v = scrap.v;
		}

		// return view
		return v;
	}

	@Override
	public boolean onInterceptTouchEvent(MotionEvent ev) {

		if (!mIsFlippingEnabled) {
			return false;
		}

		if (mPageCount < 1) {
			return false;
		}

		final int action = ev.getAction() & MotionEvent.ACTION_MASK;

		if (action == MotionEvent.ACTION_CANCEL
				|| action == MotionEvent.ACTION_UP) {
			mIsFlipping = false;
			mIsUnableToFlip = false;
			mActivePointerId = INVALID_POINTER;
			if (mVelocityTracker != null) {
				mVelocityTracker.recycle();
				mVelocityTracker = null;
			}
			return false;
		}

		if (action != MotionEvent.ACTION_DOWN) {
			if (mIsFlipping) {
				return true;
			} else if (mIsUnableToFlip) {
				return false;
			}
		}

		switch (action) {
		case MotionEvent.ACTION_MOVE:
			final int activePointerId = mActivePointerId;
			if (activePointerId == INVALID_POINTER) {
				break;
			}

			final int pointerIndex = MotionEventCompat.findPointerIndex(ev,
					activePointerId);
			if (pointerIndex == -1) {
				mActivePointerId = INVALID_POINTER;
				break;
			}

			final float x = MotionEventCompat.getX(ev, pointerIndex);
			final float dx = x - mLastX;
			final float xDiff = Math.abs(dx);
			final float y = MotionEventCompat.getY(ev, pointerIndex);
			final float dy = y - mLastY;
			final float yDiff = Math.abs(dy);

			if ((mIsFlippingVertically && yDiff > mTouchSlop && yDiff > xDiff)
					|| (!mIsFlippingVertically && xDiff > mTouchSlop && xDiff > yDiff)) {
				mIsFlipping = true;
				mLastX = x;
				mLastY = y;
			} else if ((mIsFlippingVertically && xDiff > mTouchSlop)
					|| (!mIsFlippingVertically && yDiff > mTouchSlop)) {
				mIsUnableToFlip = true;
			}
			break;

		case MotionEvent.ACTION_DOWN:
			mActivePointerId = ev.getAction()
					& MotionEvent.ACTION_POINTER_INDEX_MASK;
			mLastX = MotionEventCompat.getX(ev, mActivePointerId);
			mLastY = MotionEventCompat.getY(ev, mActivePointerId);

			mIsFlipping = !mScroller.isFinished() | mPeakAnim != null;
			mIsUnableToFlip = false;
			mLastTouchAllowed = true;

			break;
		case MotionEventCompat.ACTION_POINTER_UP:
			onSecondaryPointerUp(ev);
			break;
		}

		if (!mIsFlipping) {
			trackVelocity(ev);
		}

		return mIsFlipping;
	}

	@Override
	public boolean onTouchEvent(MotionEvent ev) {

		if (!mIsFlippingEnabled) {
			return false;
		}

		if (mPageCount < 1) {
			return false;
		}

		if (!mIsFlipping && !mLastTouchAllowed) {
			return false;
		}

		final int action = ev.getAction();

		if (action == MotionEvent.ACTION_UP
				|| action == MotionEvent.ACTION_CANCEL
				|| action == MotionEvent.ACTION_OUTSIDE) {
			mLastTouchAllowed = false;
		} else {
			mLastTouchAllowed = true;
		}

		trackVelocity(ev);

		switch (action & MotionEvent.ACTION_MASK) {
		case MotionEvent.ACTION_DOWN:

			// start flipping immediately if interrupting some sort of animation
			if (endScroll() || endPeak()) {
				mIsFlipping = true;
			}

			// Remember where the motion event started
			mLastX = ev.getX();
			mLastY = ev.getY();
			mActivePointerId = MotionEventCompat.getPointerId(ev, 0);
			break;
		case MotionEvent.ACTION_MOVE:
			if (!mIsFlipping) {
				final int pointerIndex = MotionEventCompat.findPointerIndex(ev,
						mActivePointerId);
				if (pointerIndex == -1) {
					mActivePointerId = INVALID_POINTER;
					break;
				}
				final float x = MotionEventCompat.getX(ev, pointerIndex);
				final float xDiff = Math.abs(x - mLastX);
				final float y = MotionEventCompat.getY(ev, pointerIndex);
				final float yDiff = Math.abs(y - mLastY);
				if ((mIsFlippingVertically && yDiff > mTouchSlop && yDiff > xDiff)
						|| (!mIsFlippingVertically && xDiff > mTouchSlop && xDiff > yDiff)) {
					mIsFlipping = true;
					mLastX = x;
					mLastY = y;
				}
			}
			if (mIsFlipping) {
				// Scroll to follow the motion event
				final int activePointerIndex = MotionEventCompat
						.findPointerIndex(ev, mActivePointerId);
				if (activePointerIndex == -1) {
					mActivePointerId = INVALID_POINTER;
					break;
				}
				final float x = MotionEventCompat.getX(ev, activePointerIndex);
				final float deltaX = mLastX - x;
				final float y = MotionEventCompat.getY(ev, activePointerIndex);
				final float deltaY = mLastY - y;
				mLastX = x;
				mLastY = y;

				float deltaFlipDistance = 0;
				if (mIsFlippingVertically) {
					deltaFlipDistance = deltaY;
				} else {
					deltaFlipDistance = deltaX;
				}

				deltaFlipDistance /= ((isFlippingVertically() ? getHeight()
						: getWidth()) / FLIP_DISTANCE_PER_PAGE);
				setFlipDistance(mFlipDistance + deltaFlipDistance);

				final int minFlipDistance = 0;
				final int maxFlipDistance = (mPageCount - 1)
						* FLIP_DISTANCE_PER_PAGE;
				final boolean isOverFlipping = mFlipDistance < minFlipDistance
						|| mFlipDistance > maxFlipDistance;
				if (isOverFlipping) {
					mIsOverFlipping = true;
					setFlipDistance(mOverFlipper.calculate(mFlipDistance,
							minFlipDistance, maxFlipDistance));
					if (mOnOverFlipListener != null) {
						float overFlip = mOverFlipper.getTotalOverFlip();
						mOnOverFlipListener.onOverFlip(this, mOverFlipMode,
								overFlip < 0, Math.abs(overFlip),
								FLIP_DISTANCE_PER_PAGE);
					}
				} else if (mIsOverFlipping) {
					mIsOverFlipping = false;
					if (mOnOverFlipListener != null) {
						// TODO in the future should only notify flip distance 0
						// on the correct edge (previous/next)
						mOnOverFlipListener.onOverFlip(this, mOverFlipMode,
								false, 0, FLIP_DISTANCE_PER_PAGE);
						mOnOverFlipListener.onOverFlip(this, mOverFlipMode,
								true, 0, FLIP_DISTANCE_PER_PAGE);
					}
				}
			}
			break;
		case MotionEvent.ACTION_UP:
		case MotionEvent.ACTION_CANCEL:
			if (mIsFlipping) {
				final VelocityTracker velocityTracker = mVelocityTracker;
				velocityTracker.computeCurrentVelocity(1000, mMaximumVelocity);

				int velocity = 0;
				if (isFlippingVertically()) {
					velocity = (int) VelocityTrackerCompat.getYVelocity(
							velocityTracker, mActivePointerId);
				} else {
					velocity = (int) VelocityTrackerCompat.getXVelocity(
							velocityTracker, mActivePointerId);
				}
				smoothFlipTo(getNextPage(velocity));

				mActivePointerId = INVALID_POINTER;
				endFlip();

				mOverFlipper.overFlipEnded();
			}
			break;
		case MotionEventCompat.ACTION_POINTER_DOWN: {
			final int index = MotionEventCompat.getActionIndex(ev);
			final float x = MotionEventCompat.getX(ev, index);
			final float y = MotionEventCompat.getY(ev, index);
			mLastX = x;
			mLastY = y;
			mActivePointerId = MotionEventCompat.getPointerId(ev, index);
			break;
		}
		case MotionEventCompat.ACTION_POINTER_UP:
			onSecondaryPointerUp(ev);
			final int index = MotionEventCompat.findPointerIndex(ev,
					mActivePointerId);
			final float x = MotionEventCompat.getX(ev, index);
			final float y = MotionEventCompat.getY(ev, index);
			mLastX = x;
			mLastY = y;
			break;
		}
		if (mActivePointerId == INVALID_POINTER) {
			mLastTouchAllowed = false;
		}
		return true;
	}

	@Override
	protected void dispatchDraw(Canvas canvas) {

		if (mPageCount < 1) {
			return;
		}

		if (!mScroller.isFinished() && mScroller.computeScrollOffset()) {
			setFlipDistance(mScroller.getCurrY());
		}

		if (mIsFlipping || !mScroller.isFinished() || mPeakAnim != null) {
			showAllPages();
			drawPreviousHalf(canvas);
			drawNextHalf(canvas);
			drawFlippingHalf(canvas);
		} else {
			endScroll();
			setDrawWithLayer(mCurrentPage.v, false);
			hideOtherPages(mCurrentPage);
			drawChild(canvas, mCurrentPage.v, 0);

			// dispatch listener event now that we have "landed" on a page.
			// TODO not the prettiest to have this with the drawing logic,
			// should change.
			if (mLastDispatchedPageEventIndex != mCurrentPageIndex) {
				mLastDispatchedPageEventIndex = mCurrentPageIndex;
				postFlippedToPage(mCurrentPageIndex);
			}
		}

		// if overflip is GLOW mode and the edge effects needed drawing, make
		// sure to invalidate
		if (mOverFlipper.draw(canvas)) {
			// always invalidate whole screen as it is needed 99% of the time.
			// This is because of the shadows and shines put on the non-flipping
			// pages
			invalidate();
		}
	}

	private void hideOtherPages(Page p) {
		if (mPreviousPage != p && mPreviousPage.valid && mPreviousPage.v.getVisibility() != GONE) {
			mPreviousPage.v.setVisibility(GONE);
		}
		if (mCurrentPage != p && mCurrentPage.valid && mCurrentPage.v.getVisibility() != GONE) {
			mCurrentPage.v.setVisibility(GONE);
		}
		if (mNextPage != p && mNextPage.valid && mNextPage.v.getVisibility() != GONE) {
			mNextPage.v.setVisibility(GONE);
		}
		p.v.setVisibility(VISIBLE);
	}

	private void showAllPages() {
		if (mPreviousPage.valid && mPreviousPage.v.getVisibility() != VISIBLE) {
			mPreviousPage.v.setVisibility(VISIBLE);
		}
		if (mCurrentPage.valid && mCurrentPage.v.getVisibility() != VISIBLE) {
			mCurrentPage.v.setVisibility(VISIBLE);
		}
		if (mNextPage.valid && mNextPage.v.getVisibility() != VISIBLE) {
			mNextPage.v.setVisibility(VISIBLE);
		}
	}

	/**
	 * draw top/left half
	 * 
	 * @param canvas
	 */
	private void drawPreviousHalf(Canvas canvas) {
		canvas.save();
		canvas.clipRect(isFlippingVertically() ? mTopRect : mLeftRect);

		final float degreesFlipped = getDegreesFlipped();
		final Page p = degreesFlipped > 90 ? mPreviousPage : mCurrentPage;

		// if the view does not exist, skip drawing it
		if (p.valid) {
			setDrawWithLayer(p.v, true);
			drawChild(canvas, p.v, 0);
		}

		drawPreviousShadow(canvas);
		canvas.restore();
	}

	/**
	 * draw top/left half shadow
	 * 
	 * @param canvas
	 */
	private void drawPreviousShadow(Canvas canvas) {
		final float degreesFlipped = getDegreesFlipped();
		if (degreesFlipped > 90) {
			final int alpha = (int) (((degreesFlipped - 90) / 90f) * MAX_SHADOW_ALPHA);
			mShadowPaint.setAlpha(alpha);
			canvas.drawPaint(mShadowPaint);
		}
	}

	/**
	 * draw bottom/right half
	 * 
	 * @param canvas
	 */
	private void drawNextHalf(Canvas canvas) {
		canvas.save();
		canvas.clipRect(isFlippingVertically() ? mBottomRect : mRightRect);
		
		final float degreesFlipped = getDegreesFlipped();
		final Page p = degreesFlipped > 90 ? mCurrentPage : mNextPage;

		// if the view does not exist, skip drawing it
		if (p.valid) {
			setDrawWithLayer(p.v, true);
			drawChild(canvas, p.v, 0);
		}

		drawNextShadow(canvas);
		canvas.restore();
	}

	/**
	 * draw bottom/right half shadow
	 * 
	 * @param canvas
	 */
	private void drawNextShadow(Canvas canvas) {
		final float degreesFlipped = getDegreesFlipped();
		if (degreesFlipped < 90) {
			final int alpha = (int) ((Math.abs(degreesFlipped - 90) / 90f) * MAX_SHADOW_ALPHA);
			mShadowPaint.setAlpha(alpha);
			canvas.drawPaint(mShadowPaint);
		}
	}

	private void drawFlippingHalf(Canvas canvas) {
		canvas.save();
		mCamera.save();
		
		final float degreesFlipped = getDegreesFlipped();

		if (degreesFlipped > 90) {
			canvas.clipRect(isFlippingVertically() ? mTopRect : mLeftRect);
			if (mIsFlippingVertically) {
				mCamera.rotateX(degreesFlipped - 180);
			} else {
				mCamera.rotateY(180 - degreesFlipped);
			}
		} else {
			canvas.clipRect(isFlippingVertically() ? mBottomRect : mRightRect);
			if (mIsFlippingVertically) {
				mCamera.rotateX(degreesFlipped);
			} else {
				mCamera.rotateY(-degreesFlipped);
			}
		}

		mCamera.getMatrix(mMatrix);

		positionMatrix();
		canvas.concat(mMatrix);

		setDrawWithLayer(mCurrentPage.v, true);
		drawChild(canvas, mCurrentPage.v, 0);

		drawFlippingShadeShine(canvas);

		mCamera.restore();
		canvas.restore();
	}

	/**
	 * will draw a shade if flipping on the previous(top/left) half and a shine
	 * if flipping on the next(bottom/right) half
	 * 
	 * @param canvas
	 */
	private void drawFlippingShadeShine(Canvas canvas) {
		final float degreesFlipped = getDegreesFlipped();
		if (degreesFlipped < 90) {
			final int alpha = (int) ((degreesFlipped / 90f) * MAX_SHINE_ALPHA);
			mShinePaint.setAlpha(alpha);
			canvas.drawRect(isFlippingVertically() ? mBottomRect : mRightRect,
					mShinePaint);
		} else {
			final int alpha = (int) ((Math.abs(degreesFlipped - 180) / 90f) * MAX_SHADE_ALPHA);
			mShadePaint.setAlpha(alpha);
			canvas.drawRect(isFlippingVertically() ? mTopRect : mLeftRect,
					mShadePaint);
		}
	}

	/**
	 * Enable a hardware layer for the view.
	 * 
	 * @param v
	 * @param drawWithLayer
	 */
	private void setDrawWithLayer(View v, boolean drawWithLayer) {
		if (isHardwareAccelerated()) {
			if (v.getLayerType() != LAYER_TYPE_HARDWARE && drawWithLayer) {
				v.setLayerType(LAYER_TYPE_HARDWARE, null);
			} else if (v.getLayerType() != LAYER_TYPE_NONE && !drawWithLayer) {
				v.setLayerType(LAYER_TYPE_NONE, null);
			}
		}
	}

	private void positionMatrix() {
		mMatrix.preScale(0.25f, 0.25f);
		mMatrix.postScale(4.0f, 4.0f);
		mMatrix.preTranslate(-getWidth() / 2, -getHeight() / 2);
		mMatrix.postTranslate(getWidth() / 2, getHeight() / 2);
	}

	private float getDegreesFlipped() {
		float localFlipDistance = mFlipDistance % FLIP_DISTANCE_PER_PAGE;

		// fix for negative modulo. always want a positive flip degree
		if (localFlipDistance < 0) {
			localFlipDistance += FLIP_DISTANCE_PER_PAGE;
		}

		return (localFlipDistance / FLIP_DISTANCE_PER_PAGE) * 180;
	}

	private void postFlippedToPage(final int page) {
		post(new Runnable() {

			@Override
			public void run() {
				if (mOnFlipListener != null) {
					mOnFlipListener.onFlippedToPage(FlipView.this, page,
							mAdapter.getItemId(page));
				}
			}
		});
	}

	private void onSecondaryPointerUp(MotionEvent ev) {
		final int pointerIndex = MotionEventCompat.getActionIndex(ev);
		final int pointerId = MotionEventCompat.getPointerId(ev, pointerIndex);
		if (pointerId == mActivePointerId) {
			// This was our active pointer going up. Choose a new
			// active pointer and adjust accordingly.
			final int newPointerIndex = pointerIndex == 0 ? 1 : 0;
			mLastX = MotionEventCompat.getX(ev, newPointerIndex);
			mActivePointerId = MotionEventCompat.getPointerId(ev,
					newPointerIndex);
			if (mVelocityTracker != null) {
				mVelocityTracker.clear();
			}
		}
	}

	/**
	 * 
	 * @param deltaFlipDistance
	 *            The distance to flip.
	 * @return The duration for a flip, bigger deltaFlipDistance = longer
	 *         duration. The increase if duration gets smaller for bigger values
	 *         of deltaFlipDistance.
	 */
	private int getFlipDuration(int deltaFlipDistance) {
		float distance = Math.abs(deltaFlipDistance);
		return (int) (MAX_SINGLE_PAGE_FLIP_ANIM_DURATION * Math.sqrt(distance
				/ FLIP_DISTANCE_PER_PAGE));
	}

	/**
	 * 
	 * @param velocity
	 * @return the page you should "land" on
	 */
	private int getNextPage(int velocity) {
		int nextPage;
		if (velocity > mMinimumVelocity) {
			nextPage = getCurrentPageFloor();
		} else if (velocity < -mMinimumVelocity) {
			nextPage = getCurrentPageCeil();
		} else {
			nextPage = getCurrentPageRound();
		}
		return Math.min(Math.max(nextPage, 0), mPageCount - 1);
	}

	private int getCurrentPageRound() {
		return Math.round(mFlipDistance / FLIP_DISTANCE_PER_PAGE);
	}

	private int getCurrentPageFloor() {
		return (int) Math.floor(mFlipDistance / FLIP_DISTANCE_PER_PAGE);
	}

	private int getCurrentPageCeil() {
		return (int) Math.ceil(mFlipDistance / FLIP_DISTANCE_PER_PAGE);
	}

	/**
	 * 
	 * @return true if ended a flip
	 */
	private boolean endFlip() {
		final boolean wasflipping = mIsFlipping;
		mIsFlipping = false;
		mIsUnableToFlip = false;
		mLastTouchAllowed = false;

		if (mVelocityTracker != null) {
			mVelocityTracker.recycle();
			mVelocityTracker = null;
		}
		return wasflipping;
	}

	/**
	 * 
	 * @return true if ended a scroll
	 */
	private boolean endScroll() {
		final boolean wasScrolling = !mScroller.isFinished();
		mScroller.abortAnimation();
		return wasScrolling;
	}

	/**
	 * 
	 * @return true if ended a peak
	 */
	private boolean endPeak() {
		final boolean wasPeaking = mPeakAnim != null;
		if (mPeakAnim != null) {
			mPeakAnim.cancel();
			mPeakAnim = null;
		}
		return wasPeaking;
	}

	private void peak(boolean next, boolean once) {
		final float baseFlipDistance = mCurrentPageIndex
				* FLIP_DISTANCE_PER_PAGE;
		if (next) {
			mPeakAnim = ValueAnimator.ofFloat(baseFlipDistance,
					baseFlipDistance + FLIP_DISTANCE_PER_PAGE / 4);
		} else {
			mPeakAnim = ValueAnimator.ofFloat(baseFlipDistance,
					baseFlipDistance - FLIP_DISTANCE_PER_PAGE / 4);
		}
		mPeakAnim.setInterpolator(mPeakInterpolator);
		mPeakAnim.addUpdateListener(new AnimatorUpdateListener() {

			@Override
			public void onAnimationUpdate(ValueAnimator animation) {
				setFlipDistance((Float) animation.getAnimatedValue());
			}
		});
		mPeakAnim.addListener(new AnimatorListenerAdapter() {
			@Override
			public void onAnimationEnd(Animator animation) {
				endPeak();
			}
		});
		mPeakAnim.setDuration(PEAK_ANIM_DURATION);
		mPeakAnim.setRepeatMode(ValueAnimator.REVERSE);
		mPeakAnim.setRepeatCount(once ? 1 : ValueAnimator.INFINITE);
		mPeakAnim.start();
	}

	private void trackVelocity(MotionEvent ev) {
		if (mVelocityTracker == null) {
			mVelocityTracker = VelocityTracker.obtain();
		}
		mVelocityTracker.addMovement(ev);
	}

	private void updateEmptyStatus() {
		boolean empty = mAdapter == null || mPageCount == 0;

		if (empty) {
			if (mEmptyView != null) {
				mEmptyView.setVisibility(View.VISIBLE);
				setVisibility(View.GONE);
			} else {
				setVisibility(View.VISIBLE);
			}

		} else {
			if (mEmptyView != null) {
				mEmptyView.setVisibility(View.GONE);
			}
			setVisibility(View.VISIBLE);
		}
	}

	/* ---------- API ---------- */

	/**
	 * 
	 * @param adapter
	 *            a regular ListAdapter, not all methods if the list adapter are
	 *            used by the flipview
	 * 
	 */
	public void setAdapter(ListAdapter adapter) {
		if (mAdapter != null) {
			mAdapter.unregisterDataSetObserver(dataSetObserver);
		}

		// remove all the current views
		removeAllViews();

		mAdapter = adapter;
		mPageCount = adapter == null ? 0 : mAdapter.getCount();

		if (adapter != null) {
			mAdapter.registerDataSetObserver(dataSetObserver);

			mRecycler.setViewTypeCount(mAdapter.getViewTypeCount());
			mRecycler.invalidateScraps();
		}

		// TODO pretty confusing
		// this will be correctly set in setFlipDistance method
		mCurrentPageIndex = INVALID_PAGE_POSITION;
		mFlipDistance = INVALID_FLIP_DISTANCE;
		setFlipDistance(0);

		updateEmptyStatus();
	}

	public ListAdapter getAdapter() {
		return mAdapter;
	}

	public int getPageCount() {
		return mPageCount;
	}

	public int getCurrentPage() {
		return mCurrentPageIndex;
	}

	public void flipTo(int page) {
		if (page < 0 || page > mPageCount - 1) {
			throw new IllegalArgumentException("That page does not exist");
		}
		endFlip();
		setFlipDistance(page * FLIP_DISTANCE_PER_PAGE);
	}

	public void flipBy(int delta) {
		flipTo(mCurrentPageIndex + delta);
	}

	public void smoothFlipTo(int page) {
		if (page < 0 || page > mPageCount - 1) {
			throw new IllegalArgumentException("That page does not exist");
		}
		final int start = (int) mFlipDistance;
		final int delta = page * FLIP_DISTANCE_PER_PAGE - start;

		endFlip();
		mScroller.startScroll(0, start, 0, delta, getFlipDuration(delta));
		invalidate();
	}

	public void smoothFlipBy(int delta) {
		smoothFlipTo(mCurrentPageIndex + delta);
	}

	/**
	 * Hint that there is a next page will do nothing if there is no next page
	 * 
	 * @param once
	 *            if true, only peak once. else peak until user interacts with
	 *            view
	 */
	public void peakNext(boolean once) {
		if (mCurrentPageIndex < mPageCount - 1) {
			peak(true, once);
		}
	}

	/**
	 * Hint that there is a previous page will do nothing if there is no
	 * previous page
	 * 
	 * @param once
	 *            if true, only peak once. else peak until user interacts with
	 *            view
	 */
	public void peakPrevious(boolean once) {
		if (mCurrentPageIndex > 0) {
			peak(false, once);
		}
	}

	/**
	 * 
	 * @return true if the view is flipping vertically, can only be set via xml
	 *         attribute "orientation"
	 */
	public boolean isFlippingVertically() {
		return mIsFlippingVertically;
	}

	/**
	 * The OnFlipListener will notify you when a page has been fully turned.
	 * 
	 * @param onFlipListener
	 */
	public void setOnFlipListener(OnFlipListener onFlipListener) {
		mOnFlipListener = onFlipListener;
	}

	/**
	 * The OnOverFlipListener will notify of over flipping. This is a great
	 * listener to have when implementing pull-to-refresh
	 * 
	 * @param onOverFlipListener
	 */
	public void setOnOverFlipListener(OnOverFlipListener onOverFlipListener) {
		this.mOnOverFlipListener = onOverFlipListener;
	}

	/**
	 * 
	 * @return the overflip mode of this flipview. Default is GLOW
	 */
	public OverFlipMode getOverFlipMode() {
		return mOverFlipMode;
	}

	/**
	 * Set the overflip mode of the flipview. GLOW is the standard seen in all
	 * andriod lists. RUBBER_BAND is more like iOS lists which list you flip
	 * past the first/last page but adding friction, like a rubber band.
	 * 
	 * @param overFlipMode
	 */
	public void setOverFlipMode(OverFlipMode overFlipMode) {
		this.mOverFlipMode = overFlipMode;
		mOverFlipper = OverFlipperFactory.create(this, mOverFlipMode);
	}

	/**
	 * @param emptyView
	 *            The view to show when either no adapter is set or the adapter
	 *            has no items. This should be a view already in the view
	 *            hierarchy which the FlipView will set the visibility of.
	 */
	public void setEmptyView(View emptyView) {
		mEmptyView = emptyView;
		updateEmptyStatus();
	}

}