自定义viewpager与自定义imageview实现图片显示

自定义放大缩小imageview


import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.Color;
import android.graphics.Matrix;
import android.graphics.PointF;
import android.util.AttributeSet;
import android.view.GestureDetector;
import android.view.GestureDetector.SimpleOnGestureListener;
import android.view.MotionEvent;
import android.view.View;
import android.view.ViewTreeObserver;
import android.widget.ImageView;

/**
 * @ClassName: MatrixImageView
 * @Description:  带放大、缩小、移动效果的ImageView
 *
 */
public class MatrixImageView extends ImageView{
   public final static String TAG="MatrixImageView";
   private GestureDetector mGestureDetector;
   /**  模板Matrix，用以初始化 */
   private  Matrix mMatrix=new Matrix();
   /**  图片长度*/
   private float mImageWidth;
   /**  图片高度 */
   private float mImageHeight;
   /**  原始缩放级别 */
   private float mScale
         ;
   private OnMovingListener moveListener;
   private OnSingleTapListener singleTapListener;

   public MatrixImageView(Context context, AttributeSet attrs) {
      super(context, attrs);
      MatrixTouchListener mListener=new MatrixTouchListener();
      setOnTouchListener(mListener);
      mGestureDetector=new GestureDetector(getContext(), new GestureListener(mListener));
      //背景设置为balck
      setBackgroundColor(Color.BLACK);
      //将缩放类型设置为CENTER_INSIDE，表示把图片居中显示,并且宽高最大值为控件宽高
      setScaleType(ScaleType.FIT_CENTER);
   }
   public MatrixImageView(Context context) {
      super(context, null);
      MatrixTouchListener mListener=new MatrixTouchListener();
      setOnTouchListener(mListener);
      mGestureDetector=new GestureDetector(getContext(), new GestureListener(mListener));
      //背景设置为balck
      setBackgroundColor(Color.BLACK);
      //将缩放类型设置为CENTER_INSIDE，表示把图片居中显示,并且宽高最大值为控件宽高
      setScaleType(ScaleType.FIT_CENTER);
   }
   public void setOnMovingListener(OnMovingListener listener){
      moveListener=listener;
   }
   public void setOnSingleTapListener(OnSingleTapListener onSingleTapListener) {
      this.singleTapListener = onSingleTapListener;
   }
   @Override
   public void setImageBitmap(Bitmap bm) {
      // TODO Auto-generated method stub
      super.setImageBitmap(bm);
      //大小为0 表示当前控件大小未测量  设置监听函数  在绘制前赋值
      if(getWidth()==0){
         ViewTreeObserver vto = getViewTreeObserver();
         vto.addOnPreDrawListener(new ViewTreeObserver.OnPreDrawListener()
         {
            public boolean onPreDraw()
            {
               initData();
               //赋值结束后，移除该监听函数
               MatrixImageView.this.getViewTreeObserver().removeOnPreDrawListener(this);
               return true;
            }
         });
      }else {
         initData();
      }
   }

   /**
    *   初始化模板Matrix和图片的其他数据
    */
   private void initData() {
      //设置完图片后，获取该图片的坐标变换矩阵
      mMatrix.set(getImageMatrix());
      float[] values=new float[9];
      mMatrix.getValues(values);
      //图片宽度为屏幕宽度除缩放倍数
      mImageWidth=getWidth()/values[Matrix.MSCALE_X];
      mImageHeight=(getHeight()-values[Matrix.MTRANS_Y]*2)/values[Matrix.MSCALE_Y];
      mScale=values[Matrix.MSCALE_X];
   }

   public class MatrixTouchListener implements OnTouchListener{
      /** 拖拉照片模式 */
      private static final int MODE_DRAG = 1;
      /** 放大缩小照片模式 */
      private static final int MODE_ZOOM = 2;
      /**  不支持Matrix */
      private static final int MODE_UNABLE=3;
      /**   最大缩放级别*/
      float mMaxScale=6;
      /**   双击时的缩放级别*/
      float mDobleClickScale=2;
      private int mMode = 0;// 
      /**  缩放开始时的手指间距 */
      private float mStartDis;
      /**   当前Matrix*/
      private Matrix mCurrentMatrix = new Matrix();

      /** 用于记录开始时候的坐标位置 */

