使用Android如何实现层叠卡片式的banner轮播图

package cn.com.cunw.familydesk.view.vipBanner;

import android.animation.Animator;
import android.animation.AnimatorSet;
import android.animation.ObjectAnimator;
import android.animation.ValueAnimator;
import android.content.Context;
import android.content.res.TypedArray;
import android.graphics.Rect;
import androidx.annotation.NonNull;
import android.util.AttributeSet;
import android.util.Log;
import android.util.SparseArray;
import android.view.MotionEvent;
import android.view.VelocityTracker;
import android.view.View;
import android.view.animation.AccelerateDecelerateInterpolator;
import android.view.animation.AnimationUtils;
import android.widget.RelativeLayout;
import android.widget.Scroller;

import java.util.ArrayList;

import cn.com.cunw.familydesk.R;

/**
 * @Description:
 * @Author: wuJie
 * @CreateDate: 2020/1/4 10:14
 * Copyright (C), 2015-2020,
 */
public class CoverFlowView extends RelativeLayout {

 public enum CoverFlowGravity {
  TOP, BOTTOM, CENTER_VERTICAL
 }

 public enum CoverFlowLayoutMode {
  MATCH_PARENT, WRAP_CONTENT
 }

 protected CoverFlowGravity mGravity;

 protected CoverFlowLayoutMode mLayoutMode;

 private Scroller mScroller;
 /**
  * To store reflections need to remove
  */
 private ArrayList<View> removeViewArray;

 private SparseArray<View> showViewArray;

 private int paddingLeft;
 private int paddingRight;
 private int paddingTop;
 private int paddingBottom;

 private int mWidth; // 控件的宽度

 private float reflectHeightFraction;
 private int reflectGap;

 private int mChildHeight; // child的高度
 private int mChildTranslateY;
 //private int mReflectionTranslateY;

 private int mVisibleChildCount; // 一屏显示的图片数量

 protected int VISIBLE_VIEWS = 3; // the visible views left and right 左右两边显示的个数

 private ICoverFlowAdapter mAdapter;

 private float mOffset;
 //private int mLastOffset;

 private final int ALPHA_DATUM = 200; // 基础alpha&#1461;
 private int STANDARD_ALPHA;
 // 基础缩放值
 //private static final float CARD_SCALE = 0.15f;

 private static float MOVE_POS_MULTIPLE = 3.0f;
 private static final int TOUCH_MINIMUM_MOVE = 5;
 private static final float MOVE_SPEED_MULTIPLE = 1;
 private static final float MAX_SPEED = 6.0f;
 private static final float FRICTION = 10.0f;

 private VelocityTracker mVelocity;

 private int firstIndex = 0;

 public CoverFlowView(Context context) {
  super(context);
  init();
 }

 public CoverFlowView(Context context, AttributeSet attrs) {
  super(context, attrs);
  initAttributes(context, attrs);
  init();
 }

 public CoverFlowView(Context context, AttributeSet attrs, int defStyle) {
  super(context, attrs, defStyle);
  initAttributes(context, attrs);
  init();
 }

 private void initAttributes(Context context, AttributeSet attrs) {
  TypedArray a = context.obtainStyledAttributes(attrs, R.styleable.ImageCoverFlowView);
  int totalVisibleChildren = a.getInt(
    R.styleable.ImageCoverFlowView_visibleImage, 3);
  if (totalVisibleChildren % 2 == 0) { // 一屏幕必须是奇数显示
   throw new IllegalArgumentException("visible image must be an odd number");
  }

  VISIBLE_VIEWS = totalVisibleChildren >> 1; // 计算出左右两两边的显示个数

  reflectHeightFraction = a.getFraction(
    R.styleable.ImageCoverFlowView_reflectionHeight, 100, 0, 0.0f);

  if (reflectHeightFraction > 100) {
   reflectHeightFraction = 100;
  }
  reflectHeightFraction /= 100;
  reflectGap = a.getDimensionPixelSize(
    R.styleable.ImageCoverFlowView_reflectionGap, 0);

  mGravity = CoverFlowGravity.values()[a.getInt(
    R.styleable.ImageCoverFlowView_coverflowGravity,
    CoverFlowGravity.CENTER_VERTICAL.ordinal())];

  mLayoutMode = CoverFlowLayoutMode.values()[a.getInt(
    R.styleable.ImageCoverFlowView_coverflowLayoutMode,
    CoverFlowLayoutMode.WRAP_CONTENT.ordinal())];

  a.recycle();
 }

