/*

* Copyright (C) 2011 Google Inc.

* Licensed to The Android Open Source Project.

*

* Licensed under the Apache License, Version 2.0 (the "License");

* you may not use this file except in compliance with the License.

* You may obtain a copy of the License at

*

* http://www.apache.org/licenses/LICENSE-2.0

*

* Unless required by applicable law or agreed to in writing, software

* distributed under the License is distributed on an "AS IS" BASIS,

* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

* See the License for the specific language governing permissions and

* limitations under the License.

*/

import android.content.Context;

import android.content.res.TypedArray;

import android.graphics.Bitmap;

import android.graphics.Canvas;

import android.graphics.Color;

import android.graphics.Matrix;

import android.graphics.Paint;

import android.graphics.Paint.Style;

import android.graphics.Rect;

import android.graphics.RectF;

import android.graphics.drawable.BitmapDrawable;

import android.graphics.drawable.Drawable;

import android.util.AttributeSet;

import android.view.GestureDetector.OnDoubleTapListener;

import android.view.GestureDetector.OnGestureListener;

import android.view.MotionEvent;

import android.view.ScaleGestureDetector;

import android.view.View;

import android.view.ViewConfiguration;

import androidx.core.view.GestureDetectorCompat;

import androidx.core.view.ScaleGestureDetectorCompat;

import frame.libsource.R;

/**

* Layout for the photo list view header.

* copy from com.android.ex.photo.views.PhotoView by 2021.02.07

*/

public class PhotoView extends View implements OnGestureListener,