      /** 和ViewPager交互相关，判断当前是否可以左移、右移  */
      boolean mLeftDragable;
      boolean mRightDragable;
      /**  是否第一次移动 */
      boolean mFirstMove=false;
      private PointF mStartPoint = new PointF();
      @Override
      public boolean onTouch(View v, MotionEvent event) {
         // TODO Auto-generated method stub
         switch (event.getActionMasked()) {
            case MotionEvent.ACTION_DOWN:
               //设置拖动模式
               mMode=MODE_DRAG;
               mStartPoint.set(event.getX(), event.getY());
               isMatrixEnable();
               startDrag();
               checkDragable();
               break;
            case MotionEvent.ACTION_UP:
            case MotionEvent.ACTION_CANCEL:
               reSetMatrix();
               stopDrag();
               break;
            case MotionEvent.ACTION_MOVE:
               if (mMode == MODE_ZOOM) {
                  setZoomMatrix(event);
               }else if (mMode==MODE_DRAG) {
                  setDragMatrix(event);
               }else {
                  stopDrag();
               }
               break;
            case MotionEvent.ACTION_POINTER_DOWN:
               if(mMode==MODE_UNABLE) return true;
               mMode=MODE_ZOOM;
               mStartDis = distance(event);
               break;
            case MotionEvent.ACTION_POINTER_UP:

               break;
            default:
               break;
         }
         return mGestureDetector.onTouchEvent(event);
      }

      /**
       *   子控件开始进入移动状态，令ViewPager无法拦截对子控件的Touch事件
       */
      private void startDrag(){
         if(moveListener!=null) moveListener.startDrag();

      }
      /**
       *   子控件开始停止移动状态，ViewPager将拦截对子控件的Touch事件
       */
      private void stopDrag(){
         if(moveListener!=null) moveListener.stopDrag();
      }

      /**
       *   根据当前图片左右边缘设置可拖拽状态
       */
      private void checkDragable() {
         mLeftDragable=true;
         mRightDragable=true;
         mFirstMove=true;
         float[] values=new float[9];
         getImageMatrix().getValues(values);
         //图片左边缘离开左边界，表示不可右移
         if(values[Matrix.MTRANS_X]>=0)
            mRightDragable=false;
         //图片右边缘离开右边界，表示不可左移
         if((mImageWidth)*values[Matrix.MSCALE_X]+values[Matrix.MTRANS_X]<=getWidth()){
            mLeftDragable=false;
         }
      }

      /**
       *  设置拖拽状态下的Matrix
       *  @param event
       */
      public void setDragMatrix(MotionEvent event) {
         if(isZoomChanged()){
            float dx = event.getX() - mStartPoint.x; // 得到x轴的移动距离
            float dy = event.getY() - mStartPoint.y; // 得到x轴的移动距离
            //避免和双击冲突,大于10f才算是拖动
            if(Math.sqrt(dx*dx+dy*dy)>10f){
               mStartPoint.set(event.getX(), event.getY());
               //在当前基础上移动
               mCurrentMatrix.set(getImageMatrix());
               float[] values=new float[9];
               mCurrentMatrix.getValues(values);
               dy=checkDyBound(values,dy);
               dx=checkDxBound(values,dx,dy);

               mCurrentMatrix.postTranslate(dx, dy);
               setImageMatrix(mCurrentMatrix);
            }
         }else {
            stopDrag();
         }
      }

      /**
       *  判断缩放级别是否是改变过
       *  @return   true表示非初始值,false表示初始值
       */
      private boolean isZoomChanged() {
         float[] values=new float[9];
         getImageMatrix().getValues(values);
         //获取当前X轴缩放级别
         float scale=values[Matrix.MSCALE_X];
         //获取模板的X轴缩放级别，两者做比较
         return scale!=mScale;
      }

      /**
       *  和当前矩阵对比，检验dy，使图像移动后不会超出ImageView边界
       *  @param values
       *  @param dy
       *  @return
       */
      private float checkDyBound(float[] values, float dy) {
         float height=getHeight();
         if(mImageHeight*values[Matrix.MSCALE_Y]<height)
            return 0;
         if(values[Matrix.MTRANS_Y]+dy>0)
            dy=-values[Matrix.MTRANS_Y];
         else if(values[Matrix.MTRANS_Y]+dy<-(mImageHeight*values[Matrix.MSCALE_Y]-height))
            dy=-(mImageHeight*values[Matrix.MSCALE_Y]-height)-values[Matrix.MTRANS_Y];
         return dy;
      }

