Android 手势滑动，多点触摸放大缩小图片

效果展示:

基本思路：

<1>首先写一个图片控制类ImageControl，实现对图片控制的的基本操作，我们的图片控制类ImageControl是继承自ImageView自定义的视图；

<2>再写一个测试用的布局，这里就要用到自定义的ImageView;

<3>编写测试类ImageViewActivity，写onTouchEvent（）方法；

图片控制类ImageControl:

 package com.basecontrol.view;

 import android.content.Context;
 import android.graphics.Bitmap;
 import android.graphics.Matrix;
 import android.util.AttributeSet;
 import android.util.FloatMath;
 import android.view.MotionEvent;
 import android.widget.ImageView;

 public class ImageControl extends ImageView {

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

     Matrix imgMatrix=null;//定义图片的变换矩阵 

     static final int DOUBLE_CLICK_TIME_SPACE=300;//双击时间间隔
     static final int DOUBLE_POINT_DISTANCE =10;// 两点放大两点间最小间距
     static final int NONE = 0;
     private int mode=NONE;//当前模式
     static final int DRAG=1;
     static final int ZOOM = 2; // 放大缩小操作  

     float bigScale=3f;//默认放大倍数
     Boolean isBig=false;//是否放大
     long lastClickTime =0;//单击时间
     float startDistance;//两点触摸两点距离
     float endDistance;//多点触摸两点距离 

     float topHeight;//状态栏高度和标题栏高度
     Bitmap primaryBitmap=null; 

     float contentW;//屏幕内容区宽度
     float contentH;//屏幕内容区高度 

     float primaryW;//原图宽度
     float primaryH;//原图高度 

     float scale; // 适合屏幕缩放倍数
     Boolean isMoveX = true; // 是否允许在X轴拖动
     Boolean isMoveY = true; // 是否允许在Y轴拖动
     float startX;
     float startY;
     float endX;
     float endY;
     float subX;
     float subY;
     float limitX1;
     float limitX2;
     float limitY1;
     float limitY2;
     ICustomMethod mCustomMethod=null;
     /**
      * @param bitmap 要显示的图片
      * @param contentW 内容区域宽度
      * @param contentH 内容区域高度
      * @param topHeight 状态栏高度和标题栏高度之和
      * @param iCustomMethod
      */
     public void imageInit(Bitmap bitmap,int contentW,int contentH,int topHeight,ICustomMethod iCustomMethod)
     {
         this.primaryBitmap=bitmap;
         this.contentW=contentH;
         this.contentH=contentH;
         this.topHeight=topHeight;
         mCustomMethod=iCustomMethod;
         primaryW=primaryBitmap.getWidth();
         primaryH=primaryBitmap.getHeight();
         float scaleX=(float)contentW/primaryW;
         float scaleY=(float)contentH/primaryH;
         scale=scaleX<scaleY?scaleX:scaleY;
         if (scale<1&&1/scale<bigScale)
         {
             bigScale=(float)(1/scale+0.5);
         } 

         imgMatrix=new Matrix();
         subX = (contentW-primaryW*scale)/2;
         subY=(contentH-primaryH*scale)/2;
         this.setImageBitmap(primaryBitmap);
         this.setScaleType(ScaleType.MATRIX);
         imgMatrix.postScale(scale, scale);
         imgMatrix.postTranslate(subX,subY);
         this.setImageMatrix(imgMatrix);
     }
     /**
      * 按下操作
      * @param event
      */
     public void mouseDown(MotionEvent event)
     {
         mode=NONE;
         startX=event.getRawX();
         startY=event.getRawY();
         if (event.getPointerCount()==1)
         {
             //如果两次时间间隔小于一定值，则默认为双击事件
             if (event.getEventTime()-lastClickTime<DOUBLE_CLICK_TIME_SPACE)
             {
                 changeSize(startX,startY);
             }
             else if (isBig)
             {
                 mode=DRAG;
             }
         }
         lastClickTime=event.getEventTime();
     }
     /**
      * 非第一个点按下操作
      * @param event
      */
     public void mousePointDown(MotionEvent event)
     {
         startDistance=getDistance(event);
         if (startDistance > DOUBLE_POINT_DISTANCE) {
             mode = ZOOM;
         } else {
             mode = NONE;
         }
     }
      public void mouseMove(MotionEvent event)
      {
         if ((mode == DRAG) && (isMoveX || isMoveY)) {
             float[] XY = getTranslateXY(imgMatrix);
             float transX = 0;
             float transY = 0;
             if (isMoveX) {
                 endX = event.getRawX();
                 transX = endX - startX;
                 if ((XY[0] + transX) <= limitX1) {
                     transX = limitX1 - XY[0];
                 }
                 if ((XY[0] + transX) >= limitX2) {
                     transX = limitX2 - XY[0];
                 }
             }
             if (isMoveY) {
                 endY = event.getRawY();
                 transY = endY - startY;
                 if ((XY[1] + transY) <= limitY1) {
                     transY = limitY1 - XY[1];
                 }
                 if ((XY[1] + transY) >= limitY2) {
                     transY = limitY2 - XY[1];
                 }
             }  

             imgMatrix.postTranslate(transX, transY);
             startX = endX;
             startY = endY;
             this.setImageMatrix(imgMatrix);
         } else if (mode == ZOOM && event.getPointerCount() > 1) {
             endDistance = getDistance(event);
             float dif = endDistance - startDistance;
             if (Math.abs(endDistance - startDistance) > DOUBLE_POINT_DISTANCE) {
                 if (isBig) {
                     if (dif < 0) {
                         changeSize(0, 0);
                         mode = NONE;
                     }
                 } else if (dif > 0) {
                     float x = event.getX(0) / 2 + event.getX(1) / 2;
                     float y = event.getY(0) / 2 + event.getY(1) / 2;
                     changeSize(x, y);
                     mode = NONE;
                 }
             }
         }
     }
      /**
       * 鼠标抬起事件
       */
     public void mouseUp()
     {
         mode = NONE;
     }
     private void changeSize(float x, float y) {
         if (isBig) {
             // 如果处于最大状态，则还原
             imgMatrix.reset();
             imgMatrix.postScale(scale, scale);
             imgMatrix.postTranslate(subX, subY);
             isBig = false;
         } else {
             imgMatrix.postScale(bigScale, bigScale); // 在原有矩阵后乘放大倍数
             float transX = -((bigScale - 1) * x);
             float transY = -((bigScale - 1) * (y - topHeight)); // (bigScale-1)(y-statusBarHeight-subY)+2*subY;
             float currentWidth = primaryW * scale * bigScale; // 放大后图片大小
             float currentHeight = primaryH * scale * bigScale;
             // 如果图片放大后超出屏幕范围处理
             if (currentHeight > contentH) {
                 limitY1 = -(currentHeight - contentH); // 平移限制
                 limitY2 = 0;
                 isMoveY = true; // 允许在Y轴上拖动
                 float currentSubY = bigScale * subY; // 当前平移距离
                 // 平移后，内容区域上部有空白处理办法
                 if (-transY < currentSubY) {
                     transY = -currentSubY;
                 }
                 // 平移后，内容区域下部有空白处理办法
                 if (currentSubY + transY < limitY1) {
                     transY = -(currentHeight + currentSubY - contentH);
                 }
             } else {
                 // 如果图片放大后没有超出屏幕范围处理，则不允许拖动
                 isMoveY = false;
             }  

             if (currentWidth > contentW) {
                 limitX1 = -(currentWidth - contentW);
                 limitX2 = 0;
                 isMoveX = true;
                 float currentSubX = bigScale * subX;
                 if (-transX < currentSubX) {
                     transX = -currentSubX;
                 }
                 if (currentSubX + transX < limitX1) {
                     transX = -(currentWidth + currentSubX - contentW);
                 }
             } else {
                 isMoveX = false;
             }  

             imgMatrix.postTranslate(transX, transY);
             isBig = true;
         }  

         this.setImageMatrix(imgMatrix);
         if (mCustomMethod != null) {
             mCustomMethod.customMethod(isBig);
         }
     }
     /**
      * 获取变换矩阵中X轴偏移量和Y轴偏移量
      * @param matrix
      * @return
      */
     private float[] getTranslateXY(Matrix matrix)
     {
         float[] values = new float[9];
         matrix.getValues(values);
         float[] floats = new float[2];
         floats[0] = values[Matrix.MTRANS_X];
         floats[1] = values[Matrix.MTRANS_Y];
         return floats;
     }
     /**
      * 获取两点间距离
      * @param event
      * @return
      */
     private float getDistance(MotionEvent event)
     {
         float x = event.getX(0) - event.getX(1);
         float y = event.getY(0) - event.getY(1);
         return FloatMath.sqrt(x * x + y * y);
     }
     /**
      * 用户自定义方法
      * @author AILALA
      */
     public interface ICustomMethod
     {
         public void customMethod(Boolean currentStatus);
     }
 }