OnDoubleTapListener, ScaleGestureDetector.OnScaleGestureListener {

public static final int TRANSLATE_NONE = 0;

public static final int TRANSLATE_X_ONLY = 1;

public static final int TRANSLATE_Y_ONLY = 2;

public static final int TRANSLATE_BOTH = 3;

/**

* Zoom animation duration; in milliseconds

*/

private final static long ZOOM_ANIMATION_DURATION = 200L;

/**

* Amount of time to wait after over-zooming before the zoom out animation; in milliseconds

*/

private static final long ZOOM_CORRECTION_DELAY = 600L;

/**

* Rotate animation duration; in milliseconds

*/

private final static long ROTATE_ANIMATION_DURATION = 500L;

/**

* Snap animation duration; in milliseconds

*/

private static final long SNAP_DURATION = 100L;

/**

* Amount of time to wait before starting snap animation; in milliseconds

*/

private static final long SNAP_DELAY = 250L;

/**

* By how much to scale the image when double click occurs

*/

private final static float DOUBLE_TAP_SCALE_FACTOR = 2.0f;

/**

* Amount which can be zoomed in past the maximum scale, and then scaled back

*/

private final static float SCALE_OVERZOOM_FACTOR = 1.5f;

/**

* Amount of translation needed before starting a snap animation

*/

private final static float SNAP_THRESHOLD = 20.0f;

/**

* The width & height of the bitmap returned by {@link #getCroppedPhoto()}

*/

private final static float CROPPED_SIZE = 256.0f;

/**

* Touch slop used to determine if this double tap is valid for starting a scale or should be

* ignored.

*/

private static int sTouchSlopSquare;

/**

* If {@code true}, the static values have been initialized

*/

private static boolean sInitialized;

// Various dimensions

/**

* Width & height of the crop region

*/

private static int sCropSize;

// Bitmaps

/**

* Video icon

*/

private static Bitmap sVideoImage;

/**

* Video icon

*/

private static Bitmap sVideoNotReadyImage;

// Paints

/**

* Paint to partially dim the photo during crop

*/

private static Paint sCropDimPaint;

/**

* Paint to highlight the cropped portion of the photo

*/

private static Paint sCropPaint;

/**

* The photo to display

*/

private Drawable mDrawable;

/**

* The matrix used for drawing; this may be {@code null}

*/

private Matrix mDrawMatrix;

/**

* A matrix to apply the scaling of the photo

*/

private Matrix mMatrix = new Matrix();

/**

* The original matrix for this image; used to reset any transformations applied by the user

*/

private Matrix mOriginalMatrix = new Matrix();

/**

* The fixed height of this view. If {@code -1}, calculate the height

*/

private int mFixedHeight = -1;

/**

* When {@code true}, the view has been laid out

*/

private boolean mHaveLayout;

/**

* Whether or not the photo is full-screen

*/

private boolean mFullScreen;

/**

* Whether or not this is a still image of a video

*/

private byte[] mVideoBlob;

/**

* Whether or not this is a still image of a video

*/

private boolean mVideoReady;

/**

* Whether or not crop is allowed

*/

private boolean mAllowCrop;

/**

* The crop region

*/

private Rect mCropRect = new Rect();

/**

* Actual crop size; may differ from {@link #sCropSize} if the screen is smaller

*/

private int mCropSize;

/**

* The maximum amount of scaling to apply to images

*/

private float mMaxInitialScaleFactor;

/**

* Gesture detector

*/

private GestureDetectorCompat mGestureDetector;

/**

* Gesture detector that detects pinch gestures

*/

private ScaleGestureDetector mScaleGetureDetector;

/**

* An external click listener

*/

private OnClickListener mExternalClickListener;

/**

* When {@code true}, allows gestures to scale / pan the image

*/

private boolean mTransformsEnabled;

// To support zooming

/**

* When {@code true}, a double tap scales the image by {@link #DOUBLE_TAP_SCALE_FACTOR}

*/

private boolean mDoubleTapToZoomEnabled = true;

/**

* When {@code true}, prevents scale end gesture from falsely triggering a double click.

*/

private boolean mDoubleTapDebounce;

/**

* When {@code false}, event is a scale gesture. Otherwise, event is a double touch.

*/

private boolean mIsDoubleTouch;

/**

* Runnable that scales the image

*/

private ScaleRunnable mScaleRunnable;

/**

* Minimum scale the image can have.

*/

private float mMinScale;

/**

* Maximum scale to limit scaling to, 0 means no limit.

*/

private float mMaxScale;

// To support translation [i.e. panning]

/**

* Runnable that can move the image

*/

private TranslateRunnable mTranslateRunnable;

private SnapRunnable mSnapRunnable;

// To support rotation

/**

* The rotate runnable used to animate rotations of the image

*/

private RotateRunnable mRotateRunnable;

/**

* The current rotation amount, in degrees

*/

private float mRotation;

// Convenience fields

// These are declared here not because they are important properties of the view. Rather, we

// declare them here to avoid object allocation during critical graphics operations; such as

// layout or drawing.

/**

* Source (i.e. the photo size) bounds

*/

private RectF mTempSrc = new RectF();

/**

* Destination (i.e. the display) bounds. The image is scaled to this size.

*/

private RectF mTempDst = new RectF();

/**

* Rectangle to handle translations

*/

private RectF mTranslateRect = new RectF();

/**

* Array to store a copy of the matrix values

*/

private float[] mValues = new float[9];

/**

* Track whether a double tap event occurred.

*/

private boolean mDoubleTapOccurred;

/**

* X and Y coordinates for the current down event. Since mDoubleTapOccurred only contains the

* information that there was a double tap event, use these to get the secondary tap

* information to determine if a user has moved beyond touch slop.

*/

private float mDownFocusX;

private float mDownFocusY;

/**

* Whether the QuickSale gesture is enabled.

*/

private boolean mQuickScaleEnabled;

public PhotoView(Context context) {

this(context, null);

}

public PhotoView(Context context, AttributeSet attrs) {

super(context, attrs, 0);

}

public PhotoView(Context context, AttributeSet attrs, int defStyle) {

super(context, attrs, defStyle);

initialize(context, attrs, defStyle);

}

@Override

public boolean onTouchEvent(MotionEvent event) {

if (mScaleGetureDetector == null || mGestureDetector == null) {

// We're being destroyed; ignore any touch events

return true;

}

mScaleGetureDetector.onTouchEvent(event);

mGestureDetector.onTouchEvent(event);

final int action = event.getAction();

switch (action) {

case MotionEvent.ACTION_UP:

case MotionEvent.ACTION_CANCEL:

if (!mTranslateRunnable.mRunning) {

snap();

}

break;

}

return true;

}

@Override

public boolean onDoubleTap(MotionEvent e) {

mDoubleTapOccurred = true;

if (!mQuickScaleEnabled) {

return scale(e);

}

return false;

}

@Override

public boolean onDoubleTapEvent(MotionEvent e) {

final int action = e.getAction();

boolean handled = false;

switch (action) {

case MotionEvent.ACTION_DOWN:

if (mQuickScaleEnabled) {

mDownFocusX = e.getX();

mDownFocusY = e.getY();

}

break;

case MotionEvent.ACTION_UP:

if (mQuickScaleEnabled) {

handled = scale(e);

}

break;

case MotionEvent.ACTION_MOVE:

if (mQuickScaleEnabled && mDoubleTapOccurred) {

final int deltaX = (int) (e.getX() - mDownFocusX);

final int deltaY = (int) (e.getY() - mDownFocusY);

int distance = (deltaX * deltaX) + (deltaY * deltaY);

if (distance > sTouchSlopSquare) {

mDoubleTapOccurred = false;

}

}

break;

}

return handled;

}

private boolean scale(MotionEvent e) {

boolean handled = false;

if (mDoubleTapToZoomEnabled && mTransformsEnabled && mDoubleTapOccurred) {

if (!mDoubleTapDebounce) {

float currentScale = getScale();

float targetScale;

float centerX, centerY;

// Zoom out if not default scale, otherwise zoom in

if (currentScale > mMinScale) {

targetScale = mMinScale;

float relativeScale = targetScale / currentScale;

// Find the apparent origin for scaling that equals this scale and translate

centerX = (getWidth() / 2 - relativeScale * mTranslateRect.centerX()) /

(1 - relativeScale);

centerY = (getHeight() / 2 - relativeScale * mTranslateRect.centerY()) /

(1 - relativeScale);

} else {

targetScale = currentScale * DOUBLE_TAP_SCALE_FACTOR;

// Ensure the target scale is within our bounds

targetScale = Math.max(mMinScale, targetScale);

targetScale = Math.min(mMaxScale, targetScale);

float relativeScale = targetScale / currentScale;

float widthBuffer = (getWidth() - mTranslateRect.width()) / relativeScale;

float heightBuffer = (getHeight() - mTranslateRect.height()) / relativeScale;

// Clamp the center if it would result in uneven borders

if (mTranslateRect.width() <= widthBuffer * 2) {

centerX = mTranslateRect.centerX();

} else {

centerX = Math.min(Math.max(mTranslateRect.left + widthBuffer,

e.getX()), mTranslateRect.right - widthBuffer);

}

if (mTranslateRect.height() <= heightBuffer * 2) {

centerY = mTranslateRect.centerY();

} else {

centerY = Math.min(Math.max(mTranslateRect.top + heightBuffer,

e.getY()), mTranslateRect.bottom - heightBuffer);

}

}

mScaleRunnable.start(currentScale, targetScale, centerX, centerY);

handled = true;

}

mDoubleTapDebounce = false;

}

mDoubleTapOccurred = false;

return handled;

}

@Override

public boolean onSingleTapConfirmed(MotionEvent e) {

if (mExternalClickListener != null && !mIsDoubleTouch) {

mExternalClickListener.onClick(this);

}

mIsDoubleTouch = false;

return true;

}

@Override

public boolean onSingleTapUp(MotionEvent e) {

return false;

}

@Override

public void onLongPress(MotionEvent e) {

}

@Override

public void onShowPress(MotionEvent e) {

}

@Override

public boolean onScroll(MotionEvent e1, MotionEvent e2, float distanceX, float distanceY) {

if (mTransformsEnabled && !mScaleRunnable.mRunning) {

translate(-distanceX, -distanceY);

}

return true;

}

@Override

public boolean onDown(MotionEvent e) {

if (mTransformsEnabled) {

mTranslateRunnable.stop();

mSnapRunnable.stop();

}

return true;

}

@Override

public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX, float velocityY) {

if (mTransformsEnabled && !mScaleRunnable.mRunning) {

mTranslateRunnable.start(velocityX, velocityY);

}

return true;

}