      /**
       *  和当前矩阵对比，检验dx，使图像移动后不会超出ImageView边界
       *  @param values
       *  @param dx
       *  @return
       */
      private float checkDxBound(float[] values,float dx,float dy) {
         float width=getWidth();
         if(!mLeftDragable&&dx<0){
            //加入和y轴的对比，表示在监听到垂直方向的手势时不切换Item
            if(Math.abs(dx)*0.4f>Math.abs(dy)&&mFirstMove){
               stopDrag();
            }
            return 0;
         }
         if(!mRightDragable&&dx>0){
            //加入和y轴的对比，表示在监听到垂直方向的手势时不切换Item
            if(Math.abs(dx)*0.4f>Math.abs(dy)&&mFirstMove){
               stopDrag();
            }
            return 0;
         }
         mLeftDragable=true;
         mRightDragable=true;
         if(mFirstMove) mFirstMove=false;
         if(mImageWidth*values[Matrix.MSCALE_X]<width){
            return 0;

         }
         if(values[Matrix.MTRANS_X]+dx>0){
            dx=-values[Matrix.MTRANS_X];
         }
         else if(values[Matrix.MTRANS_X]+dx<-(mImageWidth*values[Matrix.MSCALE_X]-width)){
            dx=-(mImageWidth*values[Matrix.MSCALE_X]-width)-values[Matrix.MTRANS_X];
         }
         return dx;
      }

      /**
       *  设置缩放Matrix
       *  @param event
       */
      private void setZoomMatrix(MotionEvent event) {
         //只有同时触屏两个点的时候才执行
         if(event.getPointerCount()<2) return;
         float endDis = distance(event);// 结束距离
         if (endDis > 10f) { // 两个手指并拢在一起的时候像素大于10
            float scale = endDis / mStartDis;// 得到缩放倍数
            mStartDis=endDis;//重置距离
            mCurrentMatrix.set(getImageMatrix());//初始化Matrix
            float[] values=new float[9];
            mCurrentMatrix.getValues(values);
            scale = checkMaxScale(scale, values);
            PointF centerF=getCenter(scale,values);
            mCurrentMatrix.postScale(scale, scale,centerF.x,centerF.y);
            setImageMatrix(mCurrentMatrix);
         }
      }

      /**
       *  获取缩放的中心点。
       *  @param scale
       *  @param values
       *  @return
       */
      private PointF getCenter(float scale,float[] values) {
         //缩放级别小于原始缩放级别时或者为放大状态时，返回ImageView中心点作为缩放中心点
         if(scale*values[Matrix.MSCALE_X]<mScale||scale>=1){
            return new PointF(getWidth()/2,getHeight()/2);
         }
         float cx=getWidth()/2;
         float cy=getHeight()/2;
         //以ImageView中心点为缩放中心，判断缩放后的图片左边缘是否会离开ImageView左边缘，是的话以左边缘为X轴中心
         if((getWidth()/2-values[Matrix.MTRANS_X])*scale<getWidth()/2)
            cx=0;
         //判断缩放后的右边缘是否会离开ImageView右边缘，是的话以右边缘为X轴中心
         if((mImageWidth*values[Matrix.MSCALE_X]+values[Matrix.MTRANS_X])*scale<getWidth())
            cx=getWidth();
         return new PointF(cx,cy);
      }

      /**
       *  检验scale，使图像缩放后不会超出最大倍数
       *  @param scale
       *  @param values
       *  @return
       */
      private float checkMaxScale(float scale, float[] values) {
         if(scale*values[Matrix.MSCALE_X]>mMaxScale)
            scale=mMaxScale/values[Matrix.MSCALE_X];
         return scale;
      }

      /**
       *   重置Matrix
       */
      private void reSetMatrix() {
         if(checkRest()){
            mCurrentMatrix.set(mMatrix);
            setImageMatrix(mCurrentMatrix);
         }else {
            //判断Y轴是否需要更正
            float[] values=new float[9];
            getImageMatrix().getValues(values);
            float height=mImageHeight*values[Matrix.MSCALE_Y];
            if(height<getHeight()){
               //在图片真实高度小于容器高度时，Y轴居中，Y轴理想偏移量为两者高度差/2，
               float topMargin=(getHeight()-height)/2;
               if(topMargin!=values[Matrix.MTRANS_Y]){
                  mCurrentMatrix.set(getImageMatrix());
                  mCurrentMatrix.postTranslate(0, topMargin-values[Matrix.MTRANS_Y]);
                  setImageMatrix(mCurrentMatrix);
               }
            }
         }
      }

