Re: [androidbrasil-dev] Alguma API de galeria para android?

/*

 * TouchImageView.java

 * By: Michael Ortiz

 * Updated By: Patrick Lackemacher

 * Updated By: Babay88

 * Updated By: @ipsilondev

 * Updated By: hank-cp

 * Updated By: singpolyma

 * -------------------

 * Extends Android ImageView to include pinch zooming, panning, fling and double tap zoom.

 */

package com.pacote;

import android.annotation.TargetApi;

import android.content.Context;

import android.content.res.Configuration;

import android.graphics.Bitmap;

import android.graphics.Canvas;

import android.graphics.Matrix;

import android.graphics.PointF;

import android.graphics.RectF;

import android.graphics.drawable.Drawable;

import android.net.Uri;

import android.os.Build;

import android.os.Build.VERSION;

import android.os.Build.VERSION_CODES;

import android.os.Bundle;

import android.os.Parcelable;

import android.util.AttributeSet;

import android.util.Log;

import android.view.GestureDetector;

import android.view.MotionEvent;

import android.view.ScaleGestureDetector;

import android.view.View;

import android.view.animation.AccelerateDecelerateInterpolator;

import android.widget.ImageView;

import android.widget.OverScroller;

import android.widget.Scroller;

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 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 imageRenderedAtLeastOnce;

    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;

    private GestureDetector.OnDoubleTapListener doubleTapListener = null;

    private OnTouchListener userTouchListener = null;

    private OnTouchImageViewListener touchImageViewListener = null;

    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);

    }

    

    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);

        onDrawReady = false;

        super.setOnTouchListener(new PrivateOnTouchListener());

    }

    @Override

    public void setOnTouchListener(View.OnTouchListener l) {

        userTouchListener = l;

    }

    

    public void setOnTouchImageViewListener(OnTouchImageViewListener l) {

    touchImageViewListener = l;

    }

    public void setOnDoubleTapListener(GestureDetector.OnDoubleTapListener l) {

        doubleTapListener = l;

    }

    @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;

    if (onDrawReady) {

    //

    // If the image is already rendered, scaleType has been called programmatically

    // and the TouchImageView should be updated with the new scaleType.

    //

    setZoom(this);

    }

    }

    }

    

    @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() {

    return normalizedScale != 1;

    }

    

    /**

     * Return a Rect representing the zoomed image.

     * @return rect representing zoomed image

     */

    public RectF getZoomedRect() {

    if (mScaleType == ScaleType.FIT_XY) {

    throw new UnsupportedOperationException("getZoomedRect() not supported with FIT_XY");

    }

    PointF topLeft = transformCoordTouchToBitmap(0, 0, true);

    PointF bottomRight = transformCoordTouchToBitmap(viewWidth, viewHeight, true);

   

    float w = getDrawable().getIntrinsicWidth();

    float h = getDrawable().getIntrinsicHeight();

    return new RectF(topLeft.x / w, topLeft.y / h, bottomRight.x / w, bottomRight.y / h);

    }

    

    /**

     * Save the current matrix and view dimensions

     * in the prevMatrix and prevView variables.

     */

    private void savePreviousImageValues() {

    if (matrix != null && viewHeight != 0 && viewWidth != 0) {

    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);

    bundle.putBoolean("imageRendered", imageRenderedAtLeastOnce);

    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");

       imageRenderedAtLeastOnce = bundle.getBoolean("imageRendered");

       super.onRestoreInstanceState(bundle.getParcelable("instanceState"));

       return;

      }

      super.onRestoreInstanceState(state);

    }

    

    @Override

    protected void onDraw(Canvas canvas) {

    onDrawReady = true;

    imageRenderedAtLeastOnce = 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();

    }

    

    /**

     * 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;

    }

   

    if (scaleType != mScaleType) {

    setScaleType(scaleType);

    }

    resetZoom();

    scaleImage(scale, viewWidth / 2, viewHeight / 2, true);

    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.getScrollPosition();

    setZoom(img.getCurrentZoom(), center.x, center.y, img.getScaleType());

    }

    

    /**

     * 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 the scroll position of the zoomed image.

     */

    public PointF getScrollPosition() {

    Drawable drawable = getDrawable();

    if (drawable == null) {

    return null;

    }

    int drawableWidth = drawable.getIntrinsicWidth();

        int drawableHeight = drawable.getIntrinsicHeight();

        

        PointF point = transformCoordTouchToBitmap(viewWidth / 2, viewHeight / 2, true);

        point.x /= drawableWidth;

        point.y /= drawableHeight;

        return point;

    }

    

    /**

     * Set the focus point of the zoomed image. The focus points are denoted as a fraction from the

     * left and top of the view. The focus points can range in value between 0 and 1. 

     * @param focusX

     * @param focusY

     */

    public void setScrollPosition(float focusX, float focusY) {

    setZoom(normalizedScale, focusX, focusY);

    }

    

    /**

     * 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;

        }

        

        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() && !imageRenderedAtLeastOnce) {

        //

        // 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 (prevMatchViewWidth == 0 || prevMatchViewHeight == 0) {

        savePreviousImageValues();

        }

       

        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;

    }

    

    /**

     * After rotating, the matrix needs to be translated. This function finds the area of image 

     * which was previously centered and adjusts translations so that is again the center, post-rotation.

     * 

     * @param axis Matrix.MTRANS_X or Matrix.MTRANS_Y

     * @param trans the value of trans in that axis before the rotation

     * @param prevImageSize the width/height of the image before the rotation

     * @param imageSize width/height of the image after rotation

     * @param prevViewSize width/height of view before rotation

     * @param viewSize width/height of view after rotation

     * @param drawableSize width/height of drawable

     */

    private void translateMatrixAfterRotate(int axis, float trans, float prevImageSize, float imageSize, int prevViewSize, int viewSize, int drawableSize) {

    if (imageSize < viewSize) {

        //

        // The width/height of image is less than the view's width/height. Center it.

        //

        m[axis] = (viewSize - (drawableSize * m[Matrix.MSCALE_X])) * 0.5f;

       

        } else if (trans > 0) {

        //

        // The image is larger than the view, but was not before rotation. Center it.

        //

        m[axis] = -((imageSize - viewSize) * 0.5f);

       

        } else {

        //

        // Find the area of the image which was previously centered in the view. Determine its distance

        // from the left/top side of the view as a fraction of the entire image's width/height. Use that percentage

        // to calculate the trans in the new view width/height.

        //

        float percentage = (Math.abs(trans) + (0.5f * prevViewSize)) / prevImageSize;

        m[axis] = -((percentage * imageSize) - (viewSize * 0.5f));

        }

    }

    

    private void setState(State state) {

    this.state = state;

    }

    

    public boolean canScrollHorizontallyFroyo(int direction) {

        return canScrollHorizontally(direction);

    }

    

    @Override

    public boolean canScrollHorizontally(int direction) {

    matrix.getValues(m);

    float x = m[Matrix.MTRANS_X];

   

    if (getImageWidth() < viewWidth) {

    return false;

   

    } else if (x >= -1 && direction < 0) {

    return false;

   

    } else if (Math.abs(x) + viewWidth + 1 >= getImageWidth() && direction > 0) {

    return false;

    }

   

    return true;

    }

    

    /**

     * Gesture Listener detects a single click or long click and passes that on

     * to the view's listener.

     * @author Ortiz

     *

     */

    private class GestureListener extends GestureDetector.SimpleOnGestureListener {

   

        @Override

        public boolean onSingleTapConfirmed(MotionEvent e)

        {

            if(doubleTapListener != null) {

            return doubleTapListener.onSingleTapConfirmed(e);

            }

        return performClick();

        }

        

        @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(doubleTapListener != null) {

            consumed = doubleTapListener.onDoubleTap(e);

            }

        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;

        }

        @Override

        public boolean onDoubleTapEvent(MotionEvent e) {

            if(doubleTapListener != null) {

            return doubleTapListener.onDoubleTapEvent(e);

            }

            return false;

        }

    }

    

    public interface OnTouchImageViewListener {

    public void onMove();

    }

    

    /**

     * 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 PrivateOnTouchListener 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);

            

            //

    // User-defined OnTouchListener

    //

    if(userTouchListener != null) {

    userTouchListener.onTouch(v, event);

    }

            

    //

    // OnTouchImageViewListener is set: TouchImageView dragged by user.

    //

    if (touchImageViewListener != null) {

    touchImageViewListener.onMove();

    }

   

            //

            // 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);

       

        //

        // OnTouchImageViewListener is set: TouchImageView pinch zoomed by user.

        //

        if (touchImageViewListener != null) {

        touchImageViewListener.onMove();

        }

            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(double 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((float) deltaScale, (float) deltaScale, focusX, focusY);

        fixScaleTrans();

    }

    

    /**

     * DoubleTapZoom calls a series of runnables which apply

     * an animated zoom in/out graphic to the image.

     * @author Ortiz

     *

     */

    private class DoubleTapZoom implements Runnable {

   

    private long startTime;

    private static final float ZOOM_TIME = 500;

    private float startZoom, targetZoom;

    private float bitmapX, bitmapY;

    private boolean stretchImageToSuper;

    private AccelerateDecelerateInterpolator interpolator = new AccelerateDecelerateInterpolator();

    private PointF startTouch;

    private PointF endTouch;

    DoubleTapZoom(float targetZoom, float focusX, float focusY, boolean stretchImageToSuper) {

    setState(State.ANIMATE_ZOOM);

    startTime = System.currentTimeMillis();

    this.startZoom = normalizedScale;

    this.targetZoom = targetZoom;

    this.stretchImageToSuper = stretchImageToSuper;

    PointF bitmapPoint = transformCoordTouchToBitmap(focusX, focusY, false);

    this.bitmapX = bitmapPoint.x;

    this.bitmapY = bitmapPoint.y;

   

    //

    // Used for translating image during scaling

    //

    startTouch = transformCoordBitmapToTouch(bitmapX, bitmapY);

    endTouch = new PointF(viewWidth / 2, viewHeight / 2);

    }

@Override

public void run() {

float t = interpolate();

double deltaScale = calculateDeltaScale(t);

scaleImage(deltaScale, bitmapX, bitmapY, stretchImageToSuper);

translateImageToCenterTouchPosition(t);

fixScaleTrans();

setImageMatrix(matrix);

//

// OnTouchImageViewListener is set: double tap runnable updates listener

// with every frame.

//

if (touchImageViewListener != null) {

touchImageViewListener.onMove();

}

if (t < 1f) {

//

// We haven't finished zooming

//

compatPostOnAnimation(this);

} else {

//

// Finished zooming

//

setState(State.NONE);

}

}

/**

* Interpolate between where the image should start and end in order to translate

* the image so that the point that is touched is what ends up centered at the end

* of the zoom.

* @param t

*/

private void translateImageToCenterTouchPosition(float t) {

float targetX = startTouch.x + t * (endTouch.x - startTouch.x);

float targetY = startTouch.y + t * (endTouch.y - startTouch.y);

PointF curr = transformCoordBitmapToTouch(bitmapX, bitmapY);

matrix.postTranslate(targetX - curr.x, targetY - curr.y);

}

/**

* Use interpolator to get t

* @return

*/

private float interpolate() {

long currTime = System.currentTimeMillis();

float elapsed = (currTime - startTime) / ZOOM_TIME;

elapsed = Math.min(1f, elapsed);

return interpolator.getInterpolation(elapsed);

}

/**

* Interpolate the current targeted zoom and get the delta

* from the current zoom.

* @param t

* @return

*/

private double calculateDeltaScale(float t) {

double zoom = startZoom + t * (targetZoom - startZoom);

return zoom / normalizedScale;

}

    }

    

    /**

     * This function will transform the coordinates in the touch event to the coordinate 

     * system of the drawable that the imageview contain

     * @param x x-coordinate of touch event

     * @param y y-coordinate of touch event

     * @param clipToBitmap Touch event may occur within view, but outside image content. True, to clip return value

     * to the bounds of the bitmap size.

     * @return Coordinates of the point touched, in the coordinate system of the original drawable.

     */

    private PointF transformCoordTouchToBitmap(float x, float y, boolean clipToBitmap) {

         matrix.getValues(m);

         float origW = getDrawable().getIntrinsicWidth();

         float origH = getDrawable().getIntrinsicHeight();

         float transX = m[Matrix.MTRANS_X];

         float transY = m[Matrix.MTRANS_Y];

         float finalX = ((x - transX) * origW) / getImageWidth();

         float finalY = ((y - transY) * origH) / getImageHeight();

         

         if (clipToBitmap) {

        finalX = Math.min(Math.max(finalX, 0), origW);

        finalY = Math.min(Math.max(finalY, 0), origH);

         }

         

         return new PointF(finalX , finalY);

    }

    

    /**

     * Inverse of transformCoordTouchToBitmap. This function will transform the coordinates in the

     * drawable's coordinate system to the view's coordinate system.

     * @param bx x-coordinate in original bitmap coordinate system

     * @param by y-coordinate in original bitmap coordinate system

     * @return Coordinates of the point in the view's coordinate system.

     */

    private PointF transformCoordBitmapToTouch(float bx, float by) {

        matrix.getValues(m);        

        float origW = getDrawable().getIntrinsicWidth();

        float origH = getDrawable().getIntrinsicHeight();

        float px = bx / origW;

        float py = by / origH;

        float finalX = m[Matrix.MTRANS_X] + getImageWidth() * px;

        float finalY = m[Matrix.MTRANS_Y] + getImageHeight() * py;

        return new PointF(finalX , finalY);

    }

    

    /**

     * Fling launches sequential runnables which apply

     * the fling graphic to the image. The values for the translation

     * are interpolated by the Scroller.

     * @author Ortiz

     *

     */

    private class Fling implements Runnable {

   

        CompatScroller scroller;

    int currX, currY;

   

    Fling(int velocityX, int velocityY) {

    setState(State.FLING);

    scroller = new CompatScroller(context);

    matrix.getValues(m);

   

    int startX = (int) m[Matrix.MTRANS_X];

    int startY = (int) m[Matrix.MTRANS_Y];

    int minX, maxX, minY, maxY;

   

    if (getImageWidth() > viewWidth) {

    minX = viewWidth - (int) getImageWidth();

    maxX = 0;

   

    } else {

    minX = maxX = startX;

    }

   

    if (getImageHeight() > viewHeight) {

    minY = viewHeight - (int) getImageHeight();

    maxY = 0;

   

    } else {

    minY = maxY = startY;

    }

   

    scroller.fling(startX, startY, velocityX, velocityY, minX,

                    maxX, minY, maxY);

    currX = startX;

    currY = startY;

    }

   

    public void cancelFling() {

    if (scroller != null) {

    setState(State.NONE);

    scroller.forceFinished(true);

    }

    }

   

@Override

public void run() {

//

// OnTouchImageViewListener is set: TouchImageView listener has been flung by user.

// Listener runnable updated with each frame of fling animation.

//

if (touchImageViewListener != null) {

touchImageViewListener.onMove();

}

if (scroller.isFinished()) {

        scroller = null;

        return;

        }

if (scroller.computeScrollOffset()) {

        int newX = scroller.getCurrX();

           int newY = scroller.getCurrY();

           int transX = newX - currX;

           int transY = newY - currY;

           currX = newX;

           currY = newY;

           matrix.postTranslate(transX, transY);

           fixTrans();

           setImageMatrix(matrix);

           compatPostOnAnimation(this);

        }

}

    }

    

    @TargetApi(Build.VERSION_CODES.GINGERBREAD)