@Override

public boolean onScale(ScaleGestureDetector detector) {

if (mTransformsEnabled && !mScaleRunnable.mRunning) {

mIsDoubleTouch = false;

float currentScale = getScale();

float newScale = currentScale * detector.getScaleFactor();

scale(newScale, detector.getFocusX(), detector.getFocusY());

}

return true;

}

@Override

public boolean onScaleBegin(ScaleGestureDetector detector) {

if (mTransformsEnabled && !mScaleRunnable.mRunning) {

mScaleRunnable.stop();

mIsDoubleTouch = true;

}

return true;

}

@Override

public void onScaleEnd(ScaleGestureDetector detector) {

if (mTransformsEnabled && mIsDoubleTouch) {

mDoubleTapDebounce = true;

resetTransformations();

}

}

@Override

public void setOnClickListener(OnClickListener listener) {

mExternalClickListener = listener;

}

public boolean interceptMoveLeft(float origX, float origY) {

if (!mTransformsEnabled) {

// Allow intercept if we're not in transform mode

return false;

} else if (mTranslateRunnable.mRunning) {

// Don't allow touch intercept until we've stopped flinging

return true;

} else {

mMatrix.getValues(mValues);

mTranslateRect.set(mTempSrc);

mMatrix.mapRect(mTranslateRect);

final float viewWidth = getWidth();

final float transX = mValues[Matrix.MTRANS_X];

final float drawWidth = mTranslateRect.right - mTranslateRect.left;

if (!mTransformsEnabled || drawWidth <= viewWidth) {

// Allow intercept if not in transform mode or the image is smaller than the view

return false;

} else if (transX == 0) {

// We're at the left-side of the image; allow intercepting movements to the right

return false;

} else if (viewWidth >= drawWidth + transX) {

// We're at the right-side of the image; allow intercepting movements to the left

return true;

} else {

// We're in the middle of the image; don't allow touch intercept

return true;

}

}

}

