How to reset an enlarged image to the original image

Question

I am using a class TouchImageViewavailable at https://github.com/MikeOrtiz/TouchImageView .

when I move from the enlarged image to the next and return to the previous image, it still has zooming.

I want to reset the image scaling to its normal position when scrolling to the previous image

and got an answer, referring to this question How to reset the image to its original position , but I don’t know exactly where this method should be put in this library so that you can help me with the manual?

Thanks in advance.

public class TouchImageView extends ImageView {

private static final String DEBUG = "DEBUG";

//
// SuperMin and SuperMax multipliers. Determine how much the image can be
// zoomed below or above the zoom boundaries, before animating back to the
// min/max zoom boundary.
//
private static final float SUPER_MIN_MULTIPLIER = .75f;
private static final float SUPER_MAX_MULTIPLIER = 1.25f;

//
// Scale of image ranges from minScale to maxScale, where minScale == 1
// when the image is stretched to fit view.
//
private float normalizedScale;

//
// Matrix applied to image. MSCALE_X and MSCALE_Y should always be equal.
// MTRANS_X and MTRANS_Y are the other values used. prevMatrix is the matrix
// saved prior to the screen rotating.
//
private Matrix matrix, prevMatrix;

private boolean onTouch = false;

private static enum State { NONE, DRAG, ZOOM, FLING, ANIMATE_ZOOM };
private State state;

private float minScale;
private float maxScale;
private float superMinScale;
private float superMaxScale;
private float[] m;

private Context context;
private Fling fling;

private ScaleType mScaleType;

private boolean onDrawReady;
private ZoomVariables delayedZoomVariables;

//
// Size of view and previous view size (ie before rotation)
//
private int viewWidth, viewHeight, prevViewWidth, prevViewHeight;

//
// Size of image when it is stretched to fit view. Before and After rotation.
//
private float matchViewWidth, matchViewHeight, prevMatchViewWidth, prevMatchViewHeight;

private ScaleGestureDetector mScaleDetector;
private GestureDetector mGestureDetector;

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

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

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

OnScaleChangeListener _scaleChangeListener;             // Coded by siva // interface object for detecting the single and double tap on imageview 


public interface OnScaleChangeListener {
    public void onSingleTabfromTouchImage(boolean isSingleTabClick);
    public void onDoubleTapfromTouchImage(boolean isDoubleTapClick);
}

public synchronized void setOnScaleChangeListener(OnScaleChangeListener listener){
    _scaleChangeListener = listener;
}

private void sharedConstructing(Context context) {
    super.setClickable(true);
    this.context = context;
    mScaleDetector = new ScaleGestureDetector(context, new ScaleListener());
    mGestureDetector = new GestureDetector(context, new GestureListener());
    matrix = new Matrix();
    prevMatrix = new Matrix();
    m = new float[9];
    normalizedScale = 1;
    if (mScaleType == null) {
        mScaleType = ScaleType.FIT_CENTER;
    }
    minScale = 1;
    maxScale = 3;
    superMinScale = SUPER_MIN_MULTIPLIER * minScale;
    superMaxScale = SUPER_MAX_MULTIPLIER * maxScale;
    setImageMatrix(matrix);
    setScaleType(ScaleType.MATRIX);
    setState(State.NONE);
    setOnTouchListener(new TouchImageViewListener());
    onDrawReady = false;
}

@Override
public void setImageResource(int resId) {
    super.setImageResource(resId);
    savePreviousImageValues();
    fitImageToView();
}

@Override
public void setImageBitmap(Bitmap bm) {
    super.setImageBitmap(bm);
    savePreviousImageValues();
    fitImageToView();
}

@Override
public void setImageDrawable(Drawable drawable) {
    super.setImageDrawable(drawable);
    savePreviousImageValues();
    fitImageToView();
}

@Override
public void setImageURI(Uri uri) {
    super.setImageURI(uri);
    savePreviousImageValues();
    fitImageToView();
}

@Override
public void setScaleType(ScaleType type) {
    if (type == ScaleType.FIT_START || type == ScaleType.FIT_END) {
        throw new UnsupportedOperationException("TouchImageView does not support FIT_START or FIT_END");
    }
    if (type == ScaleType.MATRIX) {
        super.setScaleType(ScaleType.MATRIX);

    } else {
        mScaleType = type;
    }
}

@Override
public ScaleType getScaleType() {
    return mScaleType;
}

/**
 * Returns false if image is in initial, unzoomed state. False, otherwise.
 * @return true if image is zoomed
 */
public boolean isZoomed() {

    if(normalizedScale > 1)
        return true;
    else
        return false;
    //return normalizedScale != 1;
}

/**
 * Return a bitmap of the zoomed image as it appears within the view. This essentially
 * acts as a "screenshot" of the view and the size of the final bitmap is limited to the
 * resolution of the view itself.
 * @return bitmap of zoomed image
 */
public Bitmap getZoomedImage() {
    Bitmap bitmap = Bitmap.createBitmap(viewWidth, viewHeight, Bitmap.Config.ARGB_8888);                
    Canvas canvas = new Canvas(bitmap);
    layout(0, 0, viewWidth, viewHeight);
    draw(canvas);
    return bitmap;
}

/**
 * Return a bitmap of the zoomed image. This method is different from getZoomedImage() because
 * it cuts the image directly from the drawable source, and thus, is not limited by the resolution
 * of the view. Not supported with FIT_XY.
 * @return bitmap of zoomed image
 */
public Bitmap getZoomedImageFromSource() {
    if (mScaleType == ScaleType.FIT_XY) {
        throw new UnsupportedOperationException("getZoomedImageFromSource() not supported with FIT_XY");
    }
    Bitmap bitmap = ((BitmapDrawable) getDrawable()).getBitmap();
    Rect r = getZoomedRect();
    if (r.width() <= 0 || r.height() <= 0) {
        return null;
    }
    return Bitmap.createBitmap(bitmap, r.left, r.top, r.width(), r.height());
}

/**
 * Return a Rect representing the zoomed image in the coordinate system of the drawable source.
 * @return rect representing zoomed image
 */
public Rect getZoomedRect() {
    if (mScaleType == ScaleType.FIT_XY) {
        throw new UnsupportedOperationException("getZoomedRect() not supported with FIT_XY");
    }
    PointF topLeft = getDrawablePointFromTouchPoint(0,0);
    PointF bottomRight = getDrawablePointFromTouchPoint(viewWidth, viewHeight);
    return new Rect((int) topLeft.x, (int) topLeft.y,(int) bottomRight.x, (int) bottomRight.y);
}

/**
 * Save the current matrix and view dimensions
 * in the prevMatrix and prevView variables.
 */
private void savePreviousImageValues() {
    if (matrix != null) {
        matrix.getValues(m);
        prevMatrix.setValues(m);
        prevMatchViewHeight = matchViewHeight;
        prevMatchViewWidth = matchViewWidth;
        prevViewHeight = viewHeight;
        prevViewWidth = viewWidth;
    }
}

@Override
public Parcelable onSaveInstanceState() {
    Bundle bundle = new Bundle();
    bundle.putParcelable("instanceState", super.onSaveInstanceState());
    bundle.putFloat("saveScale", normalizedScale);
    bundle.putFloat("matchViewHeight", matchViewHeight);
    bundle.putFloat("matchViewWidth", matchViewWidth);
    bundle.putInt("viewWidth", viewWidth);
    bundle.putInt("viewHeight", viewHeight);
    matrix.getValues(m);
    bundle.putFloatArray("matrix", m);
    return bundle;
}

@Override
public void onRestoreInstanceState(Parcelable state) {
    if (state instanceof Bundle) {
        Bundle bundle = (Bundle) state;
        normalizedScale = bundle.getFloat("saveScale");
        m = bundle.getFloatArray("matrix");
        prevMatrix.setValues(m);
        prevMatchViewHeight = bundle.getFloat("matchViewHeight");
        prevMatchViewWidth = bundle.getFloat("matchViewWidth");
        prevViewHeight = bundle.getInt("viewHeight");
        prevViewWidth = bundle.getInt("viewWidth");
        super.onRestoreInstanceState(bundle.getParcelable("instanceState"));
        return;
    }

    super.onRestoreInstanceState(state);
}

@Override
protected void onDraw(Canvas canvas) {
    onDrawReady = true;
    if (delayedZoomVariables != null) {
        setZoom(delayedZoomVariables.scale, delayedZoomVariables.focusX, delayedZoomVariables.focusY, delayedZoomVariables.scaleType);
        delayedZoomVariables = null;
    }
    super.onDraw(canvas);
}

@Override
public void onConfigurationChanged(Configuration newConfig) {
    super.onConfigurationChanged(newConfig);
    //savePreviousImageValues();
    resetZoom();
}

/**
 * Get the max zoom multiplier.
 * @return max zoom multiplier.
 */
public float getMaxZoom() {
    return maxScale;
}

/**
 * Set the max zoom multiplier. Default value: 3.
 * @param max max zoom multiplier.
 */
public void setMaxZoom(float max) {
    maxScale = max;
    superMaxScale = SUPER_MAX_MULTIPLIER * maxScale;
}

/**
 * Get the min zoom multiplier.
 * @return min zoom multiplier.
 */
public float getMinZoom() {
    return minScale;
}

/**
 * Get the current zoom. This is the zoom relative to the initial
 * scale, not the original resource.
 * @return current zoom multiplier.
 */
public float getCurrentZoom() {
    return normalizedScale;
}

/**
 * Set the min zoom multiplier. Default value: 1.
 * @param min min zoom multiplier.
 */
public void setMinZoom(float min) {
    minScale = min;
    superMinScale = SUPER_MIN_MULTIPLIER * minScale;
}

/**
 * Reset zoom and translation to initial state.
 */
public void resetZoom() {
    normalizedScale = 1;
    fitImageToView();
}

/**
 * Set zoom to the specified scale. Image will be centered by default.
 * @param scale
 */
public void setZoom(float scale) {
    setZoom(scale, 0.5f, 0.5f);
}

/**
 * Set zoom to the specified scale. Image will be centered around the point
 * (focusX, focusY). These floats range from 0 to 1 and denote the focus point
 * as a fraction from the left and top of the view. For example, the top left 
 * corner of the image would be (0, 0). And the bottom right corner would be (1, 1).
 * @param scale
 * @param focusX
 * @param focusY
 */
public void setZoom(float scale, float focusX, float focusY) {
    setZoom(scale, focusX, focusY, mScaleType);
}

/**
 * Set zoom to the specified scale. Image will be centered around the point
 * (focusX, focusY). These floats range from 0 to 1 and denote the focus point
 * as a fraction from the left and top of the view. For example, the top left 
 * corner of the image would be (0, 0). And the bottom right corner would be (1, 1).
 * @param scale
 * @param focusX
 * @param focusY
 * @param scaleType
 */
public void setZoom(float scale, float focusX, float focusY, ScaleType scaleType) {
    //
    // setZoom can be called before the image is on the screen, but at this point, 
    // image and view sizes have not yet been calculated in onMeasure. Thus, we should
    // delay calling setZoom until the view has been measured.
    //
    if (!onDrawReady) {
        delayedZoomVariables = new ZoomVariables(scale, focusX, focusY, scaleType);
        return;
    }

    setScaleType(scaleType);
    resetZoom();
    scaleImage(scale, viewWidth / 2, viewHeight / 2, false);
    matrix.getValues(m);
    m[Matrix.MTRANS_X] = -((focusX * getImageWidth()) - (viewWidth * 0.5f));
    m[Matrix.MTRANS_Y] = -((focusY * getImageHeight()) - (viewHeight * 0.5f));
    matrix.setValues(m);
    fixTrans();
    setImageMatrix(matrix);
}

/**
 * Set zoom parameters equal to another TouchImageView. Including scale, position,
 * and ScaleType.
 * @param TouchImageView
 */
public void setZoom(TouchImageView img) {
    PointF center = img.getCenterOfZoomedImage();
    setZoom(img.getCurrentZoom(), center.x, center.y, img.getScaleType());
}

/**
 * For a given point on the view (ie, a touch event), returns the
 * point relative to the original drawable coordinate system.
 * @param x
 * @param y
 * @return PointF relative to original drawable coordinate system.
 */
public PointF getDrawablePointFromTouchPoint(float x, float y) {
    return transformCoordTouchToBitmap(x, y, true);
}

/**
 * For a given point on the view (ie, a touch event), returns the
 * point relative to the original drawable coordinate system.
 * @param p
 * @return PointF relative to original drawable coordinate system.
 */
public PointF getDrawablePointFromTouchPoint(PointF p) {
    return transformCoordTouchToBitmap(p.x, p.y, true);
}

/**
 * Return the point at the center of the zoomed image. The PointF coordinates range
 * in value between 0 and 1 and the focus point is denoted as a fraction from the left 
 * and top of the view. For example, the top left corner of the image would be (0, 0). 
 * And the bottom right corner would be (1, 1).
 * @return PointF representing center of zoomed image
 */
public PointF getCenterOfZoomedImage() {
    Drawable drawable = getDrawable();
    if (drawable == null) {
        return null;
    }
    int drawableWidth = drawable.getIntrinsicWidth();
    int drawableHeight = drawable.getIntrinsicHeight();

    PointF point = getDrawablePointFromTouchPoint(viewWidth / 2, viewHeight / 2);
    point.x /= drawableWidth;
    point.y /= drawableHeight;
    return point;
}

/**
 * Performs boundary checking and fixes the image matrix if it 
 * is out of bounds.
 */
private void fixTrans() {
    matrix.getValues(m);
    float transX = m[Matrix.MTRANS_X];
    float transY = m[Matrix.MTRANS_Y];

    float fixTransX = getFixTrans(transX, viewWidth, getImageWidth());
    float fixTransY = getFixTrans(transY, viewHeight, getImageHeight());

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

/**
 * When transitioning from zooming from focus to zoom from center (or vice versa)
 * the image can become unaligned within the view. This is apparent when zooming
 * quickly. When the content size is less than the view size, the content will often
 * be centered incorrectly within the view. fixScaleTrans first calls fixTrans() and 
 * then makes sure the image is centered correctly within the view.
 */
private void fixScaleTrans() {
    fixTrans();
    matrix.getValues(m);
    if (getImageWidth() < viewWidth) {
        m[Matrix.MTRANS_X] = (viewWidth - getImageWidth()) / 2;
    }

    if (getImageHeight() < viewHeight) {
        m[Matrix.MTRANS_Y] = (viewHeight - getImageHeight()) / 2;
    }
    matrix.setValues(m);
}

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

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

    } else {
        minTrans = viewSize - contentSize;
        maxTrans = 0;
    }

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

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

private float getImageWidth() {
    return matchViewWidth * normalizedScale;
}

private float getImageHeight() {
    return matchViewHeight * normalizedScale;
}

@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
    Drawable drawable = getDrawable();
    if (drawable == null || drawable.getIntrinsicWidth() == 0 || drawable.getIntrinsicHeight() == 0) {
        setMeasuredDimension(0, 0);
        return;
    }

