@@ -0,0 +1,1262 @@
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 , (int ) velocityX , (int ) 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 ]);
}
}
Antarix created this gist