public boolean interceptMoveRight(float origX, float origY) {

if (!mTransformsEnabled) {

// Allow intercept if we're not in transform mode

return false;

} else if (mTranslateRunnable.mRunning) {

// Don't allow touch intercept until we've stopped flinging

return true;

} else {

mMatrix.getValues(mValues);

mTranslateRect.set(mTempSrc);

mMatrix.mapRect(mTranslateRect);

final float viewWidth = getWidth();

final float transX = mValues[Matrix.MTRANS_X];

final float drawWidth = mTranslateRect.right - mTranslateRect.left;

if (!mTransformsEnabled || drawWidth <= viewWidth) {

// Allow intercept if not in transform mode or the image is smaller than the view

return false;

} else if (transX == 0) {

// We're at the left-side of the image; allow intercepting movements to the right

return true;

} else if (viewWidth >= drawWidth + transX) {

// We're at the right-side of the image; allow intercepting movements to the left

return false;

} else {

// We're in the middle of the image; don't allow touch intercept

return true;

}

}

}

/**

* Free all resources held by this view.

* The view is on its way to be collected and will not be reused.

*/

public void clear() {

mGestureDetector = null;

mScaleGetureDetector = null;

mDrawable = null;

mScaleRunnable.stop();

mScaleRunnable = null;

mTranslateRunnable.stop();

mTranslateRunnable = null;

mSnapRunnable.stop();

mSnapRunnable = null;

mRotateRunnable.stop();

mRotateRunnable = null;

setOnClickListener(null);

mExternalClickListener = null;

mDoubleTapOccurred = false;

}

public void bindDrawable(Drawable drawable) {

boolean changed = false;

if (drawable != null && drawable != mDrawable) {

// Clear previous state.

if (mDrawable != null) {

mDrawable.setCallback(null);

}

mDrawable = drawable;

// Reset mMinScale to ensure the bounds / matrix are recalculated

mMinScale = 0f;

// Set a callback?

mDrawable.setCallback(this);

changed = true;

}

configureBounds(changed);

invalidate();

}

/**

* Binds a bitmap to the view.

*

* @param photoBitmap the bitmap to bind.

*/