  /*  if(onTouch){
        //resetZoom();
        onTouch  = false;
    }
    else
        resetZoom();*/

    int drawableWidth = drawable.getIntrinsicWidth();
    int drawableHeight = drawable.getIntrinsicHeight();
    int widthSize = MeasureSpec.getSize(widthMeasureSpec);
    int widthMode = MeasureSpec.getMode(widthMeasureSpec);
    int heightSize = MeasureSpec.getSize(heightMeasureSpec);
    int heightMode = MeasureSpec.getMode(heightMeasureSpec);
    viewWidth = setViewSize(widthMode, widthSize, drawableWidth);
    viewHeight = setViewSize(heightMode, heightSize, drawableHeight);

    //
    // Set view dimensions
    //
    setMeasuredDimension(viewWidth, viewHeight);

    //
    // Fit content within view
    //
    fitImageToView();
}

/**
 * If the normalizedScale is equal to 1, then the image is made to fit the screen. Otherwise,
 * it is made to fit the screen according to the dimensions of the previous image matrix. This
 * allows the image to maintain its zoom after rotation.
 */
private void fitImageToView() {
    Drawable drawable = getDrawable();
    if (drawable == null || drawable.getIntrinsicWidth() == 0 || drawable.getIntrinsicHeight() == 0) {
        return;
    }
    if (matrix == null || prevMatrix == null) {
        return;
    }

    int drawableWidth = drawable.getIntrinsicWidth();
    int drawableHeight = drawable.getIntrinsicHeight();

    //
    // Scale image for view
    //
    float scaleX = (float) viewWidth / drawableWidth;
    float scaleY = (float) viewHeight / drawableHeight;

    switch (mScaleType) {
    case CENTER:
        scaleX = scaleY = 1;
        break;

    case CENTER_CROP:
        scaleX = scaleY = Math.max(scaleX, scaleY);
        break;

    case CENTER_INSIDE:
        scaleX = scaleY = Math.min(1, Math.min(scaleX, scaleY));

    case FIT_CENTER:
        scaleX = scaleY = Math.min(scaleX, scaleY);
        break;

    case FIT_XY:
        break;

    default:
        //
        // FIT_START and FIT_END not supported
        //
        throw new UnsupportedOperationException("TouchImageView does not support FIT_START or FIT_END");

    }

    //
    // Center the image
    //
    float redundantXSpace = viewWidth - (scaleX * drawableWidth);
    float redundantYSpace = viewHeight - (scaleY * drawableHeight);
    matchViewWidth = viewWidth - redundantXSpace;
    matchViewHeight = viewHeight - redundantYSpace;
    if (!isZoomed()) {
        //
        // Stretch and center image to fit view
        //
        matrix.setScale(scaleX, scaleY);
        matrix.postTranslate(redundantXSpace / 2, redundantYSpace / 2);
        normalizedScale = 1;

    } else {
        //
        // These values should never be 0 or we will set viewWidth and viewHeight
        // to NaN in translateMatrixAfterRotate. To avoid this, call savePreviousImageValues
        // to set them equal to the current values.
        //

        if(onTouch){
            if(matchViewWidth > drawableWidth){
                prevMatchViewHeight = 0;
                prevMatchViewWidth = 0;
                savePreviousImageValues();
            }
            onTouch = false;
        }
        if (prevMatchViewWidth == 0 || prevMatchViewHeight == 0) {
            //savePreviousImageValues();
            normalizedScale = 1;
        }

        prevMatrix.getValues(m);

        //
        // Rescale Matrix after rotation
        //
        m[Matrix.MSCALE_X] = matchViewWidth / drawableWidth * normalizedScale;
        m[Matrix.MSCALE_Y] = matchViewHeight / drawableHeight * normalizedScale;

        //
        // TransX and TransY from previous matrix
        //
        float transX = m[Matrix.MTRANS_X];
        float transY = m[Matrix.MTRANS_Y];

        //
        // Width
        //
        float prevActualWidth = prevMatchViewWidth * normalizedScale;
        float actualWidth = getImageWidth();
        translateMatrixAfterRotate(Matrix.MTRANS_X, transX, prevActualWidth, actualWidth, prevViewWidth, viewWidth, drawableWidth);

        //
        // Height
        //
        float prevActualHeight = prevMatchViewHeight * normalizedScale;
        float actualHeight = getImageHeight();
        translateMatrixAfterRotate(Matrix.MTRANS_Y, transY, prevActualHeight, actualHeight, prevViewHeight, viewHeight, drawableHeight);

        //
        // Set the matrix to the adjusted scale and translate values.
        //
        matrix.setValues(m);
    }
    fixTrans();
    setImageMatrix(matrix);
}

