title: Scale limits on pinch zoom of android
body: <p>How to set Max and Min zoom levels for Pinch-Zoom? </p>
  
  <hr>
  
  <p>Here is my code:
  //</p>
  
  <pre><code>public class TouchImageView extends ImageView {
  
       private static final String TAG = "Touch";
  
          // These matrices will be used to move and zoom image
          Matrix matrix = new Matrix();
          Matrix savedMatrix = new Matrix();
          static PinchZoomExample sPinchZoomExample = null;
          // We can be in one of these 3 states
          static final int NONE = 0;
          static final int DRAG = 1;
          static final int ZOOM = 2;
          int mode = NONE;
          static Bitmap sCurrentImage;
  
          // Remember some things for zooming
          PointF start = new PointF();
          PointF mid = new PointF();
          float oldDist = 1f;
  
          Context context;
  
  
          public TouchImageView(Context context) {
              super(context);
              super.setClickable(true);
              this.context = context;
  
              matrix.setTranslate(1f, 1f);
              setImageMatrix(matrix);
              setScaleType(ScaleType.MATRIX);
  
              setOnTouchListener(new OnTouchListener() {
  
                  @Override
                  public boolean onTouch(View v, MotionEvent rawEvent) {
                      WrapMotionEvent event = WrapMotionEvent.wrap(rawEvent);
  
                      // Dump touch event to log
                     /* if (Viewer.isDebug == true){
                          dumpEvent(event);
                      }*/
  
                      // Handle touch events here...
                      switch (event.getAction() &amp; MotionEvent.ACTION_MASK) {
                      case MotionEvent.ACTION_DOWN:
                          savedMatrix.set(matrix);
                          start.set(event.getX(), event.getY());
                          Log.d(TAG, "mode=DRAG");
                          mode = DRAG;
                          break;
                      case MotionEvent.ACTION_POINTER_DOWN:
                          oldDist = spacing(event);
                          Log.d(TAG, "oldDist=" + oldDist);
                          if (oldDist &gt; 10f) {
                              savedMatrix.set(matrix);
                              midPoint(mid, event);
                              mode = ZOOM;
                              Log.d(TAG, "mode=ZOOM");
                          }
                          break;
                      case MotionEvent.ACTION_UP:
                          int xDiff = (int) Math.abs(event.getX() - start.x);
                          int yDiff = (int) Math.abs(event.getY() - start.y);
                          if (xDiff &lt; 8 &amp;&amp; yDiff &lt; 8){
                              performClick();
                              sPinchZoomExample.displayGallery();
                          }
                      case MotionEvent.ACTION_POINTER_UP:
                          mode = NONE;
                          Log.d(TAG, "mode=NONE");
                          break;
                      case MotionEvent.ACTION_MOVE:
                          if (mode == DRAG) {
                              // ...
                              matrix.set(savedMatrix);
                              matrix.postTranslate(event.getX() - start.x, event.getY() - start.y);
                          } else if (mode == ZOOM) {
                              float newDist = spacing(event);
                              Log.d(TAG, "newDist=" + newDist);
                              if (newDist &gt; 10f) {
                                  matrix.set(savedMatrix);
                                  float scale = newDist / oldDist;
  
                                  matrix.postScale(scale, scale, mid.x, mid.y);
  
                                  //Canvas canvas = new Canvas();
  
  //                              Bitmap bm = Bitmap.createBitmap(sCurrentImage,0, 0, sCurrentImage.getWidth()
  //                                      , sCurrentImage.getHeight(), matrix, true);
                                  Log.d("SCALE", "scale=" + scale + "  " + getWidth() + "  " + getHeight());
                                  //bm.recycle();
                              }
                          }
                          break;
                      }
  
                      setImageMatrix(matrix);
                      return true; // indicate event was handled
                  }
  
              });
          }
  
  
          public void setImage(Bitmap bm, int displayWidth, int displayHeight , PinchZoomExample pze) { 
              super.setImageBitmap(bm);
              sCurrentImage = bm;
              sPinchZoomExample = pze;
              //Fit to screen.
              float scale;
              if ((displayHeight / bm.getHeight()) &gt;= (displayWidth / bm.getWidth())){
                  scale =  (float)displayWidth / (float)bm.getWidth();
              } else {
                  scale = (float)displayHeight / (float)bm.getHeight();
              }
  
              savedMatrix.set(matrix);
              matrix.set(savedMatrix);
              matrix.postScale(scale, scale, mid.x, mid.y);
              setImageMatrix(matrix);
  
  
              // Center the image
              float redundantYSpace = (float)displayHeight - (scale * (float)bm.getHeight()) ;
              float redundantXSpace = (float)displayWidth - (scale * (float)bm.getWidth());
  
              redundantYSpace /= (float)2;
              redundantXSpace /= (float)2;
  
  
              savedMatrix.set(matrix);
              matrix.set(savedMatrix);
              matrix.postTranslate(redundantXSpace, redundantYSpace);   //matrix.postTranslate(50, 50);
              setImageMatrix(matrix);
  
  
          }
  
  
  
  
          /** Determine the space between the first two fingers */
          private float spacing(WrapMotionEvent event) {
              // ...
              float x = event.getX(0) - event.getX(1);
              float y = event.getY(0) - event.getY(1);
              return FloatMath.sqrt(x * x + y * y);
          }
  
          /** Calculate the mid point of the first two fingers */
          private void midPoint(PointF point, WrapMotionEvent event) {
              // ...
              float x = event.getX(0) + event.getX(1);
              float y = event.getY(0) + event.getY(1);
              point.set(x / 2, y / 2);
          }
  
  }
  </code></pre>