public void bindPhoto(Bitmap photoBitmap) {

boolean currentDrawableIsBitmapDrawable = mDrawable instanceof BitmapDrawable;

boolean changed = !(currentDrawableIsBitmapDrawable);

if (mDrawable != null && currentDrawableIsBitmapDrawable) {

final Bitmap drawableBitmap = ((BitmapDrawable) mDrawable).getBitmap();

if (photoBitmap == drawableBitmap) {

// setting the same bitmap; do nothing

return;

}

changed = photoBitmap != null &&

(mDrawable.getIntrinsicWidth() != photoBitmap.getWidth() ||

mDrawable.getIntrinsicHeight() != photoBitmap.getHeight());

// Reset mMinScale to ensure the bounds / matrix are recalculated

mMinScale = 0f;

mDrawable = null;

}

if (mDrawable == null && photoBitmap != null) {

mDrawable = new BitmapDrawable(getResources(), photoBitmap);

}

configureBounds(changed);

invalidate();

}

/**

* Returns the bound photo data if set. Otherwise, {@code null}.

*/

public Bitmap getPhoto() {

if (mDrawable != null && mDrawable instanceof BitmapDrawable) {

return ((BitmapDrawable) mDrawable).getBitmap();

}

return null;

}

/**

* Returns the bound drawable. May be {@code null} if no drawable is bound.

*/

public Drawable getDrawable() {

return mDrawable;

}

/**

* Gets video data associated with this item. Returns {@code null} if this is not a video.

*/

public byte[] getVideoData() {

return mVideoBlob;

}

/**

* Returns {@code true} if the photo represents a video. Otherwise, {@code false}.

*/

public boolean isVideo() {

return mVideoBlob != null;

}

/**

* Returns {@code true} if the video is ready to play. Otherwise, {@code false}.

*/

public boolean isVideoReady() {

return mVideoBlob != null && mVideoReady;

}

/**

* Returns {@code true} if a photo has been bound. Otherwise, {@code false}.

*/

public boolean isPhotoBound() {

return mDrawable != null;

}

/**

* Hides the photo info portion of the header. As a side effect, this automatically enables

* or disables image transformations [eg zoom, pan, etc...] depending upon the value of

* fullScreen. If this is not desirable, enable / disable image transformations manually.

*/

public void setFullScreen(boolean fullScreen, boolean animate) {

if (fullScreen != mFullScreen) {

mFullScreen = fullScreen;

requestLayout();

invalidate();

}

}

/**

* Enable or disable cropping of the displayed image. Cropping can only be enabled

* <em>before</em> the view has been laid out. Additionally, once cropping has been

* enabled, it cannot be disabled.

*/

public void enableAllowCrop(boolean allowCrop) {

if (allowCrop && mHaveLayout) {

throw new IllegalArgumentException("Cannot set crop after view has been laid out");

}

if (!allowCrop && mAllowCrop) {

throw new IllegalArgumentException("Cannot unset crop mode");

}

mAllowCrop = allowCrop;

}

/**

* Gets a bitmap of the cropped region. If cropping is not enabled, returns {@code null}.

*/

public Bitmap getCroppedPhoto() {

if (!mAllowCrop) {

return null;

}

final Bitmap croppedBitmap = Bitmap.createBitmap(

(int) CROPPED_SIZE, (int) CROPPED_SIZE, Bitmap.Config.ARGB_8888);

final Canvas croppedCanvas = new Canvas(croppedBitmap);

// scale for the final dimensions

final int cropWidth = mCropRect.right - mCropRect.left;

final float scaleWidth = CROPPED_SIZE / cropWidth;

final float scaleHeight = CROPPED_SIZE / cropWidth;

// translate to the origin & scale

final Matrix matrix = new Matrix(mDrawMatrix);

matrix.postTranslate(-mCropRect.left, -mCropRect.top);

matrix.postScale(scaleWidth, scaleHeight);

// draw the photo

if (mDrawable != null) {

croppedCanvas.concat(matrix);

mDrawable.draw(croppedCanvas);

}

return croppedBitmap;

}

/**

* Resets the image transformation to its original value.

*/