/**
 * Set view dimensions based on layout params
 * 
 * @param mode 
 * @param size
 * @param drawableWidth
 * @return
 */
private int setViewSize(int mode, int size, int drawableWidth) {
    int viewSize;
    switch (mode) {
    case MeasureSpec.EXACTLY:
        viewSize = size;
        break;

    case MeasureSpec.AT_MOST:
        viewSize = Math.min(drawableWidth, size);
        break;

    case MeasureSpec.UNSPECIFIED:
        viewSize = drawableWidth;
        break;

    default:
        viewSize = size;
        break;
    }
    return viewSize;
}

/**
 * Gesture Listener detects a single click or long click and passes that on
 * to the view listener.
 * @author Ortiz
 *
 */
private class GestureListener extends GestureDetector.SimpleOnGestureListener {

    @Override
    public boolean onSingleTapConfirmed(MotionEvent e)
    {
        onTouch = true;
        _scaleChangeListener.onSingleTabfromTouchImage(true);            // set the boolean for single tap //  Coded by siva.
        savePreviousImageValues();
        return false;
    }

    @Override
    public void onLongPress(MotionEvent e)
    {
        performLongClick();
    }

    @Override
    public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX, float velocityY)
    {
        if (fling != null) {
            //
            // If a previous fling is still active, it should be cancelled so that two flings
            // are not run simultaenously.
            //
            fling.cancelFling();
        }
        fling = new Fling((int) velocityX, (int) velocityY);
        compatPostOnAnimation(fling);
        return super.onFling(e1, e2, velocityX, velocityY);
    }

    @Override
    public boolean onDoubleTap(MotionEvent e) {
        boolean consumed = false;



        if (state == State.NONE) {
            float targetZoom = (normalizedScale == minScale) ? maxScale : minScale;
            DoubleTapZoom doubleTap = new DoubleTapZoom(targetZoom, e.getX(), e.getY(), false);
            compatPostOnAnimation(doubleTap);
            consumed = true;
        }
        return consumed;
    }
}