private class CompatScroller {

    Scroller scroller;

    OverScroller overScroller;

    boolean isPreGingerbread;

   

    public CompatScroller(Context context) {

    if (VERSION.SDK_INT < VERSION_CODES.GINGERBREAD) {

    isPreGingerbread = true;

    scroller = new Scroller(context);

   

    } else {

    isPreGingerbread = false;

    overScroller = new OverScroller(context);

    }

    }

   

    public void fling(int startX, int startY, int velocityX, int velocityY, int minX, int maxX, int minY, int maxY) {

    if (isPreGingerbread) {

    scroller.fling(startX, startY, velocityX, velocityY, minX, maxX, minY, maxY);

    } else {

    overScroller.fling(startX, startY, velocityX, velocityY, minX, maxX, minY, maxY);

    }

    }

   

    public void forceFinished(boolean finished) {

    if (isPreGingerbread) {

    scroller.forceFinished(finished);

    } else {

    overScroller.forceFinished(finished);

    }

    }

   

    public boolean isFinished() {

    if (isPreGingerbread) {

    return scroller.isFinished();

    } else {

    return overScroller.isFinished();

    }

    }

   

    public boolean computeScrollOffset() {

    if (isPreGingerbread) {

    return scroller.computeScrollOffset();

    } else {

    overScroller.computeScrollOffset();

    return overScroller.computeScrollOffset();

    }

    }

   

