remove all prebuilt jars

This gets rid of all prebuilt jars in the repo.

* libs/disklrucache-2.0.2.jar doesn't seem to be used anymore, app builds
  fine when removing it.
* libs/touch-image-view.jar is indeed required but is not anywhere available
  via gradle. So instead we include the source of this long unmaintained
  library directly.

build.gradle

@@ -185,7 +185,6 @@ android {
 
 dependencies {
     /// dependencies for app building
-    implementation name: 'touch-image-view'
     implementation 'com.android.support:multidex:1.0.2'
     compile 'com.github.nextcloud:android-library:1.0.31'
     implementation "com.android.support:support-v4:${supportLibraryVersion}"

src/main/java/com/ortiz/touch/ExtendedViewPager.java

@@ -0,0 +1,34 @@
+package com.ortiz.touch;
+
+import android.content.Context;
+import android.support.v4.view.ViewPager;
+import android.util.AttributeSet;
+import android.view.View;
+
+
+public class ExtendedViewPager extends ViewPager {
+
+	public ExtendedViewPager(Context context) {
+	    super(context);
+	}
+	
+	public ExtendedViewPager(Context context, AttributeSet attrs) {
+	    super(context, attrs);
+	}
+	
+	@Override
+	protected boolean canScroll(View v, boolean checkV, int dx, int x, int y) {
+	    if (v instanceof TouchImageView) {
+	    	//
+	    	// canScrollHorizontally is not supported for Api < 14. To get around this issue,
+	    	// ViewPager is extended and canScrollHorizontallyFroyo, a wrapper around
+	    	// canScrollHorizontally supporting Api >= 8, is called.
+	    	//
+	        return ((TouchImageView) v).canScrollHorizontallyFroyo(-dx);
+	        
+	    } else {
+	        return super.canScroll(v, checkV, dx, x, y);
+	    }
+	}
+
+}

src/main/java/com/ortiz/touch/TouchImageView.java

@@ -0,0 +1,1276 @@
+/*
+ * 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.ortiz.touch;
+
+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]);
+    }
+}