/**
 * Responsible for all touch events. Handles the heavy lifting of drag and also sends
 * touch events to Scale Detector and Gesture Detector.
 * @author Ortiz
 *
 */
private class TouchImageViewListener implements OnTouchListener {

    //
    // Remember last point position for dragging
    //
    private PointF last = new PointF();

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

        if (state == State.NONE || state == State.DRAG || state == State.FLING) {
            switch (event.getAction()) {
                case MotionEvent.ACTION_DOWN:
                    last.set(curr);
                    if (fling != null)
                        fling.cancelFling();
                    setState(State.DRAG);
                    break;

                case MotionEvent.ACTION_MOVE:
                    if (state == State.DRAG) {
                        float deltaX = curr.x - last.x;
                        float deltaY = curr.y - last.y;
                        float fixTransX = getFixDragTrans(deltaX, viewWidth, getImageWidth());
                        float fixTransY = getFixDragTrans(deltaY, viewHeight, getImageHeight());
                        matrix.postTranslate(fixTransX, fixTransY);
                        fixTrans();
                        last.set(curr.x, curr.y);
                    }
                    break;

                case MotionEvent.ACTION_UP:
                case MotionEvent.ACTION_POINTER_UP:
                    setState(State.NONE);
                    break;
            }
        }

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

/**
 * ScaleListener detects user two finger scaling and scales image.
 * @author Ortiz
 *
 */
private class ScaleListener extends ScaleGestureDetector.SimpleOnScaleGestureListener {
    @Override
    public boolean onScaleBegin(ScaleGestureDetector detector) {
        setState(State.ZOOM);
        return true;
    }