 private void init() {
  removeAllViews();
  setWillNotDraw(false);
  setClickable(true);

  if (mScroller == null) {
   mScroller = new Scroller(getContext(), new AccelerateDecelerateInterpolator());
  }
  if (showViewArray == null) {
   showViewArray = new SparseArray<View>();
  } else {
   showViewArray.clear();
  }
  if (removeViewArray == null) {
   removeViewArray = new ArrayList<View>();
  } else {
   removeViewArray.clear();
  }

  firstIndex = 0;
  mChildHeight = 0;
  mOffset = 0;
  //mLastOffset = -1;

  isFirstIn = true;
  lastMid = 1;
  isChange = true;

  // 计算透明度
  STANDARD_ALPHA = (255 - ALPHA_DATUM) / VISIBLE_VIEWS;

  if (mGravity == null) {
   mGravity = CoverFlowGravity.CENTER_VERTICAL;
  }

  if (mLayoutMode == null) {
   mLayoutMode = CoverFlowLayoutMode.WRAP_CONTENT;
  }

  // 一屏 显示的图片数量
  int visibleCount = (VISIBLE_VIEWS << 1) + 1;

  for (int i = 0; i < visibleCount && mAdapter != null && i < mAdapter.getCount(); ++i) {

   View convertView = null;
   if (removeViewArray.size() > 0) {
    convertView = removeViewArray.remove(0);
   }
   View view = mAdapter.getView(i, convertView, this);
   showViewArray.put(i, view);
   addView(view);
  }

  requestLayout();
 }

 @Override
 protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
  super.onMeasure(widthMeasureSpec, heightMeasureSpec);

  if (mAdapter == null || showViewArray.size() <= 0) {
   return;
  }

  paddingLeft = getPaddingLeft();
  paddingRight = getPaddingRight();
  paddingTop = getPaddingTop();
  paddingBottom = getPaddingBottom();

  int heightMode = MeasureSpec.getMode(heightMeasureSpec);
  int widthSize = MeasureSpec.getSize(widthMeasureSpec);
  int heightSize = MeasureSpec.getSize(heightMeasureSpec);

  // 一屏显示的图片数量
  int visibleCount = (VISIBLE_VIEWS << 1) + 1;

  // 控件高度
  int availableHeight = heightSize - paddingTop - paddingBottom;

  int maxChildTotalHeight = 0;
  for (int i = 0; i < getChildCount() && i < visibleCount && i < showViewArray.size(); ++i) {

   //View view = showViewArray.get(i+firstIndex);
   View view = getChildAt(i);
   measureChild(view, widthMeasureSpec, heightMeasureSpec);

   //final int childHeight = ScreenUtil.dp2px(getContext(), 110);
   final int childHeight = view.getMeasuredHeight();
   final int childTotalHeight = (int) (childHeight + childHeight
     * reflectHeightFraction + reflectGap);

   // 孩子的最大高度
   maxChildTotalHeight = (maxChildTotalHeight < childTotalHeight) &#63; childTotalHeight
     : maxChildTotalHeight;
  }