    public int getCurrX() {

    if (isPreGingerbread) {

    return scroller.getCurrX();

    } else {

    return overScroller.getCurrX();

    }

    }

   

    public int getCurrY() {

    if (isPreGingerbread) {

    return scroller.getCurrY();

    } else {

    return overScroller.getCurrY();

    }

    }

    }

    

    @TargetApi(Build.VERSION_CODES.JELLY_BEAN)

private void compatPostOnAnimation(Runnable runnable) {

    if (VERSION.SDK_INT >= VERSION_CODES.JELLY_BEAN) {

            postOnAnimation(runnable);

            

        } else {

            postDelayed(runnable, 1000/60);

        }

    }

    

    private class ZoomVariables {

    public float scale;

    public float focusX;

    public float focusY;

    public ScaleType scaleType;

   

    public ZoomVariables(float scale, float focusX, float focusY, ScaleType scaleType) {

    this.scale = scale;

    this.focusX = focusX;

    this.focusY = focusY;

    this.scaleType = scaleType;

    }

    }

    

    private void printMatrixInfo() {

    float[] n = new float[9];

    matrix.getValues(n);

    Log.d(DEBUG, "Scale: " + n[Matrix.MSCALE_X] + " TransX: " + n[Matrix.MTRANS_X] + " TransY: " + n[Matrix.MTRANS_Y]);

    }

}

com.pacote.TouchImageView

                        android:id="@+id/ivFoto1"

                        android:layout_width="wrap_content"

                        android:layout_height="wrap_content"

                        android:layout_gravity="center"

                        android:layout_margin="2dp"

                        android:contentDescription="@string/TODO"

                        android:scaleType="fitXY"

                        android:src="@drawable/foto" />