    @Override
    public boolean onScale(ScaleGestureDetector detector) {
        scaleImage(detector.getScaleFactor(), detector.getFocusX(), detector.getFocusY(), true);
        return true;
    }

    @Override
    public void onScaleEnd(ScaleGestureDetector detector) {
        super.onScaleEnd(detector);
        setState(State.NONE);
        boolean animateToZoomBoundary = false;
        float targetZoom = normalizedScale;
        if (normalizedScale > maxScale) {
            targetZoom = maxScale;
            animateToZoomBoundary = true;

        } else if (normalizedScale < minScale) {
            targetZoom = minScale;
            animateToZoomBoundary = true;
        }

        if (animateToZoomBoundary) {
            DoubleTapZoom doubleTap = new DoubleTapZoom(targetZoom, viewWidth / 2, viewHeight / 2, true);
            compatPostOnAnimation(doubleTap);
        }
    }
}

private void scaleImage(float deltaScale, float focusX, float focusY, boolean stretchImageToSuper) {

    float lowerScale, upperScale;
    if (stretchImageToSuper) {
        lowerScale = superMinScale;
        upperScale = superMaxScale;

    } else {
        lowerScale = minScale;
        upperScale = maxScale;
    }

    float origScale = normalizedScale;
    normalizedScale *= deltaScale;
    if (normalizedScale > upperScale) {
        normalizedScale = upperScale;
        deltaScale = upperScale / origScale;
    } else if (normalizedScale < lowerScale) {
        normalizedScale = lowerScale;
        deltaScale = lowerScale / origScale;
    }

    matrix.postScale(deltaScale, deltaScale, focusX, focusY);
    fixScaleTrans();
}

Answer 1

, : TouchImageView class

switch (event.getAction()) { }

case MotionEvent.ACTION_CANCEL:
     resetZoom();
     break;

, , .

Answer 2

:

• TouchImageView

  public void resetImageToNormalSize(){
      maintainZoomAfterSetImage(false);
      setImageCalled();
      savePreviousImageValues();
      fitImageToView();
  }
  

:

    False -- means the image should be resized within the view.
    True  -- means the new image should maintain the zoom of the previous image.

    maintainZoomAfterSetImage(boolean maintainZoom);

• TouchImageView, , reset .

  imgPhoto.resetImageToNormalSize();
  

  .

  public void onPageSelected(int position) {
  
  // get the previous touchimageview object and call 
  // resetImageToNormalSize method on it.
  
     imgPhoto.resetImageToNormalSize();
  } 
  

, .

Answer 3

, .. reset ImageView /

setContentView(R.layout.activity_image);

put it on any button in reset general view of activity ...