  // 如果控件模式为确切值 或者 最大时
  if (heightMode == MeasureSpec.EXACTLY || heightMode == MeasureSpec.AT_MOST) {
   // if height which parent provided is less than child need, scale
   // child height to parent provide
   // 如果控件高度小于孩子控件高度，则缩放孩子高度为控件高度
   if (availableHeight < maxChildTotalHeight) {
    mChildHeight = availableHeight;
   } else {
    // if larger than, depends on layout mode
    // if layout mode is match_parent, scale child height to parent
    // provide
    // 如果是填充父窗体模式 则将孩子的高度 设为控件高度
    if (mLayoutMode == CoverFlowLayoutMode.MATCH_PARENT) {
     mChildHeight = availableHeight;
     // if layout mode is wrap_content, keep child's original
     // height
     // 如果是包裹内容 则将孩子的高度设为孩子允许的最大高度
    } else if (mLayoutMode == CoverFlowLayoutMode.WRAP_CONTENT) {
     mChildHeight = maxChildTotalHeight;

     // adjust parent's height
     // 计算出控件的高度
     if (heightMode == MeasureSpec.AT_MOST) {
      heightSize = mChildHeight + paddingTop + paddingBottom;
     }
    }
   }
  } else {
   // height mode is unspecified
   // 如果空间高度 没有明确定义
   // 如果孩子的模式为填充父窗体
   if (mLayoutMode == CoverFlowLayoutMode.MATCH_PARENT) {
    mChildHeight = availableHeight;
    // 如果孩子的模式为包裹内容
   } else if (mLayoutMode == CoverFlowLayoutMode.WRAP_CONTENT) {
    mChildHeight = maxChildTotalHeight;

    // 计算出控件的高度
    // adjust parent's height
    heightSize = mChildHeight + paddingTop + paddingBottom;
   }
  }

  // Adjust movement in y-axis according to gravity
  // 计算出孩子的原点 Y坐标
  if (mGravity == CoverFlowGravity.CENTER_VERTICAL) {// 竖直居中
   mChildTranslateY = (heightSize >> 1) - (mChildHeight >> 1);
  } else if (mGravity == CoverFlowGravity.TOP) {// 顶部对齐
   mChildTranslateY = paddingTop;
  } else if (mGravity == CoverFlowGravity.BOTTOM) {// 底部对齐
   mChildTranslateY = heightSize - paddingBottom - mChildHeight;
  }

  //mReflectionTranslateY = (int) (mChildTranslateY + mChildHeight - mChildHeight
  //  * reflectHeightFraction);