      /**
       *  判断是否需要重置
       *  @return  当前缩放级别小于模板缩放级别时，重置 
       */
      private boolean checkRest() {
         // TODO Auto-generated method stub
         float[] values=new float[9];
         getImageMatrix().getValues(values);
         //获取当前X轴缩放级别
         float scale=values[Matrix.MSCALE_X];
         //获取模板的X轴缩放级别，两者做比较
         return scale<mScale;
      }

      /**
       *  判断是否支持Matrix
       */
      private void isMatrixEnable() {
         //当加载出错时，不可缩放
         if(getScaleType()!=ScaleType.CENTER){
            setScaleType(ScaleType.MATRIX);
         }else {
            mMode=MODE_UNABLE;//设置为不支持手势
         }
      }

      /**
       *  计算两个手指间的距离
       *  @param event
       *  @return
       */
      private float distance(MotionEvent event) {
         float dx = event.getX(1) - event.getX(0);
         float dy = event.getY(1) - event.getY(0);
         /** 使用勾股定理返回两点之间的距离 */
         return (float) Math.sqrt(dx * dx + dy * dy);
      }

      /**
       *   双击时触发
       */
      public void onDoubleClick(){
         float scale=isZoomChanged()?1:mDobleClickScale;
         mCurrentMatrix.set(mMatrix);//初始化Matrix
         mCurrentMatrix.postScale(scale, scale,getWidth()/2,getHeight()/2);
         setImageMatrix(mCurrentMatrix);
      }
   }


   private class  GestureListener extends SimpleOnGestureListener{
      private final MatrixTouchListener listener;
      public GestureListener(MatrixTouchListener listener) {
         this.listener=listener;
      }
      @Override
      public boolean onDown(MotionEvent e) {
         //捕获Down事件
         return true;
      }
      @Override
      public boolean onDoubleTap(MotionEvent e) {
         //触发双击事件
         listener.onDoubleClick();
         return true;
      }
      @Override
      public boolean onSingleTapUp(MotionEvent e) {
         // TODO Auto-generated method stub
         return super.onSingleTapUp(e);
      }

      @Override
      public void onLongPress(MotionEvent e) {
         // TODO Auto-generated method stub
         super.onLongPress(e);
      }

      @Override
      public boolean onScroll(MotionEvent e1, MotionEvent e2,
                        float distanceX, float distanceY) {
         return super.onScroll(e1, e2, distanceX, distanceY);
      }

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

      @Override
      public void onShowPress(MotionEvent e) {
         // TODO Auto-generated method stub
         super.onShowPress(e);
      }

      @Override
      public boolean onDoubleTapEvent(MotionEvent e) {
         // TODO Auto-generated method stub
         return super.onDoubleTapEvent(e);
      }

      @Override
      public boolean onSingleTapConfirmed(MotionEvent e) {
         if(singleTapListener!=null) singleTapListener.onSingleTap();
         return super.onSingleTapConfirmed(e);
      }

   }
   /**
    * @ClassName: OnChildMovingListener
    * @Description:  MatrixImageView移动监听接口,用以组织ViewPager对Move操作的拦截
    *
    */
   public interface OnMovingListener{
      public void  startDrag();
      public void  stopDrag();
   }

   /**
    * @ClassName: OnSingleTapListener
    * @Description:  监听ViewPager屏幕单击事件，本质是监听子控件MatrixImageView的单击事件
    *
    */
   public interface OnSingleTapListener{
      public void onSingleTap();
   }


自定义viewpager


import android.content.Context;
import android.support.v4.view.ViewPager;
import android.util.AttributeSet;
import android.view.MotionEvent;


/**
 * @author LinJ
 * @ClassName: AlbumViewPager
 * @Description: 自定义viewpager  优化了事件拦截
 */
public class AlbumViewPager extends ViewPager implements MatrixImageView.OnMovingListener {
    public final static String TAG = "AlbumViewPager";


    /**
     * 当前子控件是否处理拖动状态
     */
    private boolean mChildIsBeingDragged = false;


    public AlbumViewPager(Context context, AttributeSet attrs) {
        super(context, attrs);
    }


    @Override
    public boolean onInterceptTouchEvent(MotionEvent arg0) {
        if (mChildIsBeingDragged)
            return false;
        return super.onInterceptTouchEvent(arg0);
    }

    @Override
    public void startDrag() {
        mChildIsBeingDragged = true;
    }


    @Override
    public void stopDrag() {
        mChildIsBeingDragged = false;
    }
}