public void resetTransformations() {

// snap transformations; we don't animate

mMatrix.set(mOriginalMatrix);

// Invalidate the view because if you move off this PhotoView

// to another one and come back, you want it to draw from scratch

// in case you were zoomed in or translated (since those settings

// are not preserved and probably shouldn't be).

invalidate();

}

/**

* Rotates the image 90 degrees, clockwise.

*/

public void rotateClockwise() {

rotate(90, true);

}

/**

* Rotates the image 90 degrees, counter clockwise.

*/

public void rotateCounterClockwise() {

rotate(-90, true);

}

@Override

protected void onDraw(Canvas canvas) {

super.onDraw(canvas);

// draw the photo

if (mDrawable != null) {

int saveCount = canvas.getSaveCount();

canvas.save();

if (mDrawMatrix != null) {

canvas.concat(mDrawMatrix);

}

mDrawable.draw(canvas);

canvas.restoreToCount(saveCount);

if (mVideoBlob != null) {

final Bitmap videoImage = (mVideoReady ? sVideoImage : sVideoNotReadyImage);

final int drawLeft = (getWidth() - videoImage.getWidth()) / 2;

final int drawTop = (getHeight() - videoImage.getHeight()) / 2;

canvas.drawBitmap(videoImage, drawLeft, drawTop, null);

}

// Extract the drawable's bounds (in our own copy, to not alter the image)

mTranslateRect.set(mDrawable.getBounds());

if (mDrawMatrix != null) {

mDrawMatrix.mapRect(mTranslateRect);

}

if (mAllowCrop) {

int previousSaveCount = canvas.getSaveCount();

canvas.drawRect(0, 0, getWidth(), getHeight(), sCropDimPaint);

canvas.save();

canvas.clipRect(mCropRect);

if (mDrawMatrix != null) {

canvas.concat(mDrawMatrix);

}

mDrawable.draw(canvas);

canvas.restoreToCount(previousSaveCount);

canvas.drawRect(mCropRect, sCropPaint);

}

}

}

@Override

protected void onLayout(boolean changed, int left, int top, int right, int bottom) {

super.onLayout(changed, left, top, right, bottom);

mHaveLayout = true;

final int layoutWidth = getWidth();

final int layoutHeight = getHeight();

if (mAllowCrop) {

mCropSize = Math.min(sCropSize, Math.min(layoutWidth, layoutHeight));

final int cropLeft = (layoutWidth - mCropSize) / 2;

final int cropTop = (layoutHeight - mCropSize) / 2;

final int cropRight = cropLeft + mCropSize;

final int cropBottom = cropTop + mCropSize;

// Create a crop region overlay. We need a separate canvas to be able to "punch

// a hole" through to the underlying image.

mCropRect.set(cropLeft, cropTop, cropRight, cropBottom);

}

configureBounds(changed);

}

@Override

protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {

if (mFixedHeight != -1) {

super.onMeasure(widthMeasureSpec, MeasureSpec.makeMeasureSpec(mFixedHeight,

MeasureSpec.AT_MOST));

setMeasuredDimension(getMeasuredWidth(), mFixedHeight);

} else {

super.onMeasure(widthMeasureSpec, heightMeasureSpec);

}

}

@Override

public boolean verifyDrawable(Drawable drawable) {

return mDrawable == drawable || super.verifyDrawable(drawable);

}

@Override

/**

* {@inheritDoc}

*/

public void invalidateDrawable(Drawable drawable) {

// Only invalidate this view if the passed in drawable is displayed within this view. If

// another drawable is passed in, have the parent view handle invalidation.

if (mDrawable == drawable) {

invalidate();

} else {

super.invalidateDrawable(drawable);

}

}

/**

* Forces a fixed height for this view.

*

* @param fixedHeight The height. If {@code -1}, use the measured height.

*/

public void setFixedHeight(int fixedHeight) {

final boolean adjustBounds = (fixedHeight != mFixedHeight);

mFixedHeight = fixedHeight;

setMeasuredDimension(getMeasuredWidth(), mFixedHeight);

if (adjustBounds) {

configureBounds(true);

requestLayout();

}

}

/**

* Enable or disable image transformations. When transformations are enabled, this view

* consumes all touch events.

*/