  setMeasuredDimension(widthSize, heightSize);
  mVisibleChildCount = visibleCount;
  mWidth = widthSize;

 }

 boolean isFirstIn = true; // 第一次初始化该控件
 int lastMid = 1;
 boolean isChange = true;

 @Override
 protected void onLayout(boolean changed, int l, int t, int r, int b) {
  if (mAdapter == null || mAdapter.getCount() <= 0 || showViewArray.size() <= 0) {
   return;
  }

  final float offset = mOffset;
  int i = 0;
  int mid = (int) Math.floor(offset + 0.5);

  //右边孩子的数量
  int rightChild = (mVisibleChildCount % 2 == 0) &#63; (mVisibleChildCount >> 1) - 1
    : mVisibleChildCount >> 1;
  //左边孩子的数量
  int leftChild = mVisibleChildCount >> 1;

  if (!isFirstIn) {
   if (lastMid + 1 == mid) {
    int actuallyPositionStart = getActuallyPosition(lastMid - leftChild);
    View view = showViewArray.get(actuallyPositionStart);
    showViewArray.remove(actuallyPositionStart);
    removeViewArray.add(view);
    removeView(view);

    View convertView = null;
    if (removeViewArray.size() > 0) {
     convertView = removeViewArray.remove(0);
    }
    int actuallyPositionEnd = getActuallyPosition(mid + rightChild);

    //TODO
    View viewItem = mAdapter.getView(actuallyPositionEnd, convertView, this);

    showViewArray.put(actuallyPositionEnd, viewItem);
    addView(viewItem);

    isChange = true;

   } else if (lastMid - 1 == mid) {
    int actuallyPositionEnd = getActuallyPosition(lastMid + rightChild);
    View view = showViewArray.get(actuallyPositionEnd);
    showViewArray.remove(actuallyPositionEnd);
    removeViewArray.add(view);
    removeView(view);

    View convertView = null;
    if (removeViewArray.size() > 0) {
     convertView = removeViewArray.remove(0);
    }
    int actuallyPositionStart = getActuallyPosition(mid - leftChild);

    //TODO
    View viewItem = mAdapter.getView(actuallyPositionStart, convertView, this);

    showViewArray.put(actuallyPositionStart, viewItem);
    addView(viewItem, 0);

    isChange = true;
   }

  } else {
   isFirstIn = false;
  }

  lastMid = mid;

  // draw the left children
  // 计算左边孩子的位置
  int startPos = mid - leftChild;
  for (i = startPos; i < mid; ++i) {
   //TODO 计算左边孩子的位置
   View child = layoutLeftChild(i, i - offset);

   if (isChange) {
    int actuallyPosition = getActuallyPosition(i);
    mAdapter.getData(child, actuallyPosition);
   }
  }

  // 计算 右边 和 中间
  int endPos = mid + rightChild;

  int j = -VISIBLE_VIEWS;
  for (i = endPos; i >= mid; --i, j = j + 2) {
   //TODO 计算右边和中间孩子的位置
   View child = layoutRightChild(i + j, i - offset);

   if (isChange) {
    int actuallyPosition = getActuallyPosition(i);
    mAdapter.getData(child, actuallyPosition);
   }
  }

  isChange = false;
 }

 private View layoutLeftChild(int position, float offset) {
  //获取实际的position
  int actuallyPosition = getActuallyPosition(position);
  View child = showViewArray.get(actuallyPosition);
  if (child != null) {
   makeChildTransfromer(child, actuallyPosition, offset);
  }
  return child;
 }

 private View layoutRightChild(int position, float offset) {

  //获取实际的position
  int actuallyPosition = getActuallyPosition(position);
  View child = showViewArray.get(actuallyPosition);
  if (child != null) {
   makeChildTransfromer(child, actuallyPosition, offset);
  }

  return child;
 }

 /**
  * 对 bitmap 进行伪 3d 变换
  *
  * @param child
  * @param position
  * @param offset
  */
 private void makeChildTransfromer(View child, int position, float offset) {
  //child.layout(0, 0, ScreenUtil.dp2px(getContext(), 200),ScreenUtil.dp2px(getContext(), 110));
  child.layout(0, 0, child.getMeasuredWidth(), child.getMeasuredHeight());

  float scale = 0;
  scale = 1 - Math.abs(offset) * 0.25f;

  // 延x轴移动的距离应该根据center图片决定
  float translateX = 0;

  final int originalChildHeight = (int) (mChildHeight - mChildHeight
    * reflectHeightFraction - reflectGap);

  //final int childTotalHeight = (int) (child.getHeight()
  //  + child.getHeight() * reflectHeightFraction + reflectGap);

  final float originalChildHeightScale = (float) originalChildHeight / child.getHeight();

  final float childHeightScale = originalChildHeightScale * scale;

  final int childWidth = (int) (child.getWidth() * childHeightScale);

  final int centerChildWidth = (int) (child.getWidth() * originalChildHeightScale);

  //final int centerChildWidth = (int) (child.getWidth() * childHeightScale);

  int leftSpace = ((mWidth >> 1) - paddingLeft) - (centerChildWidth >> 1);
  int rightSpace = (((mWidth >> 1) - paddingRight) - (centerChildWidth >> 1));

  //计算出水平方向的x坐标
  if (offset <= 0)
   translateX = ((float) leftSpace / VISIBLE_VIEWS)
     * (VISIBLE_VIEWS + offset) + paddingLeft;

  else
   translateX = mWidth - ((float) rightSpace / VISIBLE_VIEWS)
     * (VISIBLE_VIEWS - offset) - childWidth - paddingRight;

  //根据offset 算出透明度
  float alpha = 254 - Math.abs(offset) * STANDARD_ALPHA;

  child.setAlpha(0);
  if (alpha < 0) {
   alpha = 0;
  } else if (alpha > 254) {
   alpha = 254;
  }
  child.setAlpha(alpha / 254.0f);

  float adjustedChildTranslateY = 0;

  ObjectAnimator anim1 = ObjectAnimator.ofFloat(child, "scaleX", 1.0f, childHeightScale);
  ObjectAnimator anim2 = ObjectAnimator.ofFloat(child, "scaleY", 1.0f, childHeightScale);
  AnimatorSet animSet = new AnimatorSet();
  animSet.setDuration(0);
  //两个动画同时执行
  animSet.playTogether(anim1, anim2);
  child.setPivotX(0);
  child.setPivotY(child.getHeight() / 2);
  //显示的调用invalidate
  child.invalidate();
  animSet.setTarget(child);
  animSet.start();

  child.setTranslationX(translateX);
  child.setTranslationY(mChildTranslateY + adjustedChildTranslateY);

 }

 /**
  * 获取顶部Item position
  *
  * @return
  */
 public int getTopViewPosition() {
  return getActuallyPosition(lastMid);
 }

 /**
  * 获取顶部Item View
  *
  * @return
  */
 public View getTopView() {
  return showViewArray.get(getActuallyPosition(VISIBLE_VIEWS + lastMid));
 }

 /**
  * Convert draw-index to index in adapter
  *
  * @param position position to draw
  * @return
  */
 private int getActuallyPosition(int position) {
  if (mAdapter!=null){

  int max = mAdapter.getCount();
  position += VISIBLE_VIEWS;
  while (position < 0 || position >= max) {
   if (position < 0) {
    position += max;
   } else if (position >= max) {
    position -= max;
   }
   }
  }
  return position;
 }

 public void setAdapter(@NonNull ICoverFlowAdapter adapter) {
  mAdapter = adapter;
  init();
 }

 public ICoverFlowAdapter getAdapter() {
  return mAdapter;
 }

 private boolean onTouchMove = false; //是否正在执行触摸移动逻辑

 private View touchViewItem = null;
 private boolean isOnTopView = false;

 @Override
 public boolean onTouchEvent(MotionEvent event) {
  if (getParent() != null) {
   getParent().requestDisallowInterceptTouchEvent(true);
  }

  if (isOnAnimator) {
   return false;
  }
  int action = event.getAction();

  switch (action) {
   case MotionEvent.ACTION_DOWN:
    if (mAdapter==null){
     return false;
    }
    onTouchMove = true;
    if (mScroller.computeScrollOffset()) {
     mScroller.abortAnimation();
     invalidate();
     requestLayout();
    }
    touchBegan(event);
    touchViewItem = getTopView();
    isOnTopView = inRangeOfView(touchViewItem, event);
    if (isOnTopView) {
     sendLongClickAction();
    }
    return true;
   case MotionEvent.ACTION_MOVE:
    touchMoved(event);
    removeLongClickAction();
    touchViewItem = null;
    isOnTopView = false;
    return true;
   case MotionEvent.ACTION_UP:
    removeLongClickAction();
    if (isOnTopView && touchViewItem == getTopView()
      && inRangeOfView(touchViewItem, event)) {

     if (mTopViewClickListener != null) {
      mTopViewClickListener.onClick(getTopViewPosition(), getTopView());
     }
    }
    touchViewItem = null;
    isOnTopView = false;
    touchEnded(event);
    return true;
  }

  return false;
 }

 private Runnable longClickRunnable = null;

 /**
  * 发送长点击事件 Runnable
  */
 private void sendLongClickAction() {
  removeLongClickAction();
  longClickRunnable = new Runnable() {
   @Override
   public void run() {
    touchViewItem = null;
    isOnTopView = false;
    if (mTopViewLongClickListener != null) {
     mTopViewLongClickListener.onLongClick(getTopViewPosition(), getTopView());
    }
   }
  };
  postDelayed(longClickRunnable, 600);
 }

 /**
  * 移除长点击事件 Runnable
  */
 private void removeLongClickAction() {
  if (longClickRunnable != null) {
   removeCallbacks(longClickRunnable);
   longClickRunnable = null;
  }
 }

 private boolean inRangeOfView(View view, MotionEvent ev) {
  Rect frame = new Rect();
  view.getHitRect(frame);
  if (frame.contains((int) ev.getX(), (int) ev.getY())) {
   return true;
  }
  return false;
 }

 private OnTopViewClickListener mTopViewClickListener;
 private OnTopViewLongClickListener mTopViewLongClickListener;
 private OnTopViewChangeListener mTopViewChangeListener;

 /**
  * 设置 TopView 的点击监听
  *
  * @param topViewClickListener
  */
 public void setOnTopViewClickListener(OnTopViewClickListener topViewClickListener) {
  this.mTopViewClickListener = topViewClickListener;
 }

 /**
  * 获取 TopView 的点击监听
  *
  * @return
  */
 public OnTopViewClickListener getOnTopViewClickListener() {
  return this.mTopViewClickListener;
 }

 /**
  * 设置 TopView 的长点击监听
  *
  * @param topViewLongClickListener
  */
 public void setOnTopViewLongClickListener(OnTopViewLongClickListener topViewLongClickListener) {
  this.mTopViewLongClickListener = topViewLongClickListener;
 }

 /**
  * 设置 TopView 的长点击监听
  *
  * @param mTopViewChangeListener
  */
 public void setOnTopViewChangeListener(OnTopViewChangeListener mTopViewChangeListener) {
  this.mTopViewChangeListener = mTopViewChangeListener;
 }

 /**
  * 获取 TopView 的长点击监听
  *
  * @return
  */
 public OnTopViewLongClickListener getOnTopViewLongClickListener() {
  return this.mTopViewLongClickListener;
 }

 public interface OnTopViewClickListener {

  void onClick(int position, View itemView);

 }

 public interface OnTopViewLongClickListener {

  void onLongClick(int position, View itemView);

 }

 public interface OnTopViewChangeListener {

  void onItemChange(int position);

 }

 private boolean mTouchMoved;
 private float mTouchStartPos;
 private float mTouchStartX;
 private float mTouchStartY;

 private long mStartTime;
 private float mStartOffset;

 private void touchBegan(MotionEvent event) {
  endAnimation();

  float x = event.getX();
  mTouchStartX = x;
  mTouchStartY = event.getY();
  mStartTime = AnimationUtils.currentAnimationTimeMillis();
  mStartOffset = mOffset;

  mTouchMoved = false;

  mTouchStartPos = (x / mWidth) * MOVE_POS_MULTIPLE - 5;
  mTouchStartPos /= 2;

  mVelocity = VelocityTracker.obtain();
  mVelocity.addMovement(event);
 }

 private Runnable mAnimationRunnable;

 private void endAnimation() {
  if (mAnimationRunnable != null) {
   mOffset = (float) Math.floor(mOffset + 0.5);

   invalidate();
   requestLayout();

   removeCallbacks(mAnimationRunnable);
   mAnimationRunnable = null;
  }
 }

 private void touchMoved(MotionEvent event) {
  float pos = (event.getX() / mWidth) * MOVE_POS_MULTIPLE - 5;
  pos /= 2;

  if (!mTouchMoved) {
   float dx = Math.abs(event.getX() - mTouchStartX);
   float dy = Math.abs(event.getY() - mTouchStartY);
   if (dx < TOUCH_MINIMUM_MOVE && dy < TOUCH_MINIMUM_MOVE)
    return;
   mTouchMoved = true;
  }

  mOffset = mStartOffset + mTouchStartPos - pos;

  invalidate();
  requestLayout();
  mVelocity.addMovement(event);
 }

 private void touchEnded(MotionEvent event) {
  float pos = (event.getX() / mWidth) * MOVE_POS_MULTIPLE - 5;
  pos /= 2;

  if (mTouchMoved || (mOffset - Math.floor(mOffset)) != 0) {
   mStartOffset += mTouchStartPos - pos;
   mOffset = mStartOffset;

   mVelocity.addMovement(event);

   mVelocity.computeCurrentVelocity(1000);
   float speed = mVelocity.getXVelocity();

   speed = (speed / mWidth) * MOVE_SPEED_MULTIPLE;
   if (speed > MAX_SPEED)
    speed = MAX_SPEED;
   else if (speed < -MAX_SPEED)
    speed = -MAX_SPEED;

   startAnimation(-speed);

   if (mTopViewChangeListener != null) {
    mTopViewChangeListener.onItemChange(getTopViewPosition());
   }
  } else {
   Log.e("xyw", " touch ==>" + event.getX() + " , " + event.getY());
   onTouchMove = false;
  }

  mVelocity.clear();
  mVelocity.recycle();
 }

 private float mStartSpeed;
 private float mDuration;

 private void startAnimation(float speed) {
  if (mAnimationRunnable != null) {
   onTouchMove = false;
   return;
  }

  float delta = speed * speed / (FRICTION * 2);
  if (speed < 0)
   delta = -delta;

  float nearest = mStartOffset + delta;
  nearest = (float) Math.floor(nearest + 0.5f);

  mStartSpeed = (float) Math.sqrt(Math.abs(nearest - mStartOffset) * FRICTION * 2);
  if (nearest < mStartOffset)
   mStartSpeed = -mStartSpeed;

  mDuration = Math.abs(mStartSpeed / FRICTION);
  mStartTime = AnimationUtils.currentAnimationTimeMillis();

  mAnimationRunnable = new Runnable() {
   @Override
   public void run() {
    driveAnimation();
   }
  };
  post(mAnimationRunnable);
 }

 private void driveAnimation() {
  float elapsed = (AnimationUtils.currentAnimationTimeMillis() - mStartTime) / 1000.0f;
  if (elapsed >= mDuration) {
   endAnimation();
   onTouchMove = false;
  } else {
   updateAnimationAtElapsed(elapsed);
   post(mAnimationRunnable);
  }
 }

 private void updateAnimationAtElapsed(float elapsed) {
  if (elapsed > mDuration)
   elapsed = mDuration;

  float delta = Math.abs(mStartSpeed) * elapsed - FRICTION * elapsed * elapsed / 2;
  if (mStartSpeed < 0)
   delta = -delta;

  mOffset = mStartOffset + delta;
  invalidate();
  requestLayout();
 }

 @Override
 public void computeScroll() {
  super.computeScroll();

  // 算出移动到某一个虚拟点时 mOffset 的值，然后 invalidate 重绘
  if (mScroller.computeScrollOffset()) {
   final int currX = mScroller.getCurrX();
   mOffset = (float) currX / 100;

   invalidate();
  }
 }

 private boolean isOnAnimator = false; //是否正在进行点击切换动画

 /**
  * 翻到前页
  */
 public void gotoPrevious() {
  doAnimator(-1.0f);

 }

 /**
  * 前进到后一页
  */
 public void gotoForward() {
  doAnimator(1.0f);
 }

 public void doAnimator(float target) {
  if (isOnAnimator || onTouchMove) { //如果正在执行点击切换动画 或者 正在执行触摸移动
   return;
  }
  isOnAnimator = true;
  ValueAnimator animator = ValueAnimator.ofFloat(mOffset, mOffset + target);
  animator.setDuration(300).start();
  animator.setInterpolator(new AccelerateDecelerateInterpolator());
  animator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {

   @Override
   public void onAnimationUpdate(ValueAnimator animation) {
    mOffset = (Float) animation.getAnimatedValue();

    invalidate();
    requestLayout();
   }
  });
  animator.addListener(new Animator.AnimatorListener() {
   @Override
   public void onAnimationStart(Animator animation) {
   }

   @Override
   public void onAnimationCancel(Animator animation) {
   }

   @Override
   public void onAnimationRepeat(Animator animation) {
   }

   @Override
   public void onAnimationEnd(Animator animation) {
    isOnAnimator = false;
   }
  });
 }

// @Override
// public boolean dispatchTouchEvent(MotionEvent ev) {
//  if (ev.getAction() == MotionEvent.ACTION_MOVE) {
//   return true; // 禁止滑动
//  }
//  return super.dispatchTouchEvent(ev);
// }
}

public interface ICoverFlowAdapter {

 int getCount();
 Object getItem(int position);
 long getItemId(int position);
 View getView(int position, View convertView, ViewGroup parent);

 void getData(View view, int position);
}