ImageControl

测试布局：

 <?xml version="1.0" encoding="utf-8"?>
 <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
     android:layout_width="match_parent"
     android:layout_height="match_parent" > 

     <com.basecontrol.view.ImageControl
         android:id="@+id/common_imageview_imageControll"
         android:layout_width="fill_parent"
         android:layout_height="fill_parent"
         android:src="@drawable/ic_launcher"/>

     <LinearLayout
         android:id="@+id/common_iamgeview_llTitle"
         android:layout_width="wrap_content"
         android:layout_height="wrap_content"
         android:layout_alignParentLeft="true"
         android:layout_alignParentTop="true" > 

         <TextView
             android:id="@+id/common_imageview_title"
             android:layout_width="fill_parent"
             android:layout_height="wrap_content"
             android:text="报告"/>
     </LinearLayout>
 </RelativeLayout>

测试的Activity:

 package com.basecontrol.ui;

 import com.basecontrol.view.ImageControl;
 import com.basecontrol.view.ImageControl.ICustomMethod;
 import com.example.basecontrol.R;
 import android.app.Activity;
 import android.graphics.Bitmap;
 import android.graphics.Rect;
 import android.graphics.drawable.BitmapDrawable;
 import android.os.Bundle;
 import android.view.MotionEvent;
 import android.view.View;
 import android.widget.LinearLayout;
 import android.widget.TextView;
 import android.widget.Toast;

 public class ImageViewActivity extends Activity
 {

     @Override
     protected void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
         setContentView(R.layout.bc_common_image_view);
         findView();
     } 

     public void onWindowFocusChanged(boolean hasFocus)
     {
         super.onWindowFocusChanged(hasFocus);
         init();
     }; 

     ImageControl imgControl;
     LinearLayout llTitle;
     TextView tvTitle;
     private void findView()
     {
         imgControl=(ImageControl) findViewById(R.id.common_imageview_imageControll);
         llTitle=(LinearLayout) findViewById(R.id.common_iamgeview_llTitle);
         tvTitle=(TextView) findViewById(R.id.common_imageview_title);
     } 

     private void init() {
         tvTitle.setText("图片测试");
         // 这里可以为imgcontrol的图片路径动态赋值
         // ............  

         Bitmap bmp;
         if (imgControl.getDrawingCache() != null) {
             bmp = Bitmap.createBitmap(imgControl.getDrawingCache());
         } else {
             bmp = ((BitmapDrawable)imgControl.getDrawable()).getBitmap();
         }
         Rect frame = new Rect();
         getWindow().getDecorView().getWindowVisibleDisplayFrame(frame);
         int statusBarHeight = frame.top;
         int screenW = this.getWindowManager().getDefaultDisplay().getWidth();
         int screenH = this.getWindowManager().getDefaultDisplay().getHeight()
                 - statusBarHeight;
         if (bmp != null) {
             imgControl.imageInit(bmp, screenW, screenH, statusBarHeight,
                     new ICustomMethod() {
                         @Override
                         public void customMethod(Boolean currentStatus) {
                             // 当图片处于放大或缩小状态时，控制标题是否显示
                             if (currentStatus) {
                                 llTitle.setVisibility(View.GONE);
                             } else {
                                 llTitle.setVisibility(View.VISIBLE);
                             }
                         }
                     });
         }
         else
         {
             Toast.makeText(ImageViewActivity.this, "图片加载失败，请稍候再试！", Toast.LENGTH_SHORT)
                     .show();
         }  

     }
     @Override
     public boolean onTouchEvent(MotionEvent event) {
         switch (event.getAction()&MotionEvent.ACTION_MASK) {
         case MotionEvent.ACTION_DOWN:
             imgControl.mouseDown(event);
             break;
         case MotionEvent.ACTION_POINTER_DOWN:
             imgControl.mousePointDown(event);
             break;
         case MotionEvent.ACTION_MOVE:
             imgControl.mouseMove(event);
             break;
         case MotionEvent.ACTION_UP:
             imgControl.mouseUp();
             break;
         }
         return super.onTouchEvent(event);
     }
 }

ImageViewActivity

嗯，就酱…………