public void enableImageTransforms(boolean enable) {

mTransformsEnabled = enable;

if (!mTransformsEnabled) {

resetTransformations();

}

}

/**

* Configures the bounds of the photo. The photo will always be scaled to fit center.

*/

private void configureBounds(boolean changed) {

if (mDrawable == null || !mHaveLayout) {

return;

}

final int dwidth = mDrawable.getIntrinsicWidth();

final int dheight = mDrawable.getIntrinsicHeight();

final int vwidth = getWidth();

final int vheight = getHeight();

final boolean fits = (dwidth < 0 || vwidth == dwidth) &&

(dheight < 0 || vheight == dheight);

// We need to do the scaling ourself, so have the drawable use its native size.

mDrawable.setBounds(0, 0, dwidth, dheight);

// Create a matrix with the proper transforms

if (changed || (mMinScale == 0 && mDrawable != null && mHaveLayout)) {

generateMatrix();

generateScale();

}

if (fits || mMatrix.isIdentity()) {

// The bitmap fits exactly, no transform needed.

mDrawMatrix = null;

} else {

mDrawMatrix = mMatrix;

}

}

/**

* Generates the initial transformation matrix for drawing. Additionally, it sets the

* minimum and maximum scale values.

*/

private void generateMatrix() {

final int dwidth = mDrawable.getIntrinsicWidth();

final int dheight = mDrawable.getIntrinsicHeight();

final int vwidth = mAllowCrop ? sCropSize : getWidth();

final int vheight = mAllowCrop ? sCropSize : getHeight();

final boolean fits = (dwidth < 0 || vwidth == dwidth) &&

(dheight < 0 || vheight == dheight);

if (fits && !mAllowCrop) {

mMatrix.reset();

} else {

// Generate the required transforms for the photo

mTempSrc.set(0, 0, dwidth, dheight);

if (mAllowCrop) {

mTempDst.set(mCropRect);

} else {

mTempDst.set(0, 0, vwidth, vheight);

}

RectF scaledDestination = new RectF(

(vwidth / 2) - (dwidth * mMaxInitialScaleFactor / 2),

(vheight / 2) - (dheight * mMaxInitialScaleFactor / 2),

(vwidth / 2) + (dwidth * mMaxInitialScaleFactor / 2),

(vheight / 2) + (dheight * mMaxInitialScaleFactor / 2));

if (mTempDst.contains(scaledDestination)) {

mMatrix.setRectToRect(mTempSrc, scaledDestination, Matrix.ScaleToFit.CENTER);

} else {

mMatrix.setRectToRect(mTempSrc, mTempDst, Matrix.ScaleToFit.CENTER);

}

}

mOriginalMatrix.set(mMatrix);

}

private void generateScale() {

final int dwidth = mDrawable.getIntrinsicWidth();

final int dheight = mDrawable.getIntrinsicHeight();

final int vwidth = mAllowCrop ? getCropSize() : getWidth();

final int vheight = mAllowCrop ? getCropSize() : getHeight();

if (dwidth < vwidth && dheight < vheight && !mAllowCrop) {

mMinScale = 1.0f;

} else {

mMinScale = getScale();

}

mMaxScale = Math.max(mMinScale * 4, 4);

}

/**

* @return the size of the crop regions

*/

private int getCropSize() {

return mCropSize > 0 ? mCropSize : sCropSize;

}

/**

* Returns the currently applied scale factor for the image.

* <p>

* NOTE: This method overwrites any values stored in {@link #mValues}.

*/

private float getScale() {

mMatrix.getValues(mValues);

return mValues[Matrix.MSCALE_X];

}

/**

* Scales the image while keeping the aspect ratio.

* <p>

* The given scale is capped so that the resulting scale of the image always remains

* between {@link #mMinScale} and {@link #mMaxScale}.

* <p>

* If the image is smaller than the viewable area, it will be centered.

*

* @param newScale the new scale

* @param centerX the center horizontal point around which to scale

* @param centerY the center vertical point around which to scale

*/

private void scale(float newScale, float centerX, float centerY) {

// Rotate back to the original orientation

mMatrix.postRotate(-mRotation, getWidth() / 2, getHeight() / 2);