Android 移动缩放的ImageView

今天介绍一下Android中怎么实现ImageView的缩放和移动，自定义TouchImageView。

 public class TouchImageView extends ImageView {

     Matrix matrix;

     // We can be in one of these 3 states
     static final int NONE = ;
     static final int DRAG = ;
     static final int ZOOM = ;
     int mode = NONE;

     // Remember some things for zooming
     PointF last = new PointF();
     PointF start = new PointF();
     float minScale = 1f;
     float maxScale = 3f;
     float[] m;

     int viewWidth, viewHeight;
     static final int CLICK = ;
     float saveScale = 1f;
     protected float origWidth, origHeight;
     int oldMeasuredWidth, oldMeasuredHeight;

     ScaleGestureDetector mScaleDetector;

     Context context;

     public TouchImageView(Context context) {
         super(context);
         sharedConstructing(context);
     }

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

     private void sharedConstructing(Context context) {
         super.setClickable(true);
         this.context = context;
         mScaleDetector = new ScaleGestureDetector(context, new ScaleListener());
         matrix = new Matrix();
         m = new float[];
         setImageMatrix(matrix);
         setScaleType(ScaleType.MATRIX);

         setOnTouchListener(new OnTouchListener() {

             @Override
             public boolean onTouch(View v, MotionEvent event) {
                 mScaleDetector.onTouchEvent(event);
                 PointF curr = new PointF(event.getX(), event.getY());

                 switch (event.getAction()) {
                     case MotionEvent.ACTION_DOWN:
                         last.set(curr);
                         start.set(last);
                         mode = DRAG;
                         break;

                     case MotionEvent.ACTION_MOVE:
                         if (mode == DRAG) {
                             float deltaX = curr.x - last.x;
                             float deltaY = curr.y - last.y;
                             float fixTransX = getFixDragTrans(deltaX, viewWidth, origWidth * saveScale);
                             float fixTransY = getFixDragTrans(deltaY, viewHeight, origHeight * saveScale);
                             matrix.postTranslate(fixTransX, fixTransY);
                             fixTrans();
                             last.set(curr.x, curr.y);
                         }
                         break;

                     case MotionEvent.ACTION_UP:
                         mode = NONE;
                         int xDiff = (int) Math.abs(curr.x - start.x);
                         int yDiff = (int) Math.abs(curr.y - start.y);
                         if (xDiff < CLICK && yDiff < CLICK)
                             performClick();
                         break;

                     case MotionEvent.ACTION_POINTER_UP:
                         mode = NONE;
                         break;
                 }

                 setImageMatrix(matrix);
                 invalidate();
                 return true; // indicate event was handled
             }

         });
     }

     public void setMaxZoom(float x) {
         maxScale = x;
     }

     private class ScaleListener extends ScaleGestureDetector.SimpleOnScaleGestureListener {
         @Override
         public boolean onScaleBegin(ScaleGestureDetector detector) {
             mode = ZOOM;
             return true;
         }

         @Override
         public boolean onScale(ScaleGestureDetector detector) {
             float mScaleFactor = detector.getScaleFactor();
             float origScale = saveScale;
             saveScale *= mScaleFactor;
             if (saveScale > maxScale) {
                 saveScale = maxScale;
                 mScaleFactor = maxScale / origScale;
             } else if (saveScale < minScale) {
                 saveScale = minScale;
                 mScaleFactor = minScale / origScale;
             }

             if (origWidth * saveScale <= viewWidth || origHeight * saveScale <= viewHeight)
                 matrix.postScale(mScaleFactor, mScaleFactor, viewWidth / , viewHeight / );
             else
                 matrix.postScale(mScaleFactor, mScaleFactor, detector.getFocusX(), detector.getFocusY());

             fixTrans();
             return true;
         }
     }

     void fixTrans() {
         matrix.getValues(m);
         float transX = m[Matrix.MTRANS_X];
         float transY = m[Matrix.MTRANS_Y];

         float fixTransX = getFixTrans(transX, viewWidth, origWidth * saveScale);
         float fixTransY = getFixTrans(transY, viewHeight, origHeight * saveScale);

         if (fixTransX !=  || fixTransY != )
             matrix.postTranslate(fixTransX, fixTransY);
     }

     float getFixTrans(float trans, float viewSize, float contentSize) {
         float minTrans, maxTrans;

         if (contentSize <= viewSize) {
             minTrans = ;
             maxTrans = viewSize - contentSize;
         } else {
             minTrans = viewSize - contentSize;
             maxTrans = ;
         }

         if (trans < minTrans)
             return -trans + minTrans;
         if (trans > maxTrans)
             return -trans + maxTrans;
         return ;
     }

     float getFixDragTrans(float delta, float viewSize, float contentSize) {
         if (contentSize <= viewSize) {
             return ;
         }
         return delta;
     }

     @Override
     protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
         super.onMeasure(widthMeasureSpec, heightMeasureSpec);
         viewWidth = MeasureSpec.getSize(widthMeasureSpec);
         viewHeight = MeasureSpec.getSize(heightMeasureSpec);

         //
         // Rescales image on rotation
         //
         if (oldMeasuredHeight == viewWidth && oldMeasuredHeight == viewHeight
                 || viewWidth ==  || viewHeight == )
             return;
         oldMeasuredHeight = viewHeight;
         oldMeasuredWidth = viewWidth;

         if (saveScale == ) {
             //Fit to screen.
             float scale;

             Drawable drawable = getDrawable();
             if (drawable == null || drawable.getIntrinsicWidth() ==  || drawable.getIntrinsicHeight() == )
                 return;
             int bmWidth = drawable.getIntrinsicWidth();
             int bmHeight = drawable.getIntrinsicHeight();

             Log.d("bmSize", "bmWidth: " + bmWidth + " bmHeight : " + bmHeight);

             float scaleX = (float) viewWidth / (float) bmWidth;
             float scaleY = (float) viewHeight / (float) bmHeight;
             scale = Math.min(scaleX, scaleY);
             matrix.setScale(scale, scale);

             // Center the image
             float redundantYSpace = (float) viewHeight - (scale * (float) bmHeight);
             float redundantXSpace = (float) viewWidth - (scale * (float) bmWidth);
             redundantYSpace /= (float) ;
             redundantXSpace /= (float) ;

             matrix.postTranslate(redundantXSpace, redundantYSpace);

             origWidth = viewWidth -  * redundantXSpace;
             origHeight = viewHeight -  * redundantYSpace;
             setImageMatrix(matrix);
         }
         fixTrans();
     }
 }